package threading
import (
	πg "grumpy"
	π_reflect "reflect"
	π_sync "sync"
)
func initModule(πF *πg.Frame, _ []*πg.Object) (*πg.Object, *πg.BaseException) {
	ßBroadcast := πg.InternStr("Broadcast")
	ßEvent := πg.InternStr("Event")
	ßFalse := πg.InternStr("False")
	ßLock := πg.InternStr("Lock")
	ßMutex := πg.InternStr("Mutex")
	ßNewCond := πg.InternStr("NewCond")
	ßNone := πg.InternStr("None")
	ßStartThread := πg.InternStr("StartThread")
	ßThread := πg.InternStr("Thread")
	ßTrue := πg.InternStr("True")
	ßUnlock := πg.InternStr("Unlock")
	ßWait := πg.InternStr("Wait")
	ß__init__ := πg.InternStr("__init__")
	ß__metaclass__ := πg.InternStr("__metaclass__")
	ß__module__ := πg.InternStr("__module__")
	ß__name__ := πg.InternStr("__name__")
	ß_args := πg.InternStr("_args")
	ß_cond := πg.InternStr("_cond")
	ß_event := πg.InternStr("_event")
	ß_is_set := πg.InternStr("_is_set")
	ß_mutex := πg.InternStr("_mutex")
	ß_run := πg.InternStr("_run")
	ß_target := πg.InternStr("_target")
	ßjoin := πg.InternStr("join")
	ßnew := πg.InternStr("new")
	ßobject := πg.InternStr("object")
	ßrun := πg.InternStr("run")
	ßset := πg.InternStr("set")
	ßstart := πg.InternStr("start")
	ßwait := πg.InternStr("wait")
	var πTemp001 *πg.Object
	_ = πTemp001
	var πTemp002 map[string]*πg.Object
	_ = πTemp002
	var πTemp003 *πg.Object
	_ = πTemp003
	var πTemp004 π_sync.Mutex
	_ = πTemp004
	var πTemp005 *πg.Dict
	_ = πTemp005
	var πTemp006 []*πg.Object
	_ = πTemp006
	var πTemp007 *πg.Object
	_ = πTemp007
	var πE *πg.BaseException; _ = πE
	for ; πF.State() >= 0; πF.PopCheckpoint() {
		switch πF.State() {
		case 0:
		default: panic("unexpected function state")
		}
		// line 15: """Concurrent programming functionality."""
		πF.SetLineno(15)
		// line 17: from __go__.grumpy import StartThread
		πF.SetLineno(17)
		πTemp002 = map[string]*πg.Object{}
		if πTemp003, πE = πg.WrapNative(πF, π_reflect.ValueOf(πg.StartThread)); πE != nil {
			continue
		}
		πTemp002["StartThread"] = πTemp003
		if πTemp001, πE = πg.ImportNativeModule(πF, "__go__.grumpy", πTemp002); πE != nil {
			continue
		}
		if πTemp003, πE = πg.GetAttr(πF, πTemp001, ßStartThread, nil); πE != nil {
			continue
		}
		if πE = πF.Globals().SetItem(πF, ßStartThread.ToObject(), πTemp003); πE != nil {
			continue
		}
		// line 18: from __go__.sync import NewCond, type_Mutex as Mutex
		πF.SetLineno(18)
		πTemp002 = map[string]*πg.Object{}
		if πTemp003, πE = πg.WrapNative(πF, π_reflect.ValueOf(π_sync.NewCond)); πE != nil {
			continue
		}
		πTemp002["NewCond"] = πTemp003
		if πTemp003, πE = πg.WrapNative(πF, π_reflect.ValueOf(πTemp004)); πE != nil {
			continue
		}
		πTemp003 = πTemp003.Type().ToObject()
		πTemp002["Mutex"] = πTemp003
		if πTemp001, πE = πg.ImportNativeModule(πF, "__go__.sync", πTemp002); πE != nil {
			continue
		}
		if πTemp003, πE = πg.GetAttr(πF, πTemp001, ßNewCond, nil); πE != nil {
			continue
		}
		if πE = πF.Globals().SetItem(πF, ßNewCond.ToObject(), πTemp003); πE != nil {
			continue
		}
		if πTemp003, πE = πg.GetAttr(πF, πTemp001, ßMutex, nil); πE != nil {
			continue
		}
		if πE = πF.Globals().SetItem(πF, ßMutex.ToObject(), πTemp003); πE != nil {
			continue
		}
		// line 21: class Event(object):
		πF.SetLineno(21)
		πTemp006 = make([]*πg.Object, 1)
		if πTemp007, πE = πg.ResolveGlobal(πF, ßobject); πE != nil {
			continue
		}
		πTemp006[0] = πTemp007
		πTemp005 = πg.NewDict()
		if πTemp001, πE = πF.Globals().GetItem(πF, ß__name__.ToObject()); πE != nil {
			continue
		}
		if πE = πTemp005.SetItem(πF, ß__module__.ToObject(), πTemp001); πE != nil {
			continue
		}
		_, πE = πg.NewCode("Event", "lib/threading.py", nil, 0, func(πF *πg.Frame, _ []*πg.Object) (*πg.Object, *πg.BaseException) {
			πClass := πTemp005
			_ = πClass
			var πTemp001 *πg.Object
			_ = πTemp001
			var πTemp002 []πg.FunctionArg
			_ = πTemp002
			var πTemp003 *πg.Object
			_ = πTemp003
			var πTemp004 *πg.Object
			_ = πTemp004
			var πE *πg.BaseException; _ = πE
			for ; πF.State() >= 0; πF.PopCheckpoint() {
				switch πF.State() {
				case 0:
				default: panic("unexpected function state")
				}
				// line 22: """Event is a way to signal conditions between threads."""
				πF.SetLineno(22)
				// line 24: def __init__(self):
				πF.SetLineno(24)
				πTemp002 = make([]πg.FunctionArg, 1)
				πTemp002[0] = πg.FunctionArg{Name: "self", Def: nil}
				πTemp001 = πg.NewFunction(πg.NewCode("__init__", "lib/threading.py", πTemp002, 0, func(πF *πg.Frame, πArgs []*πg.Object) (*πg.Object, *πg.BaseException) {
					var µself *πg.Object = πArgs[0]; _ = µself
					var πTemp001 *πg.Object
					_ = πTemp001
					var πTemp002 *πg.Object
					_ = πTemp002
					var πTemp003 []*πg.Object
					_ = πTemp003
					var πE *πg.BaseException; _ = πE
					for ; πF.State() >= 0; πF.PopCheckpoint() {
						switch πF.State() {
						case 0:
						default: panic("unexpected function state")
						}
						// line 25: self._mutex = Mutex.new()
						πF.SetLineno(25)
						if πTemp001, πE = πg.ResolveGlobal(πF, ßMutex); πE != nil {
							continue
						}
						if πTemp002, πE = πg.GetAttr(πF, πTemp001, ßnew, nil); πE != nil {
							continue
						}
						if πTemp001, πE = πTemp002.Call(πF, nil, nil); πE != nil {
							continue
						}
						if πE = πg.Tie(πF, πg.TieTarget{Target: &πTemp002}, πTemp001); πE != nil {
							continue
						}
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πE = πg.SetAttr(πF, µself, ß_mutex, πTemp002); πE != nil {
							continue
						}
						// line 26: self._cond = NewCond(self._mutex)
						πF.SetLineno(26)
						πTemp003 = πF.MakeArgs(1)
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πTemp001, πE = πg.GetAttr(πF, µself, ß_mutex, nil); πE != nil {
							continue
						}
						πTemp003[0] = πTemp001
						if πTemp001, πE = πg.ResolveGlobal(πF, ßNewCond); πE != nil {
							continue
						}
						if πTemp002, πE = πTemp001.Call(πF, πTemp003, nil); πE != nil {
							continue
						}
						πF.FreeArgs(πTemp003)
						if πE = πg.Tie(πF, πg.TieTarget{Target: &πTemp001}, πTemp002); πE != nil {
							continue
						}
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πE = πg.SetAttr(πF, µself, ß_cond, πTemp001); πE != nil {
							continue
						}
						// line 27: self._is_set = False
						πF.SetLineno(27)
						if πTemp001, πE = πg.ResolveGlobal(πF, ßFalse); πE != nil {
							continue
						}
						if πE = πg.Tie(πF, πg.TieTarget{Target: &πTemp002}, πTemp001); πE != nil {
							continue
						}
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πE = πg.SetAttr(πF, µself, ß_is_set, πTemp002); πE != nil {
							continue
						}
						return nil, nil
					}
					return nil, πE
				}), πF.Globals()).ToObject()
				if πE = πClass.SetItem(πF, ß__init__.ToObject(), πTemp001); πE != nil {
					continue
				}
				// line 29: def set(self):
				πF.SetLineno(29)
				πTemp002 = make([]πg.FunctionArg, 1)
				πTemp002[0] = πg.FunctionArg{Name: "self", Def: nil}
				πTemp003 = πg.NewFunction(πg.NewCode("set", "lib/threading.py", πTemp002, 0, func(πF *πg.Frame, πArgs []*πg.Object) (*πg.Object, *πg.BaseException) {
					var µself *πg.Object = πArgs[0]; _ = µself
					var πTemp001 *πg.Object
					_ = πTemp001
					var πTemp002 *πg.Object
					_ = πTemp002
					var πTemp003 *πg.BaseException
					_ = πTemp003
					var πTemp004 *πg.Traceback
					_ = πTemp004
					var πE *πg.BaseException; _ = πE
					for ; πF.State() >= 0; πF.PopCheckpoint() {
						switch πF.State() {
						case 0:
						case 1: goto Label1
						default: panic("unexpected function state")
						}
						// line 30: self._mutex.Lock()
						πF.SetLineno(30)
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πTemp001, πE = πg.GetAttr(πF, µself, ß_mutex, nil); πE != nil {
							continue
						}
						if πTemp002, πE = πg.GetAttr(πF, πTemp001, ßLock, nil); πE != nil {
							continue
						}
						if πTemp001, πE = πTemp002.Call(πF, nil, nil); πE != nil {
							continue
						}
						// line 31: try:
						πF.SetLineno(31)
						πF.PushCheckpoint(1)
						// line 32: self._is_set = True
						πF.SetLineno(32)
						if πTemp001, πE = πg.ResolveGlobal(πF, ßTrue); πE != nil {
							continue
						}
						if πE = πg.Tie(πF, πg.TieTarget{Target: &πTemp002}, πTemp001); πE != nil {
							continue
						}
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πE = πg.SetAttr(πF, µself, ß_is_set, πTemp002); πE != nil {
							continue
						}
						πF.PopCheckpoint()
					Label1:
						πE = nil
						πTemp003, πTemp004 = πF.RestoreExc(nil, nil)
						// line 34: self._mutex.Unlock()
						πF.SetLineno(34)
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πTemp001, πE = πg.GetAttr(πF, µself, ß_mutex, nil); πE != nil {
							continue
						}
						if πTemp002, πE = πg.GetAttr(πF, πTemp001, ßUnlock, nil); πE != nil {
							continue
						}
						if πTemp001, πE = πTemp002.Call(πF, nil, nil); πE != nil {
							continue
						}
						if πTemp003 != nil {
							πE = πF.Raise(πTemp003.ToObject(), nil, πTemp004.ToObject())
							continue
						}
						// line 35: self._cond.Broadcast()
						πF.SetLineno(35)
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πTemp001, πE = πg.GetAttr(πF, µself, ß_cond, nil); πE != nil {
							continue
						}
						if πTemp002, πE = πg.GetAttr(πF, πTemp001, ßBroadcast, nil); πE != nil {
							continue
						}
						if πTemp001, πE = πTemp002.Call(πF, nil, nil); πE != nil {
							continue
						}
						return nil, nil
					}
					return nil, πE
				}), πF.Globals()).ToObject()
				if πE = πClass.SetItem(πF, ßset.ToObject(), πTemp003); πE != nil {
					continue
				}
				// line 38: def wait(self):
				πF.SetLineno(38)
				πTemp002 = make([]πg.FunctionArg, 1)
				πTemp002[0] = πg.FunctionArg{Name: "self", Def: nil}
				πTemp004 = πg.NewFunction(πg.NewCode("wait", "lib/threading.py", πTemp002, 0, func(πF *πg.Frame, πArgs []*πg.Object) (*πg.Object, *πg.BaseException) {
					var µself *πg.Object = πArgs[0]; _ = µself
					var πTemp001 *πg.Object
					_ = πTemp001
					var πTemp002 *πg.Object
					_ = πTemp002
					var πTemp003 bool
					_ = πTemp003
					var πTemp004 *πg.Object
					_ = πTemp004
					var πTemp005 *πg.BaseException
					_ = πTemp005
					var πTemp006 *πg.Traceback
					_ = πTemp006
					var πE *πg.BaseException; _ = πE
					for ; πF.State() >= 0; πF.PopCheckpoint() {
						switch πF.State() {
						case 0:
						case 1: goto Label1
						default: panic("unexpected function state")
						}
						// line 39: self._mutex.Lock()
						πF.SetLineno(39)
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πTemp001, πE = πg.GetAttr(πF, µself, ß_mutex, nil); πE != nil {
							continue
						}
						if πTemp002, πE = πg.GetAttr(πF, πTemp001, ßLock, nil); πE != nil {
							continue
						}
						if πTemp001, πE = πTemp002.Call(πF, nil, nil); πE != nil {
							continue
						}
						// line 40: try:
						πF.SetLineno(40)
						πF.PushCheckpoint(1)
						// line 41: while not self._is_set:
						πF.SetLineno(41)
					Label2:
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πTemp002, πE = πg.GetAttr(πF, µself, ß_is_set, nil); πE != nil {
							continue
						}
						if πTemp003, πE = πg.IsTrue(πF, πTemp002); πE != nil {
							continue
						}
						πTemp001 = πg.GetBool(!πTemp003).ToObject()
						if πTemp003, πE = πg.IsTrue(πF, πTemp001); πE != nil {
							continue
						}
						if !πTemp003 {
							goto Label3
						}
						// line 42: self._cond.Wait()
						πF.SetLineno(42)
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πTemp002, πE = πg.GetAttr(πF, µself, ß_cond, nil); πE != nil {
							continue
						}
						if πTemp004, πE = πg.GetAttr(πF, πTemp002, ßWait, nil); πE != nil {
							continue
						}
						if πTemp002, πE = πTemp004.Call(πF, nil, nil); πE != nil {
							continue
						}
						goto Label2
						goto Label3
					Label3:
						πF.PopCheckpoint()
					Label1:
						πE = nil
						πTemp005, πTemp006 = πF.RestoreExc(nil, nil)
						// line 44: self._mutex.Unlock()
						πF.SetLineno(44)
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πTemp001, πE = πg.GetAttr(πF, µself, ß_mutex, nil); πE != nil {
							continue
						}
						if πTemp002, πE = πg.GetAttr(πF, πTemp001, ßUnlock, nil); πE != nil {
							continue
						}
						if πTemp001, πE = πTemp002.Call(πF, nil, nil); πE != nil {
							continue
						}
						if πTemp005 != nil {
							πE = πF.Raise(πTemp005.ToObject(), nil, πTemp006.ToObject())
							continue
						}
						// line 45: return True
						πF.SetLineno(45)
						if πTemp001, πE = πg.ResolveGlobal(πF, ßTrue); πE != nil {
							continue
						}
						return πTemp001, nil
						return nil, nil
					}
					return nil, πE
				}), πF.Globals()).ToObject()
				if πE = πClass.SetItem(πF, ßwait.ToObject(), πTemp004); πE != nil {
					continue
				}
				return nil, nil
			}
			return nil, πE
		}).Eval(πF, πF.Globals(), nil, nil)
		if πE != nil {
			return nil, πE
		}
		if πTemp003, πE = πTemp005.GetItem(πF, ß__metaclass__.ToObject()); πE != nil {
			return nil, πE
		}
		if πTemp003 == nil {
			πTemp003 = πg.TypeType.ToObject()
		}
		if πTemp007, πE = πTemp003.Call(πF, []*πg.Object{πg.NewStr("Event").ToObject(), πg.NewTuple(πTemp006...).ToObject(), πTemp005.ToObject()}, nil); πE != nil {
			continue
		}
		if πE = πF.Globals().SetItem(πF, ßEvent.ToObject(), πTemp007); πE != nil {
			continue
		}
		// line 48: class Thread(object):
		πF.SetLineno(48)
		πTemp006 = make([]*πg.Object, 1)
		if πTemp007, πE = πg.ResolveGlobal(πF, ßobject); πE != nil {
			continue
		}
		πTemp006[0] = πTemp007
		πTemp005 = πg.NewDict()
		if πTemp001, πE = πF.Globals().GetItem(πF, ß__name__.ToObject()); πE != nil {
			continue
		}
		if πE = πTemp005.SetItem(πF, ß__module__.ToObject(), πTemp001); πE != nil {
			continue
		}
		_, πE = πg.NewCode("Thread", "lib/threading.py", nil, 0, func(πF *πg.Frame, _ []*πg.Object) (*πg.Object, *πg.BaseException) {
			πClass := πTemp005
			_ = πClass
			var πTemp001 *πg.Object
			_ = πTemp001
			var πTemp002 []πg.FunctionArg
			_ = πTemp002
			var πTemp003 *πg.Object
			_ = πTemp003
			var πTemp004 []*πg.Object
			_ = πTemp004
			var πTemp005 *πg.Object
			_ = πTemp005
			var πTemp006 *πg.Object
			_ = πTemp006
			var πTemp007 *πg.Object
			_ = πTemp007
			var πE *πg.BaseException; _ = πE
			for ; πF.State() >= 0; πF.PopCheckpoint() {
				switch πF.State() {
				case 0:
				default: panic("unexpected function state")
				}
				// line 49: """Thread is an activity to be executed concurrently."""
				πF.SetLineno(49)
				// line 51: def __init__(self, target=None, args=()):
				πF.SetLineno(51)
				πTemp002 = make([]πg.FunctionArg, 3)
				πTemp002[0] = πg.FunctionArg{Name: "self", Def: nil}
				if πTemp003, πE = πg.ResolveClass(πF, πClass, nil, ßNone); πE != nil {
					continue
				}
				πTemp002[1] = πg.FunctionArg{Name: "target", Def: πTemp003}
				πTemp004 = make([]*πg.Object, 0)
				πTemp003 = πg.NewTuple(πTemp004...).ToObject()
				πTemp002[2] = πg.FunctionArg{Name: "args", Def: πTemp003}
				πTemp001 = πg.NewFunction(πg.NewCode("__init__", "lib/threading.py", πTemp002, 0, func(πF *πg.Frame, πArgs []*πg.Object) (*πg.Object, *πg.BaseException) {
					var µself *πg.Object = πArgs[0]; _ = µself
					var µtarget *πg.Object = πArgs[1]; _ = µtarget
					var µargs *πg.Object = πArgs[2]; _ = µargs
					var πTemp001 *πg.Object
					_ = πTemp001
					var πTemp002 *πg.Object
					_ = πTemp002
					var πE *πg.BaseException; _ = πE
					for ; πF.State() >= 0; πF.PopCheckpoint() {
						switch πF.State() {
						case 0:
						default: panic("unexpected function state")
						}
						// line 52: self._target = target
						πF.SetLineno(52)
						if πE = πg.CheckLocal(πF, µtarget, "target"); πE != nil {
							continue
						}
						if πE = πg.Tie(πF, πg.TieTarget{Target: &πTemp001}, µtarget); πE != nil {
							continue
						}
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πE = πg.SetAttr(πF, µself, ß_target, πTemp001); πE != nil {
							continue
						}
						// line 53: self._args = args
						πF.SetLineno(53)
						if πE = πg.CheckLocal(πF, µargs, "args"); πE != nil {
							continue
						}
						if πE = πg.Tie(πF, πg.TieTarget{Target: &πTemp001}, µargs); πE != nil {
							continue
						}
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πE = πg.SetAttr(πF, µself, ß_args, πTemp001); πE != nil {
							continue
						}
						// line 54: self._event = Event()
						πF.SetLineno(54)
						if πTemp001, πE = πg.ResolveGlobal(πF, ßEvent); πE != nil {
							continue
						}
						if πTemp002, πE = πTemp001.Call(πF, nil, nil); πE != nil {
							continue
						}
						if πE = πg.Tie(πF, πg.TieTarget{Target: &πTemp001}, πTemp002); πE != nil {
							continue
						}
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πE = πg.SetAttr(πF, µself, ß_event, πTemp001); πE != nil {
							continue
						}
						return nil, nil
					}
					return nil, πE
				}), πF.Globals()).ToObject()
				if πE = πClass.SetItem(πF, ß__init__.ToObject(), πTemp001); πE != nil {
					continue
				}
				// line 56: def run(self):
				πF.SetLineno(56)
				πTemp002 = make([]πg.FunctionArg, 1)
				πTemp002[0] = πg.FunctionArg{Name: "self", Def: nil}
				πTemp003 = πg.NewFunction(πg.NewCode("run", "lib/threading.py", πTemp002, 0, func(πF *πg.Frame, πArgs []*πg.Object) (*πg.Object, *πg.BaseException) {
					var µself *πg.Object = πArgs[0]; _ = µself
					var πTemp001 *πg.Object
					_ = πTemp001
					var πTemp002 *πg.Object
					_ = πTemp002
					var πTemp003 *πg.Object
					_ = πTemp003
					var πE *πg.BaseException; _ = πE
					for ; πF.State() >= 0; πF.PopCheckpoint() {
						switch πF.State() {
						case 0:
						default: panic("unexpected function state")
						}
						// line 57: self._target(*self._args)
						πF.SetLineno(57)
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πTemp001, πE = πg.GetAttr(πF, µself, ß_args, nil); πE != nil {
							continue
						}
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πTemp002, πE = πg.GetAttr(πF, µself, ß_target, nil); πE != nil {
							continue
						}
						if πTemp003, πE = πg.Invoke(πF, πTemp002, nil, πTemp001, nil, nil); πE != nil {
							continue
						}
						return nil, nil
					}
					return nil, πE
				}), πF.Globals()).ToObject()
				if πE = πClass.SetItem(πF, ßrun.ToObject(), πTemp003); πE != nil {
					continue
				}
				// line 59: def start(self):
				πF.SetLineno(59)
				πTemp002 = make([]πg.FunctionArg, 1)
				πTemp002[0] = πg.FunctionArg{Name: "self", Def: nil}
				πTemp005 = πg.NewFunction(πg.NewCode("start", "lib/threading.py", πTemp002, 0, func(πF *πg.Frame, πArgs []*πg.Object) (*πg.Object, *πg.BaseException) {
					var µself *πg.Object = πArgs[0]; _ = µself
					var πTemp001 []*πg.Object
					_ = πTemp001
					var πTemp002 *πg.Object
					_ = πTemp002
					var πTemp003 *πg.Object
					_ = πTemp003
					var πE *πg.BaseException; _ = πE
					for ; πF.State() >= 0; πF.PopCheckpoint() {
						switch πF.State() {
						case 0:
						default: panic("unexpected function state")
						}
						// line 60: StartThread(self._run)
						πF.SetLineno(60)
						πTemp001 = πF.MakeArgs(1)
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πTemp002, πE = πg.GetAttr(πF, µself, ß_run, nil); πE != nil {
							continue
						}
						πTemp001[0] = πTemp002
						if πTemp002, πE = πg.ResolveGlobal(πF, ßStartThread); πE != nil {
							continue
						}
						if πTemp003, πE = πTemp002.Call(πF, πTemp001, nil); πE != nil {
							continue
						}
						πF.FreeArgs(πTemp001)
						return nil, nil
					}
					return nil, πE
				}), πF.Globals()).ToObject()
				if πE = πClass.SetItem(πF, ßstart.ToObject(), πTemp005); πE != nil {
					continue
				}
				// line 63: def join(self):
				πF.SetLineno(63)
				πTemp002 = make([]πg.FunctionArg, 1)
				πTemp002[0] = πg.FunctionArg{Name: "self", Def: nil}
				πTemp006 = πg.NewFunction(πg.NewCode("join", "lib/threading.py", πTemp002, 0, func(πF *πg.Frame, πArgs []*πg.Object) (*πg.Object, *πg.BaseException) {
					var µself *πg.Object = πArgs[0]; _ = µself
					var πTemp001 *πg.Object
					_ = πTemp001
					var πTemp002 *πg.Object
					_ = πTemp002
					var πE *πg.BaseException; _ = πE
					for ; πF.State() >= 0; πF.PopCheckpoint() {
						switch πF.State() {
						case 0:
						default: panic("unexpected function state")
						}
						// line 64: self._event.wait()
						πF.SetLineno(64)
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πTemp001, πE = πg.GetAttr(πF, µself, ß_event, nil); πE != nil {
							continue
						}
						if πTemp002, πE = πg.GetAttr(πF, πTemp001, ßwait, nil); πE != nil {
							continue
						}
						if πTemp001, πE = πTemp002.Call(πF, nil, nil); πE != nil {
							continue
						}
						return nil, nil
					}
					return nil, πE
				}), πF.Globals()).ToObject()
				if πE = πClass.SetItem(πF, ßjoin.ToObject(), πTemp006); πE != nil {
					continue
				}
				// line 66: def _run(self):
				πF.SetLineno(66)
				πTemp002 = make([]πg.FunctionArg, 1)
				πTemp002[0] = πg.FunctionArg{Name: "self", Def: nil}
				πTemp007 = πg.NewFunction(πg.NewCode("_run", "lib/threading.py", πTemp002, 0, func(πF *πg.Frame, πArgs []*πg.Object) (*πg.Object, *πg.BaseException) {
					var µself *πg.Object = πArgs[0]; _ = µself
					var πTemp001 *πg.Object
					_ = πTemp001
					var πTemp002 *πg.Object
					_ = πTemp002
					var πTemp003 *πg.BaseException
					_ = πTemp003
					var πTemp004 *πg.Traceback
					_ = πTemp004
					var πE *πg.BaseException; _ = πE
					for ; πF.State() >= 0; πF.PopCheckpoint() {
						switch πF.State() {
						case 0:
						case 1: goto Label1
						default: panic("unexpected function state")
						}
						// line 67: try:
						πF.SetLineno(67)
						πF.PushCheckpoint(1)
						// line 68: self.run()
						πF.SetLineno(68)
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πTemp001, πE = πg.GetAttr(πF, µself, ßrun, nil); πE != nil {
							continue
						}
						if πTemp002, πE = πTemp001.Call(πF, nil, nil); πE != nil {
							continue
						}
						πF.PopCheckpoint()
					Label1:
						πE = nil
						πTemp003, πTemp004 = πF.RestoreExc(nil, nil)
						// line 70: self._event.set()
						πF.SetLineno(70)
						if πE = πg.CheckLocal(πF, µself, "self"); πE != nil {
							continue
						}
						if πTemp001, πE = πg.GetAttr(πF, µself, ß_event, nil); πE != nil {
							continue
						}
						if πTemp002, πE = πg.GetAttr(πF, πTemp001, ßset, nil); πE != nil {
							continue
						}
						if πTemp001, πE = πTemp002.Call(πF, nil, nil); πE != nil {
							continue
						}
						if πTemp003 != nil {
							πE = πF.Raise(πTemp003.ToObject(), nil, πTemp004.ToObject())
							continue
						}
						return nil, nil
					}
					return nil, πE
				}), πF.Globals()).ToObject()
				if πE = πClass.SetItem(πF, ß_run.ToObject(), πTemp007); πE != nil {
					continue
				}
				return nil, nil
			}
			return nil, πE
		}).Eval(πF, πF.Globals(), nil, nil)
		if πE != nil {
			return nil, πE
		}
		if πTemp003, πE = πTemp005.GetItem(πF, ß__metaclass__.ToObject()); πE != nil {
			return nil, πE
		}
		if πTemp003 == nil {
			πTemp003 = πg.TypeType.ToObject()
		}
		if πTemp007, πE = πTemp003.Call(πF, []*πg.Object{πg.NewStr("Thread").ToObject(), πg.NewTuple(πTemp006...).ToObject(), πTemp005.ToObject()}, nil); πE != nil {
			continue
		}
		if πE = πF.Globals().SetItem(πF, ßThread.ToObject(), πTemp007); πE != nil {
			continue
		}
		return nil, nil
	}
	return nil, πE
}
var Code *πg.Code
func init() {
	Code = πg.NewCode("<module>", "lib/threading.py", nil, 0, initModule)
}
