|  | @@ -1,10 +1,9 @@
 | 
	
		
			
				|  |  |  smalltalk.addPackage('Compiler-Interpreter');
 | 
	
		
			
				|  |  |  smalltalk.addClass('AIContext', smalltalk.NodeVisitor, ['outerContext', 'pc', 'locals', 'method'], 'Compiler-Interpreter');
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_initializeFromMethodContext_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "initializeFromMethodContext:",
 | 
	
		
			
				|  |  | -fn: function (aMethodContext) {
 | 
	
		
			
				|  |  | +fn: function (aMethodContext){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
	
		
			
				|  | @@ -21,12 +20,11 @@ _st(_st(aMethodContext)._locals())._keysAndValuesDo_((function(key,value){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(_st(self)._locals())._at_put_(key,value);
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({key:key,value:value},$ctx1)})}));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"initializeFromMethodContext:",{aMethodContext:aMethodContext},smalltalk.AIContext)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"initializeFromMethodContext:",{aMethodContext:aMethodContext},smalltalk.AIContext)})},
 | 
	
		
			
				|  |  |  messageSends: ["pc:", "pc", "receiver:", "receiver", "method:", "method", "ifNotNil:", "outerContext:", "fromMethodContext:", "outerContext", "class", "keysAndValuesDo:", "at:put:", "locals"]}),
 | 
	
		
			
				|  |  |  smalltalk.AIContext);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_initializeLocals",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "initializeLocals",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
	
		
			
				|  | @@ -40,10 +38,9 @@ messageSends: ["new", "at:put:"]}),
 | 
	
		
			
				|  |  |  smalltalk.AIContext);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_localAt_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "localAt:",
 | 
	
		
			
				|  |  | -fn: function (aString) {
 | 
	
		
			
				|  |  | +fn: function (aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
	
		
			
				|  | @@ -52,24 +49,22 @@ return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return nil;
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"localAt:",{aString:aString},smalltalk.AIContext)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"localAt:",{aString:aString},smalltalk.AIContext)})},
 | 
	
		
			
				|  |  |  messageSends: ["at:ifAbsent:", "locals"]}),
 | 
	
		
			
				|  |  |  smalltalk.AIContext);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_localAt_put_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "localAt:put:",
 | 
	
		
			
				|  |  | -fn: function (aString, anObject) {
 | 
	
		
			
				|  |  | +fn: function (aString,anObject){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(_st(self)._locals())._at_put_(aString,anObject);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"localAt:put:",{aString:aString,anObject:anObject},smalltalk.AIContext)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"localAt:put:",{aString:aString,anObject:anObject},smalltalk.AIContext)})},
 | 
	
		
			
				|  |  |  messageSends: ["at:put:", "locals"]}),
 | 
	
		
			
				|  |  |  smalltalk.AIContext);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_locals",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "locals",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
	
		
			
				|  | @@ -89,62 +84,57 @@ messageSends: ["ifNil:", "initializeLocals"]}),
 | 
	
		
			
				|  |  |  smalltalk.AIContext);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_method",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "method",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=self["@method"];
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"method",{},smalltalk.AIContext)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"method",{},smalltalk.AIContext)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.AIContext);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_method_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "method:",
 | 
	
		
			
				|  |  | -fn: function (aCompiledMethod) {
 | 
	
		
			
				|  |  | +fn: function (aCompiledMethod){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  self["@method"]=aCompiledMethod;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"method:",{aCompiledMethod:aCompiledMethod},smalltalk.AIContext)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"method:",{aCompiledMethod:aCompiledMethod},smalltalk.AIContext)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.AIContext);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_outerContext",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "outerContext",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=self["@outerContext"];
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"outerContext",{},smalltalk.AIContext)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"outerContext",{},smalltalk.AIContext)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.AIContext);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_outerContext_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "outerContext:",
 | 
	
		
			
				|  |  | -fn: function (anAIContext) {
 | 
	
		
			
				|  |  | +fn: function (anAIContext){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  self["@outerContext"]=anAIContext;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"outerContext:",{anAIContext:anAIContext},smalltalk.AIContext)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"outerContext:",{anAIContext:anAIContext},smalltalk.AIContext)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.AIContext);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_pc",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "pc",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $2,$1;
 | 
	
	
		
			
				|  | @@ -156,50 +146,46 @@ $1=self["@pc"];
 | 
	
		
			
				|  |  |  $1=$2;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"pc",{},smalltalk.AIContext)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"pc",{},smalltalk.AIContext)})},
 | 
	
		
			
				|  |  |  messageSends: ["ifNil:"]}),
 | 
	
		
			
				|  |  |  smalltalk.AIContext);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_pc_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "pc:",
 | 
	
		
			
				|  |  | -fn: function (anInteger) {
 | 
	
		
			
				|  |  | +fn: function (anInteger){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  self["@pc"]=anInteger;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"pc:",{anInteger:anInteger},smalltalk.AIContext)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"pc:",{anInteger:anInteger},smalltalk.AIContext)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.AIContext);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_receiver",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "receiver",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(self)._localAt_("self");
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"receiver",{},smalltalk.AIContext)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"receiver",{},smalltalk.AIContext)})},
 | 
	
		
			
				|  |  |  messageSends: ["localAt:"]}),
 | 
	
		
			
				|  |  |  smalltalk.AIContext);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_receiver_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "receiver:",
 | 
	
		
			
				|  |  | -fn: function (anObject) {
 | 
	
		
			
				|  |  | +fn: function (anObject){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._localAt_put_("self",anObject);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"receiver:",{anObject:anObject},smalltalk.AIContext)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"receiver:",{anObject:anObject},smalltalk.AIContext)})},
 | 
	
		
			
				|  |  |  messageSends: ["localAt:put:"]}),
 | 
	
		
			
				|  |  |  smalltalk.AIContext);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_selector",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "selector",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
	
		
			
				|  | @@ -219,10 +205,9 @@ smalltalk.AIContext);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_fromMethodContext_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "fromMethodContext:",
 | 
	
		
			
				|  |  | -fn: function (aMethodContext) {
 | 
	
		
			
				|  |  | +fn: function (aMethodContext){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $2,$3,$1;
 | 
	
	
		
			
				|  | @@ -231,17 +216,16 @@ _st($2)._initializeFromMethodContext_(aMethodContext);
 | 
	
		
			
				|  |  |  $3=_st($2)._yourself();
 | 
	
		
			
				|  |  |  $1=$3;
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"fromMethodContext:",{aMethodContext:aMethodContext},smalltalk.AIContext.klass)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"fromMethodContext:",{aMethodContext:aMethodContext},smalltalk.AIContext.klass)})},
 | 
	
		
			
				|  |  |  messageSends: ["initializeFromMethodContext:", "new", "yourself"]}),
 | 
	
		
			
				|  |  |  smalltalk.AIContext.klass);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addClass('ASTDebugger', smalltalk.Object, ['interpreter', 'context'], 'Compiler-Interpreter');
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_buildAST",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "buildAST",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var ast;
 | 
	
		
			
				|  |  |  function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
 | 
	
	
		
			
				|  | @@ -252,83 +236,77 @@ ast=_st(_st($Smalltalk())._current())._parse_(_st(_st(self)._method())._source()
 | 
	
		
			
				|  |  |  _st(_st($SemanticAnalyzer())._on_(_st(_st(_st(self)._context())._receiver())._class()))._visit_(ast);
 | 
	
		
			
				|  |  |  $1=ast;
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"buildAST",{ast:ast},smalltalk.ASTDebugger)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"buildAST",{ast:ast},smalltalk.ASTDebugger)})},
 | 
	
		
			
				|  |  |  messageSends: ["parse:", "source", "method", "current", "visit:", "on:", "class", "receiver", "context"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_context",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "context",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=self["@context"];
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"context",{},smalltalk.ASTDebugger)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"context",{},smalltalk.ASTDebugger)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_context_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "context:",
 | 
	
		
			
				|  |  | -fn: function (aContext) {
 | 
	
		
			
				|  |  | +fn: function (aContext){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  function $AIContext(){return smalltalk.AIContext||(typeof AIContext=="undefined"?nil:AIContext)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  self["@context"]=_st($AIContext())._new();
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"context:",{aContext:aContext},smalltalk.ASTDebugger)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"context:",{aContext:aContext},smalltalk.ASTDebugger)})},
 | 
	
		
			
				|  |  |  messageSends: ["new"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_defaultInterpreterClass",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "defaultInterpreterClass",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  function $ASTSteppingInterpreter(){return smalltalk.ASTSteppingInterpreter||(typeof ASTSteppingInterpreter=="undefined"?nil:ASTSteppingInterpreter)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=$ASTSteppingInterpreter();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"defaultInterpreterClass",{},smalltalk.ASTDebugger)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"defaultInterpreterClass",{},smalltalk.ASTDebugger)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_initializeInterpreter",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "initializeInterpreter",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(_st(self)._interpreter())._interpret_(_st(_st(_st(self)._buildAST())._nodes())._first());
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"initializeInterpreter",{},smalltalk.ASTDebugger)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"initializeInterpreter",{},smalltalk.ASTDebugger)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpret:", "first", "nodes", "buildAST", "interpreter"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_initializeWithContext_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "initializeWithContext:",
 | 
	
		
			
				|  |  | -fn: function (aMethodContext) {
 | 
	
		
			
				|  |  | +fn: function (aMethodContext){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  function $AIContext(){return smalltalk.AIContext||(typeof AIContext=="undefined"?nil:AIContext)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._context_(_st($AIContext())._fromMethodContext_(aMethodContext));
 | 
	
		
			
				|  |  |  _st(self)._initializeInterpreter();
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"initializeWithContext:",{aMethodContext:aMethodContext},smalltalk.ASTDebugger)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"initializeWithContext:",{aMethodContext:aMethodContext},smalltalk.ASTDebugger)})},
 | 
	
		
			
				|  |  |  messageSends: ["context:", "fromMethodContext:", "initializeInterpreter"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $2,$1;
 | 
	
	
		
			
				|  | @@ -340,65 +318,60 @@ $1=self["@interpreter"];
 | 
	
		
			
				|  |  |  $1=$2;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter",{},smalltalk.ASTDebugger)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter",{},smalltalk.ASTDebugger)})},
 | 
	
		
			
				|  |  |  messageSends: ["ifNil:", "new", "defaultInterpreterClass"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  self["@interpreter"]=anInterpreter;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpreter:",{anInterpreter:anInterpreter},smalltalk.ASTDebugger)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpreter:",{anInterpreter:anInterpreter},smalltalk.ASTDebugger)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_method",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "method",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(_st(self)._context())._method();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"method",{},smalltalk.ASTDebugger)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"method",{},smalltalk.ASTDebugger)})},
 | 
	
		
			
				|  |  |  messageSends: ["method", "context"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_restart",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "restart",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._shouldBeImplemented();
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"restart",{},smalltalk.ASTDebugger)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"restart",{},smalltalk.ASTDebugger)})},
 | 
	
		
			
				|  |  |  messageSends: ["shouldBeImplemented"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_resume",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "resume",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._shouldBeImplemented();
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"resume",{},smalltalk.ASTDebugger)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"resume",{},smalltalk.ASTDebugger)})},
 | 
	
		
			
				|  |  |  messageSends: ["shouldBeImplemented"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_step",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "step",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st((function(){
 | 
	
	
		
			
				|  | @@ -415,40 +388,37 @@ return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  _st(_st(self)._interpreter())._step();
 | 
	
		
			
				|  |  |  return _st(self)._step();
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"step",{},smalltalk.ASTDebugger)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"step",{},smalltalk.ASTDebugger)})},
 | 
	
		
			
				|  |  |  messageSends: ["whileFalse:", "step", "interpreter", "or:", "not", "atEnd", "and:", "stopOnStepping", "nextNode", "notNil"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_stepInto",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "stepInto",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._shouldBeImplemented();
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"stepInto",{},smalltalk.ASTDebugger)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"stepInto",{},smalltalk.ASTDebugger)})},
 | 
	
		
			
				|  |  |  messageSends: ["shouldBeImplemented"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_stepOver",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "stepOver",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._step();
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"stepOver",{},smalltalk.ASTDebugger)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"stepOver",{},smalltalk.ASTDebugger)})},
 | 
	
		
			
				|  |  |  messageSends: ["step"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_context_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "context:",
 | 
	
		
			
				|  |  | -fn: function (aMethodContext) {
 | 
	
		
			
				|  |  | +fn: function (aMethodContext){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $2,$3,$1;
 | 
	
	
		
			
				|  | @@ -457,17 +427,16 @@ _st($2)._initializeWithContext_(aMethodContext);
 | 
	
		
			
				|  |  |  $3=_st($2)._yourself();
 | 
	
		
			
				|  |  |  $1=$3;
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"context:",{aMethodContext:aMethodContext},smalltalk.ASTDebugger.klass)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"context:",{aMethodContext:aMethodContext},smalltalk.ASTDebugger.klass)})},
 | 
	
		
			
				|  |  |  messageSends: ["initializeWithContext:", "new", "yourself"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTDebugger.klass);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addClass('ASTInterpreter', smalltalk.Object, ['currentNode', 'context', 'shouldReturn', 'result'], 'Compiler-Interpreter');
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_assign_to_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "assign:to:",
 | 
	
		
			
				|  |  | -fn: function (aNode, anObject) {
 | 
	
		
			
				|  |  | +fn: function (aNode,anObject){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $2,$1;
 | 
	
	
		
			
				|  | @@ -478,15 +447,14 @@ $1=_st(_st(_st(self)._context())._receiver())._instVarAt_put_(_st(aNode)._value(
 | 
	
		
			
				|  |  |  $1=_st(_st(self)._context())._localAt_put_(_st(aNode)._value(),anObject);
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"assign:to:",{aNode:aNode,anObject:anObject},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"assign:to:",{aNode:aNode,anObject:anObject},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["ifTrue:ifFalse:", "instVarAt:put:", "value", "receiver", "context", "localAt:put:", "isInstanceVar", "binding"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_context",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "context",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  function $AIContext(){return smalltalk.AIContext||(typeof AIContext=="undefined"?nil:AIContext)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
	
		
			
				|  | @@ -499,54 +467,50 @@ $1=self["@context"];
 | 
	
		
			
				|  |  |  $1=$2;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"context",{},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"context",{},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["ifNil:", "new"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_context_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "context:",
 | 
	
		
			
				|  |  | -fn: function (anAIContext) {
 | 
	
		
			
				|  |  | +fn: function (anAIContext){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  self["@context"]=anAIContext;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"context:",{anAIContext:anAIContext},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"context:",{anAIContext:anAIContext},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_continue_value_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "continue:value:",
 | 
	
		
			
				|  |  | -fn: function (aBlock, anObject) {
 | 
	
		
			
				|  |  | +fn: function (aBlock,anObject){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  self["@result"]=anObject;
 | 
	
		
			
				|  |  |  _st(aBlock)._value_(anObject);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"continue:value:",{aBlock:aBlock,anObject:anObject},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"continue:value:",{aBlock:aBlock,anObject:anObject},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["value:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_currentNode",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "currentNode",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=self["@currentNode"];
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"currentNode",{},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"currentNode",{},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_eval_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "eval:",
 | 
	
		
			
				|  |  | -fn: function (aString) {
 | 
	
		
			
				|  |  | +fn: function (aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var source,function_;
 | 
	
		
			
				|  |  |  function $String(){return smalltalk.String||(typeof String=="undefined"?nil:String)}
 | 
	
	
		
			
				|  | @@ -572,28 +536,26 @@ return $2;
 | 
	
		
			
				|  |  |  function_=_st(_st($Compiler())._new())._eval_(source);
 | 
	
		
			
				|  |  |  $3=_st(function_)._valueWithPossibleArguments_(_st(_st(_st(self)._context())._locals())._values());
 | 
	
		
			
				|  |  |  return $3;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"eval:",{aString:aString,source:source,function_:function_},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"eval:",{aString:aString,source:source,function_:function_},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["streamContents:", "nextPutAll:", "do:separatedBy:", "keys", "locals", "context", "eval:", "new", "valueWithPossibleArguments:", "values"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_initialize",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "initialize",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  smalltalk.Object.fn.prototype._initialize.apply(_st(self), []);
 | 
	
		
			
				|  |  |  self["@shouldReturn"]=false;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["initialize"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpret_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpret:",
 | 
	
		
			
				|  |  | -fn: function (aNode) {
 | 
	
		
			
				|  |  | +fn: function (aNode){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  self["@shouldReturn"]=false;
 | 
	
	
		
			
				|  | @@ -602,15 +564,14 @@ return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  self["@result"]=value;
 | 
	
		
			
				|  |  |  return self["@result"];
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({value:value},$ctx1)})}));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpret:",{aNode:aNode},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpret:",{aNode:aNode},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpret:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpret_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpret:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1,$2,$3;
 | 
	
	
		
			
				|  | @@ -630,28 +591,26 @@ return _st(self)._continue_value_(aBlock,value);
 | 
	
		
			
				|  |  |  } else {
 | 
	
		
			
				|  |  |  _st(self)._continue_value_(aBlock,aNode);
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpret:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpret:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["ifTrue:", "ifTrue:ifFalse:", "interpretNode:continue:", "continue:value:", "isNode"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretAll_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretAll:continue:",
 | 
	
		
			
				|  |  | -fn: function (aCollection, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aCollection,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  function $OrderedCollection(){return smalltalk.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._interpretAll_continue_result_(aCollection,aBlock,_st($OrderedCollection())._new());
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretAll:continue:",{aCollection:aCollection,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretAll:continue:",{aCollection:aCollection,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretAll:continue:result:", "new"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretAll_continue_result_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretAll:continue:result:",
 | 
	
		
			
				|  |  | -fn: function (nodes, aBlock, aCollection) {
 | 
	
		
			
				|  |  | +fn: function (nodes,aBlock,aCollection){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
	
		
			
				|  | @@ -664,27 +623,25 @@ return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(self)._interpretAll_continue_result_(_st(nodes)._allButFirst(),aBlock,_st(aCollection).__comma([value]));
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({value:value},$ctx1)})}));
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretAll:continue:result:",{nodes:nodes,aBlock:aBlock,aCollection:aCollection},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretAll:continue:result:",{nodes:nodes,aBlock:aBlock,aCollection:aCollection},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["ifTrue:ifFalse:", "continue:value:", "interpret:continue:", "first", "interpretAll:continue:result:", "allButFirst", ",", "isEmpty"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretAssignmentNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretAssignmentNode:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._interpret_continue_(_st(aNode)._right(),(function(value){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(self)._continue_value_(aBlock,_st(self)._assign_to_(_st(aNode)._left(),value));
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({value:value},$ctx1)})}));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretAssignmentNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretAssignmentNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpret:continue:", "right", "continue:value:", "assign:to:", "left"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretBlockNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretBlockNode:continue:",
 | 
	
		
			
				|  |  |  fn: function (aNode,aBlock){
 | 
	
	
		
			
				|  | @@ -706,22 +663,20 @@ messageSends: ["continue:value:", "withBlockContext:", "interpret:", "first", "n
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretBlockSequenceNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretBlockSequenceNode:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._interpretSequenceNode_continue_(aNode,aBlock);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretBlockSequenceNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretBlockSequenceNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretSequenceNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretCascadeNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretCascadeNode:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._interpret_continue_(_st(aNode)._receiver(),(function(receiver){
 | 
	
	
		
			
				|  | @@ -738,43 +693,40 @@ return _st(self)._continue_value_(aBlock,val);
 | 
	
		
			
				|  |  |  }, function($ctx4) {$ctx4.fillBlock({val:val},$ctx1)})}));
 | 
	
		
			
				|  |  |  }, function($ctx3) {$ctx3.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({receiver:receiver},$ctx1)})}));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretCascadeNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretCascadeNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpret:continue:", "receiver", "do:", "receiver:", "nodes", "interpretAll:continue:", "allButLast", "last", "continue:value:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretClassReferenceNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretClassReferenceNode:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._continue_value_(aBlock,_st(_st($Smalltalk())._current())._at_(_st(aNode)._value()));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretClassReferenceNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretClassReferenceNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["continue:value:", "at:", "value", "current"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretDynamicArrayNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretDynamicArrayNode:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._interpretAll_continue_(_st(aNode)._nodes(),(function(array){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(self)._continue_value_(aBlock,array);
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({array:array},$ctx1)})}));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretDynamicArrayNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretDynamicArrayNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretAll:continue:", "nodes", "continue:value:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretDynamicDictionaryNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretDynamicDictionaryNode:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  function $HashedCollection(){return smalltalk.HashedCollection||(typeof HashedCollection=="undefined"?nil:HashedCollection)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
	
		
			
				|  | @@ -789,55 +741,51 @@ return _st(hashedCollection)._add_(each);
 | 
	
		
			
				|  |  |  }, function($ctx3) {$ctx3.fillBlock({each:each},$ctx1)})}));
 | 
	
		
			
				|  |  |  return _st(self)._continue_value_(aBlock,hashedCollection);
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({array:array,hashedCollection:hashedCollection},$ctx1)})}));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretDynamicDictionaryNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretDynamicDictionaryNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretAll:continue:", "nodes", "new", "do:", "add:", "continue:value:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretJSStatementNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretJSStatementNode:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  self["@shouldReturn"]=true;
 | 
	
		
			
				|  |  |  _st(self)._continue_value_(aBlock,_st(self)._eval_(_st(aNode)._source()));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretJSStatementNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretJSStatementNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["continue:value:", "eval:", "source"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretMethodNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretMethodNode:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._interpretAll_continue_(_st(aNode)._nodes(),(function(array){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(self)._continue_value_(aBlock,_st(array)._first());
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({array:array},$ctx1)})}));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretMethodNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretMethodNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretAll:continue:", "nodes", "continue:value:", "first"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretNode:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(aNode)._interpreter_continue_(self,aBlock);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpreter:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretReturnNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretReturnNode:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._interpret_continue_(_st(_st(aNode)._nodes())._first(),(function(value){
 | 
	
	
		
			
				|  | @@ -846,15 +794,14 @@ self["@shouldReturn"]=true;
 | 
	
		
			
				|  |  |  self["@shouldReturn"];
 | 
	
		
			
				|  |  |  return _st(self)._continue_value_(aBlock,value);
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({value:value},$ctx1)})}));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretReturnNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretReturnNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpret:continue:", "first", "nodes", "continue:value:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretSendNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretSendNode:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._interpret_continue_(_st(aNode)._receiver(),(function(receiver){
 | 
	
	
		
			
				|  | @@ -868,42 +815,39 @@ return _st(self)._continue_value_(aBlock,_st(message)._sendTo_(receiver));
 | 
	
		
			
				|  |  |  }, function($ctx4) {$ctx4.fillBlock({message:message},$ctx1)})}));
 | 
	
		
			
				|  |  |  }, function($ctx3) {$ctx3.fillBlock({args:args},$ctx1)})}));
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({receiver:receiver},$ctx1)})}));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretSendNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretSendNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpret:continue:", "receiver", "interpretAll:continue:", "arguments", "messageFromSendNode:arguments:do:", "pc:", "+", "pc", "context", "continue:value:", "sendTo:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretSequenceNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretSequenceNode:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._interpretAll_continue_(_st(aNode)._nodes(),(function(array){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(self)._continue_value_(aBlock,_st(array)._last());
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({array:array},$ctx1)})}));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretSequenceNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretSequenceNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretAll:continue:", "nodes", "continue:value:", "last"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretValueNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretValueNode:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self)._continue_value_(aBlock,_st(aNode)._value());
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretValueNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretValueNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["continue:value:", "value"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpretVariableNode_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpretVariableNode:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1,$2,$4,$3;
 | 
	
	
		
			
				|  | @@ -916,15 +860,14 @@ $3=_st(_st(_st(self)._context())._receiver())._instVarAt_(_st(aNode)._value());
 | 
	
		
			
				|  |  |  $3=_st(_st(self)._context())._localAt_(_st(aNode)._value());
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  _st($1)._continue_value_($2,$3);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpretVariableNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpretVariableNode:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["continue:value:", "ifTrue:ifFalse:", "instVarAt:", "value", "receiver", "context", "localAt:", "isInstanceVar", "binding"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_messageFromSendNode_arguments_do_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "messageFromSendNode:arguments:do:",
 | 
	
		
			
				|  |  | -fn: function (aSendNode, aCollection, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aSendNode,aCollection,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  function $Message(){return smalltalk.Message||(typeof Message=="undefined"?nil:Message)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
	
		
			
				|  | @@ -934,29 +877,27 @@ _st($1)._selector_(_st(aSendNode)._selector());
 | 
	
		
			
				|  |  |  _st($1)._arguments_(aCollection);
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  |  _st(self)._continue_value_(aBlock,$2);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"messageFromSendNode:arguments:do:",{aSendNode:aSendNode,aCollection:aCollection,aBlock:aBlock},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"messageFromSendNode:arguments:do:",{aSendNode:aSendNode,aCollection:aCollection,aBlock:aBlock},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["continue:value:", "selector:", "selector", "new", "arguments:", "yourself"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_result",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "result",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=self["@result"];
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"result",{},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"result",{},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_shouldReturn",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "shouldReturn",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $2,$1;
 | 
	
	
		
			
				|  | @@ -967,12 +908,11 @@ $1=false;
 | 
	
		
			
				|  |  |  $1=$2;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"shouldReturn",{},smalltalk.ASTInterpreter)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"shouldReturn",{},smalltalk.ASTInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["ifNil:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_withBlockContext_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "withBlockContext:",
 | 
	
		
			
				|  |  |  fn: function (aBlock){
 | 
	
	
		
			
				|  | @@ -997,10 +937,9 @@ smalltalk.ASTInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addClass('ASTSteppingInterpreter', smalltalk.ASTInterpreter, ['continuation', 'nextNode'], 'Compiler-Interpreter');
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_atEnd",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "atEnd",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
	
		
			
				|  | @@ -1009,30 +948,28 @@ return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(_st(self)._nextNode()).__eq_eq(_st(self)._currentNode());
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"atEnd",{},smalltalk.ASTSteppingInterpreter)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"atEnd",{},smalltalk.ASTSteppingInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["or:", "==", "currentNode", "nextNode", "shouldReturn"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTSteppingInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_initialize",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "initialize",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreter.fn.prototype._initialize.apply(_st(self), []);
 | 
	
		
			
				|  |  |  self["@continuation"]=(function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})});
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.ASTSteppingInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.ASTSteppingInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["initialize"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTSteppingInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpret_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpret:continue:",
 | 
	
		
			
				|  |  | -fn: function (aNode, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (aNode,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  self["@nextNode"]=aNode;
 | 
	
	
		
			
				|  | @@ -1040,329 +977,305 @@ self["@continuation"]=(function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return smalltalk.ASTInterpreter.fn.prototype._interpret_continue_.apply(_st(self), [aNode,aBlock]);
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})});
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"interpret:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTSteppingInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"interpret:continue:",{aNode:aNode,aBlock:aBlock},smalltalk.ASTSteppingInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpret:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTSteppingInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_nextNode",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "nextNode",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=self["@nextNode"];
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"nextNode",{},smalltalk.ASTSteppingInterpreter)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"nextNode",{},smalltalk.ASTSteppingInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.ASTSteppingInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_step",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "step",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self["@continuation"])._value();
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"step",{},smalltalk.ASTSteppingInterpreter)});},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"step",{},smalltalk.ASTSteppingInterpreter)})},
 | 
	
		
			
				|  |  |  messageSends: ["value"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTSteppingInterpreter);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.Node)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.Node)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.Node);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_isSteppingNode",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "isSteppingNode",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  return false;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"isSteppingNode",{},smalltalk.Node)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"isSteppingNode",{},smalltalk.Node)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.Node);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretAssignmentNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.AssignmentNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.AssignmentNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretAssignmentNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.AssignmentNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_isSteppingNode",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "isSteppingNode",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  return true;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"isSteppingNode",{},smalltalk.AssignmentNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"isSteppingNode",{},smalltalk.AssignmentNode)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.AssignmentNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretBlockNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.BlockNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.BlockNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretBlockNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.BlockNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_isSteppingNode",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "isSteppingNode",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  return true;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"isSteppingNode",{},smalltalk.BlockNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"isSteppingNode",{},smalltalk.BlockNode)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.BlockNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretCascadeNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.CascadeNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.CascadeNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretCascadeNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.CascadeNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretDynamicArrayNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.DynamicArrayNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.DynamicArrayNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretDynamicArrayNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.DynamicArrayNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_isSteppingNode",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "isSteppingNode",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  return true;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"isSteppingNode",{},smalltalk.DynamicArrayNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"isSteppingNode",{},smalltalk.DynamicArrayNode)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.DynamicArrayNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretDynamicDictionaryNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.DynamicDictionaryNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.DynamicDictionaryNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretDynamicDictionaryNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.DynamicDictionaryNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_isSteppingNode",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "isSteppingNode",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  return true;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"isSteppingNode",{},smalltalk.DynamicDictionaryNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"isSteppingNode",{},smalltalk.DynamicDictionaryNode)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.DynamicDictionaryNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretJSStatementNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.JSStatementNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.JSStatementNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretJSStatementNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.JSStatementNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_isSteppingNode",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "isSteppingNode",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  return true;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"isSteppingNode",{},smalltalk.JSStatementNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"isSteppingNode",{},smalltalk.JSStatementNode)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.JSStatementNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretMethodNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.MethodNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.MethodNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretMethodNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.MethodNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretReturnNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.ReturnNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.ReturnNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretReturnNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ReturnNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretSendNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.SendNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.SendNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretSendNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.SendNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_isSteppingNode",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "isSteppingNode",
 | 
	
		
			
				|  |  | -fn: function () {
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  return true;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"isSteppingNode",{},smalltalk.SendNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"isSteppingNode",{},smalltalk.SendNode)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.SendNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretSequenceNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.SequenceNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.SequenceNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretSequenceNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.SequenceNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretBlockSequenceNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.BlockSequenceNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.BlockSequenceNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretBlockSequenceNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.BlockSequenceNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretValueNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.ValueNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.ValueNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretValueNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ValueNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretVariableNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.VariableNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.VariableNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretVariableNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.VariableNode);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_interpreter_continue_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter:continue:",
 | 
	
		
			
				|  |  | -fn: function (anInterpreter, aBlock) {
 | 
	
		
			
				|  |  | +fn: function (anInterpreter,aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  |  $1=_st(anInterpreter)._interpretClassReferenceNode_continue_(self,aBlock);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.ClassReferenceNode)});},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"interpreter:continue:",{anInterpreter:anInterpreter,aBlock:aBlock},smalltalk.ClassReferenceNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpretClassReferenceNode:continue:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ClassReferenceNode);
 | 
	
		
			
				|  |  |  
 |