from RT_DEVS import *

try: import theglobals
except: pass
def get_from_Q(event_Q, event_name):
	for i in range(0, len(event_Q)):
		if event_Q[i] == event_name:
			event = event_Q[i];del event_Q[i]
			return event
def choose(coupled, imm):
	max_scope = 0
	deepest = imm[0]
	for devs in imm:
		if devs.scope > max_scope: deepest = devs; max_scope = devs.scope
	return deepest
class RELAY_ROOT_ATOMIC_1941(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 0
		self.is_relay = 1
		self.current_child = None
		self.history = 'MP3'
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['__default_hook'] = DEVSstate('__default_hook')
		self.states['epsilon1941'] = DEVSstate('epsilon1941')
		self.states['__history_hook'] = DEVSstate('__history_hook')
		self.states['__history_star_hook'] = DEVSstate('__history_star_hook')
		self.states['__alpha_relay_hook'] = DEVSstate('__alpha_relay_hook')
		self.states['__relay_hook'] = DEVSstate('__relay_hook')
		self.states['__broadcast_hook'] = DEVSstate('__broadcast_hook')
		self.states['epsilon1942'] = DEVSstate('epsilon1942')
		self.states['epsilon1943'] = DEVSstate('epsilon1943')
		self.states['epsilon1944'] = DEVSstate('epsilon1944')
		self.states['epsilon1945'] = DEVSstate('epsilon1945')
		self.states['epsilon1946'] = DEVSstate('epsilon1946')
		self.states['wait1947'] = DEVSstate('wait1947')
		self.states['epsilon1948'] = DEVSstate('epsilon1948')
		self.states['epsilon1949'] = DEVSstate('epsilon1949')
		self.states['epsilon1950'] = DEVSstate('epsilon1950')
		self.state = self.states['__default_hook']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'EXITALL':
						return self.states['epsilon1945']
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: temp = 'INSCOPE'
						elif self.event.get_param('address')[0] == '_PARENT_':
							temp = 'epsilon1950'
							self.current_child = None
						else:
							temp = 'epsilon1949'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
					elif self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon1942'
						return self.states[temp]
					elif len(self.event.get_param('address')) == 0:
						if self.event.get_param('broadcast') == 'TRUE': return '__broadcast_hook'
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: # REACHED DESTINATION
							self.return_address = self.event.get_param('return_address')
							if self.event.get_param('history') == 'TRUE':
								if self.event.get_param('broadcast') == 'TRUE': temp = '__history_star_hook'
								else: temp = '__history_hook'
							else: temp = '__default_hook'
						else:
							temp = 'epsilon1948'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
					elif self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon1942'
						return self.states[temp]
				return self.states['OUTSCOPE']
			elif self.state == 'wait1947':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon1946'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon1950':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon1949':
				return self.states['INSCOPE']
			elif self.state == '__history_star_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == '__relay_hook':
				return self.states['INSCOPE']
			elif self.state == '__history_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'epsilon1948':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1945':
				return self.states['wait1947']
			elif self.state == '__default_hook':
				return self.states['epsilon1941']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon1946':
				return self.states['OUTSCOPE']
			elif self.state == '__alpha_relay_hook':
				return self.states[self.restore]
			elif self.state == 'epsilon1944':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon1943':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1942':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1941':
				self.current_child = 'MP3'
				return self.states['INSCOPE']
			elif self.state == '__broadcast_hook':
				return self.states['INSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'wait1947':
			ta = INFINITY
		elif self.state == 'epsilon1950':
			ta = 0
		elif self.state == '__history_star_hook':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == '__relay_hook':
			ta = 0
		elif self.state == '__history_hook':
			ta = 0
		elif self.state == 'epsilon1948':
			ta = 0
		elif self.state == 'epsilon1942':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon1943':
			ta = 0
		elif self.state == 'epsilon1949':
			ta = 0
		elif self.state == '__default_hook':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon1946':
			ta = 0
		elif self.state == 'epsilon1945':
			ta = 0
		elif self.state == 'epsilon1944':
			ta = 0
		elif self.state == '__alpha_relay_hook':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon1941':
			ta = 0
		elif self.state == '__broadcast_hook':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == '__alpha_relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_star_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('broadcast', 'TRUE')
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1950':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1949':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1948':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1946':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('address', ['_PARENT_'])
				event.set_param('history_state', 'ROOT')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1945':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1944':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1943':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1942':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1941':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['MP3'])
				event.set_param('return_address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__broadcast_hook':
			def __outputFnc(self):
				self.event.set_param('address', [self.current_child])
				self.event.set_param('broadcast', 'TRUE')
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class RELAY_MP3_ATOMIC_1952(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 1
		self.is_relay = 1
		self.current_child = None
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['__default_hook'] = DEVSstate('__default_hook')
		self.states['epsilon1952'] = DEVSstate('epsilon1952')
		self.states['__history_hook'] = DEVSstate('__history_hook')
		self.states['__history_star_hook'] = DEVSstate('__history_star_hook')
		self.states['__alpha_relay_hook'] = DEVSstate('__alpha_relay_hook')
		self.states['__relay_hook'] = DEVSstate('__relay_hook')
		self.states['__broadcast_hook'] = DEVSstate('__broadcast_hook')
		self.states['epsilon1953'] = DEVSstate('epsilon1953')
		self.states['epsilon1954'] = DEVSstate('epsilon1954')
		self.states['epsilon1955'] = DEVSstate('epsilon1955')
		self.states['epsilon1956'] = DEVSstate('epsilon1956')
		self.states['epsilon1957'] = DEVSstate('epsilon1957')
		self.states['wait1958'] = DEVSstate('wait1958')
		self.states['wait1959'] = DEVSstate('wait1959')
		self.states['epsilon1960'] = DEVSstate('epsilon1960')
		self.states['epsilon1961'] = DEVSstate('epsilon1961')
		self.states['epsilon1962'] = DEVSstate('epsilon1962')
		self.states['epsilon1963'] = DEVSstate('epsilon1963')
		self.states['epsilon1964'] = DEVSstate('epsilon1964')
		self.states['epsilon1965'] = DEVSstate('epsilon1965')
		self.states['epsilon1966'] = DEVSstate('epsilon1966')
		self.states['epsilon1967'] = DEVSstate('epsilon1967')
		self.states['epsilon1968'] = DEVSstate('epsilon1968')
		self.states['epsilon1969'] = DEVSstate('epsilon1969')
		self.states['wait1970'] = DEVSstate('wait1970')
		self.states['wait1971'] = DEVSstate('wait1971')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'GUI Quit':
						return self.states['epsilon1963']
					elif self.event == 'EXITALL':
						return self.states['epsilon1956']
					elif self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon1953'
						return self.states[temp]
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: temp = 'INSCOPE'
						elif self.event.get_param('address')[0] == '_PARENT_':
							temp = 'epsilon1962'
							self.current_child = None
						else:
							temp = 'epsilon1961'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
					elif len(self.event.get_param('address')) == 0:
						if self.event.get_param('broadcast') == 'TRUE': return '__broadcast_hook'
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon1953'
						return self.states[temp]
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: # REACHED DESTINATION
							self.return_address = self.event.get_param('return_address')
							if self.event.get_param('history') == 'TRUE':
								if self.event.get_param('broadcast') == 'TRUE': temp = '__history_star_hook'
								else: temp = '__history_hook'
							else: temp = '__default_hook'
						else:
							temp = 'epsilon1960'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
				return self.states['OUTSCOPE']
			elif self.state == '__history_star_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == '__relay_hook':
				return self.states['INSCOPE']
			elif self.state == 'wait1958':
				if get_from_Q(self.Q, 'EXITACK') != None: return self.states['wait1959']
				else: return self.state
			elif self.state == 'wait1959':
				if get_from_Q(self.Q, 'EXITACK') != None: temp = 'epsilon1957'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon1954':
				return self.states['INSCOPE']
			elif self.state == 'wait1971':
				if get_from_Q(self.Q, 'EXITACK') != None: temp = 'epsilon1969'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon1961':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1960':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1963':
				if (1):
					return self.states['epsilon1964']
				else: return self.states['epsilon1965']
			elif self.state == 'epsilon1962':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon1965':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1964':
				exit
				return self.states['epsilon1967']
			elif self.state == 'epsilon1967':
				return self.states['wait1970']
			elif self.state == '__default_hook':
				return self.states['epsilon1952']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon1955':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon1956':
				return self.states['wait1958']
			elif self.state == 'epsilon1957':
				return self.states['OUTSCOPE']
			elif self.state == '__alpha_relay_hook':
				return self.states[self.restore]
			elif self.state == 'epsilon1952':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1953':
				return self.states['INSCOPE']
			elif self.state == 'wait1970':
				if get_from_Q(self.Q, 'EXITACK') != None: return self.states['wait1971']
				else: return self.state
			elif self.state == '__history_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'epsilon1968':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon1969':
				return self.states['epsilon1968']
			elif self.state == '__broadcast_hook':
				return self.states['INSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon1966':
			ta = 0
		elif self.state == '__history_star_hook':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == '__relay_hook':
			ta = 0
		elif self.state == 'wait1958':
			ta = INFINITY
		elif self.state == 'wait1959':
			ta = INFINITY
		elif self.state == 'wait1970':
			ta = INFINITY
		elif self.state == 'wait1971':
			ta = INFINITY
		elif self.state == 'epsilon1961':
			ta = 0
		elif self.state == 'epsilon1960':
			ta = 0
		elif self.state == 'epsilon1963':
			ta = 0
		elif self.state == 'epsilon1962':
			ta = 0
		elif self.state == 'epsilon1965':
			ta = 0
		elif self.state == 'epsilon1964':
			ta = 0
		elif self.state == 'epsilon1967':
			ta = 0
		elif self.state == '__default_hook':
			ta = 0
		elif self.state == 'epsilon1954':
			ta = 0
		elif self.state == 'epsilon1955':
			ta = 0
		elif self.state == 'epsilon1956':
			ta = 0
		elif self.state == 'epsilon1957':
			ta = 0
		elif self.state == '__alpha_relay_hook':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon1952':
			ta = 0
		elif self.state == 'epsilon1953':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == '__history_hook':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon1969':
			ta = 0
		elif self.state == 'epsilon1968':
			ta = 0
		elif self.state == '__broadcast_hook':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == '__history_star_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('broadcast', 'TRUE')
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1968':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'DEAD'])
				event.set_param('return_address', ['_PARENT_', 'MP3'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__broadcast_hook':
			def __outputFnc(self):
				self.event.set_param('address', ['_ALL_'])
				self.event.set_param('broadcast', 'TRUE')
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1961':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1960':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1962':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1967':
			def __outputFnc(self):
				event = DEVSevent('EXITALL')
				event.set_param('address', ['_ALL_'])
				event.set_param('broadcast', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1969':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
				
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1954':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1955':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1956':
			def __outputFnc(self):
				event = DEVSevent('EXITALL')
				event.set_param('address', ['_ALL_'])
				event.set_param('broadcast', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1957':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('address', ['_PARENT_'])
				event.set_param('history_state', 'MP3')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__alpha_relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1952':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_ALL_'])
				event.set_param('return_address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1953':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class RELAY_GUI_ATOMIC_1973(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 2
		self.is_relay = 1
		self.current_child = None
		self.history = 'GUISTOP'
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['__default_hook'] = DEVSstate('__default_hook')
		self.states['epsilon1973'] = DEVSstate('epsilon1973')
		self.states['__history_hook'] = DEVSstate('__history_hook')
		self.states['__history_star_hook'] = DEVSstate('__history_star_hook')
		self.states['__alpha_relay_hook'] = DEVSstate('__alpha_relay_hook')
		self.states['__relay_hook'] = DEVSstate('__relay_hook')
		self.states['__broadcast_hook'] = DEVSstate('__broadcast_hook')
		self.states['epsilon1974'] = DEVSstate('epsilon1974')
		self.states['epsilon1975'] = DEVSstate('epsilon1975')
		self.states['epsilon1976'] = DEVSstate('epsilon1976')
		self.states['epsilon1977'] = DEVSstate('epsilon1977')
		self.states['epsilon1978'] = DEVSstate('epsilon1978')
		self.states['wait1979'] = DEVSstate('wait1979')
		self.states['epsilon1980'] = DEVSstate('epsilon1980')
		self.states['epsilon1981'] = DEVSstate('epsilon1981')
		self.states['epsilon1982'] = DEVSstate('epsilon1982')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'EXITALL':
						return self.states['epsilon1977']
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: temp = 'INSCOPE'
						elif self.event.get_param('address')[0] == '_PARENT_':
							temp = 'epsilon1982'
							self.current_child = None
						else:
							temp = 'epsilon1981'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
					elif self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon1974'
						return self.states[temp]
					elif len(self.event.get_param('address')) == 0:
						if self.event.get_param('broadcast') == 'TRUE': return '__broadcast_hook'
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: # REACHED DESTINATION
							self.return_address = self.event.get_param('return_address')
							if self.event.get_param('history') == 'TRUE':
								if self.event.get_param('broadcast') == 'TRUE': temp = '__history_star_hook'
								else: temp = '__history_hook'
							else: temp = '__default_hook'
						else:
							temp = 'epsilon1980'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
					elif self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon1974'
						return self.states[temp]
				return self.states['OUTSCOPE']
			elif self.state == 'wait1979':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon1978'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == '__history_star_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == '__relay_hook':
				return self.states['INSCOPE']
			elif self.state == '__history_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'epsilon1976':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon1977':
				return self.states['wait1979']
			elif self.state == 'epsilon1974':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1975':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1973':
				self.current_child = 'GUISTOP'
				return self.states['INSCOPE']
			elif self.state == '__default_hook':
				return self.states['epsilon1973']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon1982':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon1981':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1980':
				return self.states['INSCOPE']
			elif self.state == '__alpha_relay_hook':
				return self.states[self.restore]
			elif self.state == 'epsilon1978':
				return self.states['OUTSCOPE']
			elif self.state == '__broadcast_hook':
				return self.states['INSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'wait1979':
			ta = INFINITY
		elif self.state == '__history_star_hook':
			ta = 0
		elif self.state == 'epsilon1977':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == '__relay_hook':
			ta = 0
		elif self.state == '__history_hook':
			ta = 0
		elif self.state == 'epsilon1976':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon1974':
			ta = 0
		elif self.state == 'epsilon1975':
			ta = 0
		elif self.state == 'epsilon1973':
			ta = 0
		elif self.state == '__default_hook':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon1982':
			ta = 0
		elif self.state == 'epsilon1981':
			ta = 0
		elif self.state == 'epsilon1980':
			ta = 0
		elif self.state == '__alpha_relay_hook':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon1978':
			ta = 0
		elif self.state == '__broadcast_hook':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == '__history_star_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('broadcast', 'TRUE')
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1976':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1977':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1974':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1975':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1973':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['GUISTOP'])
				event.set_param('return_address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1982':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1981':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1980':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__alpha_relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1978':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('address', ['_PARENT_'])
				event.set_param('history_state', 'GUI')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__broadcast_hook':
			def __outputFnc(self):
				self.event.set_param('address', [self.current_child])
				self.event.set_param('broadcast', 'TRUE')
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class RELAY_GUIACTIVE_ATOMIC_1984(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 3
		self.is_relay = 1
		self.current_child = None
		self.history = 'GUIPLAY'
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['__default_hook'] = DEVSstate('__default_hook')
		self.states['epsilon1984'] = DEVSstate('epsilon1984')
		self.states['__history_hook'] = DEVSstate('__history_hook')
		self.states['__history_star_hook'] = DEVSstate('__history_star_hook')
		self.states['__alpha_relay_hook'] = DEVSstate('__alpha_relay_hook')
		self.states['__relay_hook'] = DEVSstate('__relay_hook')
		self.states['__broadcast_hook'] = DEVSstate('__broadcast_hook')
		self.states['epsilon1985'] = DEVSstate('epsilon1985')
		self.states['epsilon1986'] = DEVSstate('epsilon1986')
		self.states['epsilon1987'] = DEVSstate('epsilon1987')
		self.states['epsilon1988'] = DEVSstate('epsilon1988')
		self.states['epsilon1989'] = DEVSstate('epsilon1989')
		self.states['wait1990'] = DEVSstate('wait1990')
		self.states['epsilon1991'] = DEVSstate('epsilon1991')
		self.states['epsilon1992'] = DEVSstate('epsilon1992')
		self.states['epsilon1993'] = DEVSstate('epsilon1993')
		self.states['epsilon1994'] = DEVSstate('epsilon1994')
		self.states['epsilon1995'] = DEVSstate('epsilon1995')
		self.states['epsilon1996'] = DEVSstate('epsilon1996')
		self.states['epsilon1997'] = DEVSstate('epsilon1997')
		self.states['epsilon1998'] = DEVSstate('epsilon1998')
		self.states['epsilon1999'] = DEVSstate('epsilon1999')
		self.states['epsilon2000'] = DEVSstate('epsilon2000')
		self.states['wait2001'] = DEVSstate('wait2001')
		self.states['epsilon2002'] = DEVSstate('epsilon2002')
		self.states['epsilon2003'] = DEVSstate('epsilon2003')
		self.states['epsilon2004'] = DEVSstate('epsilon2004')
		self.states['epsilon2005'] = DEVSstate('epsilon2005')
		self.states['epsilon2006'] = DEVSstate('epsilon2006')
		self.states['epsilon2007'] = DEVSstate('epsilon2007')
		self.states['epsilon2008'] = DEVSstate('epsilon2008')
		self.states['wait2009'] = DEVSstate('wait2009')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		if not self.timeout and round(self.elapsed_since_inscope, 6) >= 0.1:
			self.Q.append(EVENT('_TIMEOUT_'))
			self.elapsed_since_inscope = 0
			self.timeout = 1
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == '_TIMEOUT_':
						return self.states['epsilon2002']
					elif self.event == 'EXITALL':
						return self.states['epsilon1988']
					elif self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon1985'
						return self.states[temp]
					elif self.event == 'Playing Stopped':
						return self.states['epsilon1994']
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: temp = 'INSCOPE'
						elif self.event.get_param('address')[0] == '_PARENT_':
							temp = 'epsilon1993'
							self.current_child = None
						else:
							temp = 'epsilon1992'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
					elif len(self.event.get_param('address')) == 0:
						if self.event.get_param('broadcast') == 'TRUE': return '__broadcast_hook'
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon1985'
						return self.states[temp]
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: # REACHED DESTINATION
							self.return_address = self.event.get_param('return_address')
							if self.event.get_param('history') == 'TRUE':
								if self.event.get_param('broadcast') == 'TRUE': temp = '__history_star_hook'
								else: temp = '__history_hook'
							else: temp = '__default_hook'
						else:
							temp = 'epsilon1991'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
				return self.states['OUTSCOPE']
			elif self.state == 'wait2009':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2008'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon2002':
				if (1):
					return self.states['epsilon2003']
				else: return self.states['epsilon2004']
			elif self.state == 'epsilon2006':
				return self.states['wait2009']
			elif self.state == '__history_star_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == '__relay_hook':
				return self.states['INSCOPE']
			elif self.state == '__broadcast_hook':
				return self.states['INSCOPE']
			elif self.state == '__default_hook':
				return self.states['epsilon1984']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2000':
				return self.states['epsilon1999']
			elif self.state == '__alpha_relay_hook':
				return self.states[self.restore]
			elif self.state == 'epsilon2003':
				t = theglobals.audio.get_time()
				theglobals.gui.timestr.set(t)
				return self.states['epsilon2006']
			elif self.state == 'epsilon2008':
				return self.states['epsilon2007']
			elif self.state == 'epsilon1999':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon1994':
				if (1):
					return self.states['epsilon1995']
				else: return self.states['epsilon1996']
			elif self.state == '__history_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'wait1990':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon1989'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon1986':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1998':
				return self.states['wait2001']
			elif self.state == 'wait2001':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2000'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon1989':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon1988':
				return self.states['wait1990']
			elif self.state == 'epsilon2007':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon1996':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2004':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1991':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1992':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1993':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon1987':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon1995':
				theglobals.gui.hide_time()
				#[SetButtons(NORMAL, DISABLED, DISABLED, DISABLED)]
				return self.states['epsilon1998']
			elif self.state == 'epsilon1985':
				return self.states['INSCOPE']
			elif self.state == 'epsilon1984':
				self.current_child = 'GUIPLAY'
				return self.states['INSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'wait2009':
			ta = INFINITY
		elif self.state == 'wait2001':
			ta = INFINITY
		elif self.state == 'epsilon2006':
			ta = 0
		elif self.state == '__history_star_hook':
			ta = 0
		elif self.state == 'epsilon1997':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == '__relay_hook':
			ta = 0
		elif self.state == '__broadcast_hook':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == '__default_hook':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2000':
			ta = 0
		elif self.state == '__alpha_relay_hook':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2003':
			ta = 0
		elif self.state == 'epsilon2008':
			ta = 0
		elif self.state == 'epsilon2002':
			ta = 0
		elif self.state == 'epsilon1994':
			ta = 0
		elif self.state == '__history_hook':
			ta = 0
		elif self.state == 'wait1990':
			ta = INFINITY
		elif self.state == 'epsilon1986':
			ta = 0
		elif self.state == 'epsilon1998':
			ta = 0
		elif self.state == 'epsilon1999':
			ta = 0
		elif self.state == 'epsilon1989':
			ta = 0
		elif self.state == 'epsilon1988':
			ta = 0
		elif self.state == 'epsilon2007':
			ta = 0
		elif self.state == 'epsilon1996':
			ta = 0
		elif self.state == 'epsilon2005':
			ta = 0
		elif self.state == 'epsilon2004':
			ta = 0
		elif self.state == 'epsilon1991':
			ta = 0
		elif self.state == 'epsilon1992':
			ta = 0
		elif self.state == 'epsilon1993':
			ta = 0
		elif self.state == 'epsilon1987':
			ta = 0
		elif self.state == 'epsilon1995':
			ta = 0
		elif self.state == 'epsilon1985':
			ta = 0
		elif self.state == 'epsilon1984':
			ta = 0
		else: ta = INFINITY
		if self.inscope and not self.timeout:
			ta_after = max(0, 0.1-self.elapsed_since_inscope)
		else:
			ta_after = INFINITY
		return minEx(ta, ta_after)
	def outputFnc(self):
		if self.state == 'epsilon1993':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_star_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('broadcast', 'TRUE')
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1999':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'GUISTOP'])
				event.set_param('return_address', ['_PARENT_', 'GUIACTIVE'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2000':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2008':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
				
				
				
				
				
				
				
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1998':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1992':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1989':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('address', ['_PARENT_'])
				event.set_param('history_state', 'GUIACTIVE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1988':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2007':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'GUIACTIVE'])
				event.set_param('history', 'TRUE')
				event.set_param('return_address', ['_PARENT_', 'GUIACTIVE'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2006':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1991':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__alpha_relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__broadcast_hook':
			def __outputFnc(self):
				self.event.set_param('address', [self.current_child])
				self.event.set_param('broadcast', 'TRUE')
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1987':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1986':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1985':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon1984':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['GUIPLAY'])
				event.set_param('return_address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class RELAY_GUIPLAY_ATOMIC_2011(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 4
		self.is_relay = 1
		self.current_child = None
		self.history = 'GUIPLAYING'
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['__default_hook'] = DEVSstate('__default_hook')
		self.states['epsilon2011'] = DEVSstate('epsilon2011')
		self.states['__history_hook'] = DEVSstate('__history_hook')
		self.states['__history_star_hook'] = DEVSstate('__history_star_hook')
		self.states['__alpha_relay_hook'] = DEVSstate('__alpha_relay_hook')
		self.states['__relay_hook'] = DEVSstate('__relay_hook')
		self.states['__broadcast_hook'] = DEVSstate('__broadcast_hook')
		self.states['epsilon2012'] = DEVSstate('epsilon2012')
		self.states['epsilon2013'] = DEVSstate('epsilon2013')
		self.states['epsilon2014'] = DEVSstate('epsilon2014')
		self.states['epsilon2015'] = DEVSstate('epsilon2015')
		self.states['epsilon2016'] = DEVSstate('epsilon2016')
		self.states['wait2017'] = DEVSstate('wait2017')
		self.states['epsilon2018'] = DEVSstate('epsilon2018')
		self.states['epsilon2019'] = DEVSstate('epsilon2019')
		self.states['epsilon2020'] = DEVSstate('epsilon2020')
		self.states['epsilon2021'] = DEVSstate('epsilon2021')
		self.states['epsilon2022'] = DEVSstate('epsilon2022')
		self.states['epsilon2023'] = DEVSstate('epsilon2023')
		self.states['epsilon2024'] = DEVSstate('epsilon2024')
		self.states['epsilon2025'] = DEVSstate('epsilon2025')
		self.states['epsilon2026'] = DEVSstate('epsilon2026')
		self.states['epsilon2027'] = DEVSstate('epsilon2027')
		self.states['wait2028'] = DEVSstate('wait2028')
		self.states['epsilon2029'] = DEVSstate('epsilon2029')
		self.states['epsilon2030'] = DEVSstate('epsilon2030')
		self.states['epsilon2031'] = DEVSstate('epsilon2031')
		self.states['epsilon2032'] = DEVSstate('epsilon2032')
		self.states['epsilon2033'] = DEVSstate('epsilon2033')
		self.states['epsilon2034'] = DEVSstate('epsilon2034')
		self.states['epsilon2035'] = DEVSstate('epsilon2035')
		self.states['wait2036'] = DEVSstate('wait2036')
		self.states['epsilon2037'] = DEVSstate('epsilon2037')
		self.states['epsilon2038'] = DEVSstate('epsilon2038')
		self.states['epsilon2039'] = DEVSstate('epsilon2039')
		self.states['epsilon2040'] = DEVSstate('epsilon2040')
		self.states['epsilon2041'] = DEVSstate('epsilon2041')
		self.states['epsilon2042'] = DEVSstate('epsilon2042')
		self.states['epsilon2043'] = DEVSstate('epsilon2043')
		self.states['wait2044'] = DEVSstate('wait2044')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'GUI Forward Pressed':
						return self.states['epsilon2021']
					elif self.event == 'GUI Backward Pressed':
						return self.states['epsilon2029']
					elif self.event == 'EXITALL':
						return self.states['epsilon2015']
					elif self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon2012'
						return self.states[temp]
					elif self.event == 'GUI Stop':
						return self.states['epsilon2037']
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: temp = 'INSCOPE'
						elif self.event.get_param('address')[0] == '_PARENT_':
							temp = 'epsilon2020'
							self.current_child = None
						else:
							temp = 'epsilon2019'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
					elif len(self.event.get_param('address')) == 0:
						if self.event.get_param('broadcast') == 'TRUE': return '__broadcast_hook'
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon2012'
						return self.states[temp]
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: # REACHED DESTINATION
							self.return_address = self.event.get_param('return_address')
							if self.event.get_param('history') == 'TRUE':
								if self.event.get_param('broadcast') == 'TRUE': temp = '__history_star_hook'
								else: temp = '__history_hook'
							else: temp = '__default_hook'
						else:
							temp = 'epsilon2018'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
				return self.states['OUTSCOPE']
			elif self.state == 'wait2044':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2043'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon2019':
				return self.states['INSCOPE']
			elif self.state == '__history_star_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == '__relay_hook':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2037':
				if (1):
					return self.states['epsilon2038']
				else: return self.states['epsilon2039']
			elif self.state == 'wait2017':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2016'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon2042':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2041':
				return self.states['wait2044']
			elif self.state == 'wait2036':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2035'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == '__default_hook':
				return self.states['epsilon2011']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'wait2028':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2027'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == '__alpha_relay_hook':
				return self.states[self.restore]
			elif self.state == 'epsilon2038':
				theglobals.gui.hide_time()
				#[SetButtons(NORMAL, DISABLED, DISABLED, DISABLED)]
				return self.states['epsilon2041']
			elif self.state == 'epsilon2026':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2030':
				theglobals.gui.show_time()
				#[SetButtons(DISABLED, DISABLED, DISABLED, NORMAL)]
				return self.states['epsilon2033']
			elif self.state == 'epsilon2039':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2033':
				return self.states['wait2036']
			elif self.state == '__history_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'epsilon2031':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2043':
				return self.states['epsilon2042']
			elif self.state == 'epsilon2027':
				return self.states['epsilon2026']
			elif self.state == 'epsilon2034':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2035':
				return self.states['epsilon2034']
			elif self.state == 'epsilon2025':
				return self.states['wait2028']
			elif self.state == 'epsilon2011':
				self.current_child = 'GUIPLAYING'
				return self.states['INSCOPE']
			elif self.state == 'epsilon2012':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2013':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2021':
				if (1):
					return self.states['epsilon2022']
				else: return self.states['epsilon2023']
			elif self.state == 'epsilon2015':
				return self.states['wait2017']
			elif self.state == 'epsilon2016':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2022':
				theglobals.gui.show_time()
				#[SetButtons(DISABLED, DISABLED, NORMAL, DISABLED)]
				return self.states['epsilon2025']
			elif self.state == 'epsilon2018':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2014':
				return self.states['OUTSCOPE']
			elif self.state == '__broadcast_hook':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2029':
				if (1):
					return self.states['epsilon2030']
				else: return self.states['epsilon2031']
			elif self.state == 'epsilon2023':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2020':
				return self.states['OUTSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'wait2044':
			ta = INFINITY
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'wait2028':
			ta = INFINITY
		elif self.state == '__alpha_relay_hook':
			ta = 0
		elif self.state == 'epsilon2038':
			ta = 0
		elif self.state == 'epsilon2039':
			ta = 0
		elif self.state == 'epsilon2032':
			ta = 0
		elif self.state == 'epsilon2033':
			ta = 0
		elif self.state == 'epsilon2030':
			ta = 0
		elif self.state == 'epsilon2031':
			ta = 0
		elif self.state == 'epsilon2037':
			ta = 0
		elif self.state == 'epsilon2034':
			ta = 0
		elif self.state == 'epsilon2035':
			ta = 0
		elif self.state == 'epsilon2011':
			ta = 0
		elif self.state == 'epsilon2012':
			ta = 0
		elif self.state == 'epsilon2013':
			ta = 0
		elif self.state == 'epsilon2014':
			ta = 0
		elif self.state == 'epsilon2015':
			ta = 0
		elif self.state == 'epsilon2016':
			ta = 0
		elif self.state == 'epsilon2018':
			ta = 0
		elif self.state == 'epsilon2019':
			ta = 0
		elif self.state == '__broadcast_hook':
			ta = 0
		elif self.state == '__history_star_hook':
			ta = 0
		elif self.state == '__relay_hook':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'wait2036':
			ta = INFINITY
		elif self.state == '__default_hook':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == 'wait2017':
			ta = INFINITY
		elif self.state == 'epsilon2043':
			ta = 0
		elif self.state == 'epsilon2042':
			ta = 0
		elif self.state == 'epsilon2041':
			ta = 0
		elif self.state == 'epsilon2040':
			ta = 0
		elif self.state == 'epsilon2025':
			ta = 0
		elif self.state == 'epsilon2024':
			ta = 0
		elif self.state == 'epsilon2027':
			ta = 0
		elif self.state == 'epsilon2026':
			ta = 0
		elif self.state == 'epsilon2021':
			ta = 0
		elif self.state == 'epsilon2020':
			ta = 0
		elif self.state == 'epsilon2023':
			ta = 0
		elif self.state == 'epsilon2022':
			ta = 0
		elif self.state == 'epsilon2029':
			ta = 0
		elif self.state == '__history_hook':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == '__history_star_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('broadcast', 'TRUE')
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2042':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', '_PARENT_', 'GUISTOP'])
				event.set_param('return_address', ['_PARENT_', 'GUIACTIVE', 'GUIPLAY'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2013':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2034':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'GUIRW'])
				event.set_param('return_address', ['_PARENT_', 'GUIPLAY'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__alpha_relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2033':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2043':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2012':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2041':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2035':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2025':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2011':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['GUIPLAYING'])
				event.set_param('return_address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2027':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2026':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'GUIFF'])
				event.set_param('return_address', ['_PARENT_', 'GUIPLAY'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2014':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2015':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2016':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('address', ['_PARENT_'])
				event.set_param('history_state', 'GUIPLAY')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2018':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2019':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__broadcast_hook':
			def __outputFnc(self):
				self.event.set_param('address', [self.current_child])
				self.event.set_param('broadcast', 'TRUE')
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2020':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class GUIPLAYING(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 5.5
		self.is_relay = 0
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['epsilon2046'] = DEVSstate('epsilon2046')
		self.states['epsilon2047'] = DEVSstate('epsilon2047')
		self.states['epsilon2048'] = DEVSstate('epsilon2048')
		self.states['epsilon2049'] = DEVSstate('epsilon2049')
		self.states['epsilon2050'] = DEVSstate('epsilon2050')
		self.states['epsilon2051'] = DEVSstate('epsilon2051')
		self.states['epsilon2052'] = DEVSstate('epsilon2052')
		self.states['epsilon2053'] = DEVSstate('epsilon2053')
		self.states['epsilon2054'] = DEVSstate('epsilon2054')
		self.states['epsilon2055'] = DEVSstate('epsilon2055')
		self.states['epsilon2056'] = DEVSstate('epsilon2056')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'EXITALL':
						return self.states['epsilon2049']
					elif self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2048']
					elif self.event == 'GUI Play/Pause':
						return self.states['epsilon2050']
					elif len(self.event.get_param('address')) == 0:
						pass
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2047']
					elif self.event == 'ENTER':
						return self.states['INSCOPE']
				return self.states['OUTSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == 'epsilon2054':
				return self.states['epsilon2055']
			elif self.state == 'epsilon2049':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2048':
				return self.states['INSCOPE']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2055':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2050':
				if (1):
					return self.states['epsilon2051']
				else: return self.states['epsilon2052']
			elif self.state == 'epsilon2047':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2052':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2051':
				return self.states['epsilon2054']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon2049':
			ta = 0
		elif self.state == 'epsilon2048':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2046':
			ta = 0
		elif self.state == 'epsilon2056':
			ta = 0
		elif self.state == 'epsilon2050':
			ta = 0
		elif self.state == 'epsilon2051':
			ta = 0
		elif self.state == 'epsilon2052':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2055':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2053':
			ta = 0
		elif self.state == 'epsilon2054':
			ta = 0
		elif self.state == 'epsilon2047':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == 'epsilon2047':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2054':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2055':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'GUIPAUSE', 'SHOW'])
				event.set_param('return_address', ['_PARENT_', '_PARENT_', 'GUIPLAYING'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2049':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('history_state', 'GUIPLAYING')
				event.set_param('address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2048':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class RELAY_GUIPAUSE_ATOMIC_2058(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 5
		self.is_relay = 1
		self.current_child = None
		self.history = 'SHOW'
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['__default_hook'] = DEVSstate('__default_hook')
		self.states['epsilon2058'] = DEVSstate('epsilon2058')
		self.states['__history_hook'] = DEVSstate('__history_hook')
		self.states['__history_star_hook'] = DEVSstate('__history_star_hook')
		self.states['__alpha_relay_hook'] = DEVSstate('__alpha_relay_hook')
		self.states['__relay_hook'] = DEVSstate('__relay_hook')
		self.states['__broadcast_hook'] = DEVSstate('__broadcast_hook')
		self.states['epsilon2059'] = DEVSstate('epsilon2059')
		self.states['epsilon2060'] = DEVSstate('epsilon2060')
		self.states['epsilon2061'] = DEVSstate('epsilon2061')
		self.states['epsilon2062'] = DEVSstate('epsilon2062')
		self.states['epsilon2063'] = DEVSstate('epsilon2063')
		self.states['wait2064'] = DEVSstate('wait2064')
		self.states['epsilon2065'] = DEVSstate('epsilon2065')
		self.states['epsilon2066'] = DEVSstate('epsilon2066')
		self.states['epsilon2067'] = DEVSstate('epsilon2067')
		self.states['epsilon2068'] = DEVSstate('epsilon2068')
		self.states['epsilon2069'] = DEVSstate('epsilon2069')
		self.states['epsilon2070'] = DEVSstate('epsilon2070')
		self.states['epsilon2071'] = DEVSstate('epsilon2071')
		self.states['epsilon2072'] = DEVSstate('epsilon2072')
		self.states['epsilon2073'] = DEVSstate('epsilon2073')
		self.states['epsilon2074'] = DEVSstate('epsilon2074')
		self.states['wait2075'] = DEVSstate('wait2075')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon2059'
						return self.states[temp]
					elif self.event == 'EXITALL':
						return self.states['epsilon2062']
					elif self.event == 'GUI Play/Pause':
						return self.states['epsilon2068']
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: temp = 'INSCOPE'
						elif self.event.get_param('address')[0] == '_PARENT_':
							temp = 'epsilon2067'
							self.current_child = None
						else:
							temp = 'epsilon2066'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
					elif len(self.event.get_param('address')) == 0:
						if self.event.get_param('broadcast') == 'TRUE': return '__broadcast_hook'
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon2059'
						return self.states[temp]
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: # REACHED DESTINATION
							self.return_address = self.event.get_param('return_address')
							if self.event.get_param('history') == 'TRUE':
								if self.event.get_param('broadcast') == 'TRUE': temp = '__history_star_hook'
								else: temp = '__history_hook'
							else: temp = '__default_hook'
						else:
							temp = 'epsilon2065'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
				return self.states['OUTSCOPE']
			elif self.state == '__history_star_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == '__relay_hook':
				return self.states['INSCOPE']
			elif self.state == 'wait2064':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2063'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon2074':
				return self.states['epsilon2073']
			elif self.state == '__default_hook':
				return self.states['epsilon2058']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2072':
				return self.states['wait2075']
			elif self.state == '__alpha_relay_hook':
				return self.states[self.restore]
			elif self.state == 'epsilon2073':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2061':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2060':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2063':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2062':
				return self.states['wait2064']
			elif self.state == 'epsilon2058':
				self.current_child = 'SHOW'
				return self.states['INSCOPE']
			elif self.state == 'epsilon2059':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2067':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2066':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2069':
				theglobals.gui.show_time()
				return self.states['epsilon2072']
			elif self.state == 'epsilon2065':
				return self.states['INSCOPE']
			elif self.state == '__history_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'wait2075':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2074'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == '__broadcast_hook':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2070':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2068':
				if (1):
					return self.states['epsilon2069']
				else: return self.states['epsilon2070']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == '__history_star_hook':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == '__relay_hook':
			ta = 0
		elif self.state == 'wait2064':
			ta = INFINITY
		elif self.state == 'epsilon2074':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == '__default_hook':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2065':
			ta = 0
		elif self.state == '__alpha_relay_hook':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2073':
			ta = 0
		elif self.state == 'epsilon2061':
			ta = 0
		elif self.state == 'epsilon2060':
			ta = 0
		elif self.state == 'epsilon2063':
			ta = 0
		elif self.state == 'epsilon2062':
			ta = 0
		elif self.state == 'epsilon2058':
			ta = 0
		elif self.state == 'epsilon2059':
			ta = 0
		elif self.state == 'epsilon2067':
			ta = 0
		elif self.state == 'epsilon2066':
			ta = 0
		elif self.state == 'epsilon2069':
			ta = 0
		elif self.state == 'epsilon2068':
			ta = 0
		elif self.state == '__history_hook':
			ta = 0
		elif self.state == 'epsilon2071':
			ta = 0
		elif self.state == 'wait2075':
			ta = INFINITY
		elif self.state == 'epsilon2070':
			ta = 0
		elif self.state == 'epsilon2072':
			ta = 0
		elif self.state == '__broadcast_hook':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == 'epsilon2061':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2060':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2063':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('address', ['_PARENT_'])
				event.set_param('history_state', 'GUIPAUSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2062':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2058':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['SHOW'])
				event.set_param('return_address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2059':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_star_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('broadcast', 'TRUE')
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2066':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2074':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2073':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'GUIPLAYING'])
				event.set_param('return_address', ['_PARENT_', 'GUIPAUSE'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2072':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2065':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2067':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__alpha_relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__broadcast_hook':
			def __outputFnc(self):
				self.event.set_param('address', [self.current_child])
				self.event.set_param('broadcast', 'TRUE')
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class SHOW(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 6.5
		self.is_relay = 0
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['epsilon2077'] = DEVSstate('epsilon2077')
		self.states['epsilon2078'] = DEVSstate('epsilon2078')
		self.states['epsilon2079'] = DEVSstate('epsilon2079')
		self.states['epsilon2080'] = DEVSstate('epsilon2080')
		self.states['epsilon2081'] = DEVSstate('epsilon2081')
		self.states['epsilon2082'] = DEVSstate('epsilon2082')
		self.states['epsilon2083'] = DEVSstate('epsilon2083')
		self.states['epsilon2084'] = DEVSstate('epsilon2084')
		self.states['epsilon2085'] = DEVSstate('epsilon2085')
		self.states['epsilon2086'] = DEVSstate('epsilon2086')
		self.states['epsilon2087'] = DEVSstate('epsilon2087')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		if not self.timeout and round(self.elapsed_since_inscope, 6) >= 1.0:
			self.Q.append(EVENT('_TIMEOUT_'))
			self.elapsed_since_inscope = 0
			self.timeout = 1
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == '_TIMEOUT_':
						return self.states['epsilon2081']
					elif self.event == 'EXITALL':
						return self.states['epsilon2080']
					elif self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2079']
					elif len(self.event.get_param('address')) == 0:
						pass
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2078']
					elif self.event == 'ENTER':
						return self.states['INSCOPE']
				return self.states['OUTSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == 'epsilon2083':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2085':
				return self.states['epsilon2086']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2082':
				theglobals.gui.hide_time()
				return self.states['epsilon2085']
			elif self.state == 'epsilon2081':
				if (1):
					return self.states['epsilon2082']
				else: return self.states['epsilon2083']
			elif self.state == 'epsilon2080':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2086':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2078':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2079':
				return self.states['INSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon2077':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2082':
			ta = 0
		elif self.state == 'epsilon2081':
			ta = 0
		elif self.state == 'epsilon2080':
			ta = 0
		elif self.state == 'epsilon2087':
			ta = 0
		elif self.state == 'epsilon2086':
			ta = 0
		elif self.state == 'epsilon2078':
			ta = 0
		elif self.state == 'epsilon2079':
			ta = 0
		elif self.state == 'epsilon2083':
			ta = 0
		elif self.state == 'epsilon2085':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2084':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		else: ta = INFINITY
		if self.inscope and not self.timeout:
			ta_after = max(0, 1.0-self.elapsed_since_inscope)
		else:
			ta_after = INFINITY
		return minEx(ta, ta_after)
	def outputFnc(self):
		if self.state == 'epsilon2086':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'HIDE'])
				event.set_param('return_address', ['_PARENT_', 'SHOW'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2080':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('history_state', 'SHOW')
				event.set_param('address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2085':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2078':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2079':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class HIDE(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 6.5
		self.is_relay = 0
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['epsilon2089'] = DEVSstate('epsilon2089')
		self.states['epsilon2090'] = DEVSstate('epsilon2090')
		self.states['epsilon2091'] = DEVSstate('epsilon2091')
		self.states['epsilon2092'] = DEVSstate('epsilon2092')
		self.states['epsilon2093'] = DEVSstate('epsilon2093')
		self.states['epsilon2094'] = DEVSstate('epsilon2094')
		self.states['epsilon2095'] = DEVSstate('epsilon2095')
		self.states['epsilon2096'] = DEVSstate('epsilon2096')
		self.states['epsilon2097'] = DEVSstate('epsilon2097')
		self.states['epsilon2098'] = DEVSstate('epsilon2098')
		self.states['epsilon2099'] = DEVSstate('epsilon2099')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		if not self.timeout and round(self.elapsed_since_inscope, 6) >= 1.0:
			self.Q.append(EVENT('_TIMEOUT_'))
			self.elapsed_since_inscope = 0
			self.timeout = 1
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == '_TIMEOUT_':
						return self.states['epsilon2093']
					elif self.event == 'EXITALL':
						return self.states['epsilon2092']
					elif self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2091']
					elif len(self.event.get_param('address')) == 0:
						pass
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2090']
					elif self.event == 'ENTER':
						return self.states['INSCOPE']
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2098':
				return self.states['OUTSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == 'epsilon2090':
				return self.states['OUTSCOPE']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2091':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2092':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2093':
				if (1):
					return self.states['epsilon2094']
				else: return self.states['epsilon2095']
			elif self.state == 'epsilon2094':
				theglobals.gui.show_time()
				return self.states['epsilon2097']
			elif self.state == 'epsilon2095':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2097':
				return self.states['epsilon2098']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon2098':
			ta = 0
		elif self.state == 'epsilon2099':
			ta = 0
		elif self.state == 'epsilon2089':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2091':
			ta = 0
		elif self.state == 'epsilon2092':
			ta = 0
		elif self.state == 'epsilon2093':
			ta = 0
		elif self.state == 'epsilon2094':
			ta = 0
		elif self.state == 'epsilon2095':
			ta = 0
		elif self.state == 'epsilon2096':
			ta = 0
		elif self.state == 'epsilon2097':
			ta = 0
		elif self.state == 'epsilon2090':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		else: ta = INFINITY
		if self.inscope and not self.timeout:
			ta_after = max(0, 1.0-self.elapsed_since_inscope)
		else:
			ta_after = INFINITY
		return minEx(ta, ta_after)
	def outputFnc(self):
		if self.state == 'epsilon2090':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2091':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2092':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('history_state', 'HIDE')
				event.set_param('address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2098':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'SHOW'])
				event.set_param('return_address', ['_PARENT_', 'HIDE'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2097':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class GUIPAUSE(CoupledDEVS):
	def __init__(self):
		CoupledDEVS.__init__(self)
		self.scope = 5
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.relay=self.addSubModel(RELAY_GUIPAUSE_ATOMIC_2058())
		self.SHOW=self.addSubModel(SHOW())
		self.HIDE=self.addSubModel(HIDE())
		self.relay.ports['SHOW'] = self.relay.addOutPort('SHOW')
		self.relay.ports['HIDE'] = self.relay.addOutPort('HIDE')
		self.connectPorts(self.relay.ports['SHOW'], self.SHOW.ports['_IN_'])
		self.connectPorts(self.SHOW.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.SHOW.ports['_IN_'])
		self.connectPorts(self.relay.ports['HIDE'], self.HIDE.ports['_IN_'])
		self.connectPorts(self.HIDE.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.HIDE.ports['_IN_'])
		self.connectPorts(self.ports['_IN_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_PARENT_'], self.ports['_PARENT_'])
	def select(self, imm): return choose(self, imm)
class GUIPLAY(CoupledDEVS):
	def __init__(self):
		CoupledDEVS.__init__(self)
		self.scope = 4
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.relay=self.addSubModel(RELAY_GUIPLAY_ATOMIC_2011())
		self.GUIPLAYING=self.addSubModel(GUIPLAYING())
		self.GUIPAUSE=self.addSubModel(GUIPAUSE())
		self.relay.ports['GUIPLAYING'] = self.relay.addOutPort('GUIPLAYING')
		self.relay.ports['GUIPAUSE'] = self.relay.addOutPort('GUIPAUSE')
		self.connectPorts(self.relay.ports['GUIPLAYING'], self.GUIPLAYING.ports['_IN_'])
		self.connectPorts(self.GUIPLAYING.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.GUIPLAYING.ports['_IN_'])
		self.connectPorts(self.relay.ports['GUIPAUSE'], self.GUIPAUSE.ports['_IN_'])
		self.connectPorts(self.GUIPAUSE.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.GUIPAUSE.ports['_IN_'])
		self.connectPorts(self.ports['_IN_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_PARENT_'], self.ports['_PARENT_'])
	def select(self, imm): return choose(self, imm)
class GUIFF(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 4.5
		self.is_relay = 0
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['epsilon2101'] = DEVSstate('epsilon2101')
		self.states['epsilon2102'] = DEVSstate('epsilon2102')
		self.states['epsilon2103'] = DEVSstate('epsilon2103')
		self.states['epsilon2104'] = DEVSstate('epsilon2104')
		self.states['epsilon2105'] = DEVSstate('epsilon2105')
		self.states['epsilon2106'] = DEVSstate('epsilon2106')
		self.states['epsilon2107'] = DEVSstate('epsilon2107')
		self.states['epsilon2108'] = DEVSstate('epsilon2108')
		self.states['epsilon2109'] = DEVSstate('epsilon2109')
		self.states['epsilon2110'] = DEVSstate('epsilon2110')
		self.states['epsilon2111'] = DEVSstate('epsilon2111')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'EXITALL':
						return self.states['epsilon2104']
					elif self.event == 'GUI Forward Released':
						return self.states['epsilon2105']
					elif self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2103']
					elif len(self.event.get_param('address')) == 0:
						pass
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2102']
					elif self.event == 'ENTER':
						return self.states['INSCOPE']
				return self.states['OUTSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == 'epsilon2109':
				return self.states['epsilon2110']
			elif self.state == 'epsilon2110':
				return self.states['OUTSCOPE']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2103':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2102':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2106':
				#[SetButtons(NORMAL, NORMAL, NORMAL, NORMAL)]
				return self.states['epsilon2109']
			elif self.state == 'epsilon2107':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2104':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2105':
				if (1):
					return self.states['epsilon2106']
				else: return self.states['epsilon2107']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon2102':
			ta = 0
		elif self.state == 'epsilon2108':
			ta = 0
		elif self.state == 'epsilon2109':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2103':
			ta = 0
		elif self.state == 'epsilon2101':
			ta = 0
		elif self.state == 'epsilon2106':
			ta = 0
		elif self.state == 'epsilon2107':
			ta = 0
		elif self.state == 'epsilon2104':
			ta = 0
		elif self.state == 'epsilon2105':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2111':
			ta = 0
		elif self.state == 'epsilon2110':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == 'epsilon2102':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2103':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2109':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2110':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'GUIPLAY'])
				event.set_param('history', 'TRUE')
				event.set_param('return_address', ['_PARENT_', 'GUIFF'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2104':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('history_state', 'GUIFF')
				event.set_param('address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class GUIRW(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 4.5
		self.is_relay = 0
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['epsilon2113'] = DEVSstate('epsilon2113')
		self.states['epsilon2114'] = DEVSstate('epsilon2114')
		self.states['epsilon2115'] = DEVSstate('epsilon2115')
		self.states['epsilon2116'] = DEVSstate('epsilon2116')
		self.states['epsilon2117'] = DEVSstate('epsilon2117')
		self.states['epsilon2118'] = DEVSstate('epsilon2118')
		self.states['epsilon2119'] = DEVSstate('epsilon2119')
		self.states['epsilon2120'] = DEVSstate('epsilon2120')
		self.states['epsilon2121'] = DEVSstate('epsilon2121')
		self.states['epsilon2122'] = DEVSstate('epsilon2122')
		self.states['epsilon2123'] = DEVSstate('epsilon2123')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'EXITALL':
						return self.states['epsilon2116']
					elif self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2115']
					elif self.event == 'GUI Backward Released':
						return self.states['epsilon2117']
					elif len(self.event.get_param('address')) == 0:
						pass
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2114']
					elif self.event == 'ENTER':
						return self.states['INSCOPE']
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2115':
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == 'epsilon2117':
				if (1):
					return self.states['epsilon2118']
				else: return self.states['epsilon2119']
			elif self.state == 'epsilon2116':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2114':
				return self.states['OUTSCOPE']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2122':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2121':
				return self.states['epsilon2122']
			elif self.state == 'epsilon2119':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2118':
				#[SetButtons(NORMAL, NORMAL, NORMAL, NORMAL)]
				return self.states['epsilon2121']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon2120':
			ta = 0
		elif self.state == 'epsilon2114':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2121':
			ta = 0
		elif self.state == 'epsilon2123':
			ta = 0
		elif self.state == 'epsilon2122':
			ta = 0
		elif self.state == 'epsilon2118':
			ta = 0
		elif self.state == 'epsilon2115':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2117':
			ta = 0
		elif self.state == 'epsilon2116':
			ta = 0
		elif self.state == 'epsilon2113':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2119':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == 'epsilon2115':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2114':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2122':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'GUIPLAY'])
				event.set_param('history', 'TRUE')
				event.set_param('return_address', ['_PARENT_', 'GUIRW'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2116':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('history_state', 'GUIRW')
				event.set_param('address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2121':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class GUIACTIVE(CoupledDEVS):
	def __init__(self):
		CoupledDEVS.__init__(self)
		self.scope = 3
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.relay=self.addSubModel(RELAY_GUIACTIVE_ATOMIC_1984())
		self.GUIPLAY=self.addSubModel(GUIPLAY())
		self.GUIFF=self.addSubModel(GUIFF())
		self.GUIRW=self.addSubModel(GUIRW())
		self.relay.ports['GUIPLAY'] = self.relay.addOutPort('GUIPLAY')
		self.relay.ports['GUIFF'] = self.relay.addOutPort('GUIFF')
		self.relay.ports['GUIRW'] = self.relay.addOutPort('GUIRW')
		self.connectPorts(self.relay.ports['GUIPLAY'], self.GUIPLAY.ports['_IN_'])
		self.connectPorts(self.GUIPLAY.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.GUIPLAY.ports['_IN_'])
		self.connectPorts(self.relay.ports['GUIFF'], self.GUIFF.ports['_IN_'])
		self.connectPorts(self.GUIFF.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.GUIFF.ports['_IN_'])
		self.connectPorts(self.relay.ports['GUIRW'], self.GUIRW.ports['_IN_'])
		self.connectPorts(self.GUIRW.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.GUIRW.ports['_IN_'])
		self.connectPorts(self.ports['_IN_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_PARENT_'], self.ports['_PARENT_'])
	def select(self, imm): return choose(self, imm)
class GUISTOP(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 3.5
		self.is_relay = 0
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['epsilon2125'] = DEVSstate('epsilon2125')
		self.states['epsilon2126'] = DEVSstate('epsilon2126')
		self.states['epsilon2127'] = DEVSstate('epsilon2127')
		self.states['epsilon2128'] = DEVSstate('epsilon2128')
		self.states['epsilon2129'] = DEVSstate('epsilon2129')
		self.states['epsilon2130'] = DEVSstate('epsilon2130')
		self.states['epsilon2131'] = DEVSstate('epsilon2131')
		self.states['epsilon2132'] = DEVSstate('epsilon2132')
		self.states['epsilon2133'] = DEVSstate('epsilon2133')
		self.states['epsilon2134'] = DEVSstate('epsilon2134')
		self.states['epsilon2135'] = DEVSstate('epsilon2135')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'EXITALL':
						return self.states['epsilon2128']
					elif self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2127']
					elif self.event == 'GUI Play/Pause':
						return self.states['epsilon2129']
					elif len(self.event.get_param('address')) == 0:
						pass
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2126']
					elif self.event == 'ENTER':
						return self.states['INSCOPE']
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2133':
				return self.states['epsilon2134']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == 'epsilon2131':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2130':
				theglobals.gui.show_time()
				return self.states['epsilon2133']
			elif self.state == 'epsilon2126':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2127':
				return self.states['INSCOPE']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2129':
				if (1):
					return self.states['epsilon2130']
				else: return self.states['epsilon2131']
			elif self.state == 'epsilon2134':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2128':
				return self.states['OUTSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon2135':
			ta = 0
		elif self.state == 'epsilon2132':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2134':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2133':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2131':
			ta = 0
		elif self.state == 'epsilon2130':
			ta = 0
		elif self.state == 'epsilon2125':
			ta = 0
		elif self.state == 'epsilon2126':
			ta = 0
		elif self.state == 'epsilon2127':
			ta = 0
		elif self.state == 'epsilon2128':
			ta = 0
		elif self.state == 'epsilon2129':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == 'epsilon2128':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('history_state', 'GUISTOP')
				event.set_param('address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2133':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2134':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'GUIACTIVE', 'GUIPLAY', 'GUIPLAYING'])
				event.set_param('return_address', ['_PARENT_', '_PARENT_', '_PARENT_', 'GUISTOP'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2126':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2127':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class GUI(CoupledDEVS):
	def __init__(self):
		CoupledDEVS.__init__(self)
		self.scope = 2
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.relay=self.addSubModel(RELAY_GUI_ATOMIC_1973())
		self.GUIACTIVE=self.addSubModel(GUIACTIVE())
		self.GUISTOP=self.addSubModel(GUISTOP())
		self.relay.ports['GUIACTIVE'] = self.relay.addOutPort('GUIACTIVE')
		self.relay.ports['GUISTOP'] = self.relay.addOutPort('GUISTOP')
		self.connectPorts(self.relay.ports['GUIACTIVE'], self.GUIACTIVE.ports['_IN_'])
		self.connectPorts(self.GUIACTIVE.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.GUIACTIVE.ports['_IN_'])
		self.connectPorts(self.relay.ports['GUISTOP'], self.GUISTOP.ports['_IN_'])
		self.connectPorts(self.GUISTOP.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.GUISTOP.ports['_IN_'])
		self.connectPorts(self.ports['_IN_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_PARENT_'], self.ports['_PARENT_'])
	def select(self, imm): return choose(self, imm)
class RELAY_AUDIO_ATOMIC_2137(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 2
		self.is_relay = 1
		self.current_child = None
		self.history = 'AUDIOSTOP'
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['__default_hook'] = DEVSstate('__default_hook')
		self.states['epsilon2137'] = DEVSstate('epsilon2137')
		self.states['__history_hook'] = DEVSstate('__history_hook')
		self.states['__history_star_hook'] = DEVSstate('__history_star_hook')
		self.states['__alpha_relay_hook'] = DEVSstate('__alpha_relay_hook')
		self.states['__relay_hook'] = DEVSstate('__relay_hook')
		self.states['__broadcast_hook'] = DEVSstate('__broadcast_hook')
		self.states['epsilon2138'] = DEVSstate('epsilon2138')
		self.states['epsilon2139'] = DEVSstate('epsilon2139')
		self.states['epsilon2140'] = DEVSstate('epsilon2140')
		self.states['epsilon2141'] = DEVSstate('epsilon2141')
		self.states['epsilon2142'] = DEVSstate('epsilon2142')
		self.states['wait2143'] = DEVSstate('wait2143')
		self.states['epsilon2144'] = DEVSstate('epsilon2144')
		self.states['epsilon2145'] = DEVSstate('epsilon2145')
		self.states['epsilon2146'] = DEVSstate('epsilon2146')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'EXITALL':
						return self.states['epsilon2141']
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: temp = 'INSCOPE'
						elif self.event.get_param('address')[0] == '_PARENT_':
							temp = 'epsilon2146'
							self.current_child = None
						else:
							temp = 'epsilon2145'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
					elif self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon2138'
						return self.states[temp]
					elif len(self.event.get_param('address')) == 0:
						if self.event.get_param('broadcast') == 'TRUE': return '__broadcast_hook'
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: # REACHED DESTINATION
							self.return_address = self.event.get_param('return_address')
							if self.event.get_param('history') == 'TRUE':
								if self.event.get_param('broadcast') == 'TRUE': temp = '__history_star_hook'
								else: temp = '__history_hook'
							else: temp = '__default_hook'
						else:
							temp = 'epsilon2144'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
					elif self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon2138'
						return self.states[temp]
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2146':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2144':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2145':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2142':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2140':
				return self.states['OUTSCOPE']
			elif self.state == '__history_star_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'epsilon2141':
				return self.states['wait2143']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == '__relay_hook':
				return self.states['INSCOPE']
			elif self.state == '__history_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'wait2143':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2142'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon2137':
				self.current_child = 'AUDIOSTOP'
				return self.states['INSCOPE']
			elif self.state == '__default_hook':
				return self.states['epsilon2137']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2139':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2138':
				return self.states['INSCOPE']
			elif self.state == '__alpha_relay_hook':
				return self.states[self.restore]
			elif self.state == '__broadcast_hook':
				return self.states['INSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon2146':
			ta = 0
		elif self.state == 'epsilon2144':
			ta = 0
		elif self.state == 'epsilon2145':
			ta = 0
		elif self.state == 'epsilon2142':
			ta = 0
		elif self.state == 'epsilon2140':
			ta = 0
		elif self.state == '__history_star_hook':
			ta = 0
		elif self.state == 'epsilon2141':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == '__relay_hook':
			ta = 0
		elif self.state == '__history_hook':
			ta = 0
		elif self.state == 'wait2143':
			ta = INFINITY
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2137':
			ta = 0
		elif self.state == '__default_hook':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2139':
			ta = 0
		elif self.state == 'epsilon2138':
			ta = 0
		elif self.state == '__alpha_relay_hook':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == '__broadcast_hook':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == 'epsilon2146':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2144':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2145':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2142':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('address', ['_PARENT_'])
				event.set_param('history_state', 'AUDIO')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_star_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('broadcast', 'TRUE')
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2140':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2141':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2137':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['AUDIOSTOP'])
				event.set_param('return_address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2139':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2138':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__alpha_relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__broadcast_hook':
			def __outputFnc(self):
				self.event.set_param('address', [self.current_child])
				self.event.set_param('broadcast', 'TRUE')
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class RELAY_AUDIOACTIVE_ATOMIC_2148(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 3
		self.is_relay = 1
		self.current_child = None
		self.history = 'AUDIOPLAY'
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['__default_hook'] = DEVSstate('__default_hook')
		self.states['epsilon2148'] = DEVSstate('epsilon2148')
		self.states['__history_hook'] = DEVSstate('__history_hook')
		self.states['__history_star_hook'] = DEVSstate('__history_star_hook')
		self.states['__alpha_relay_hook'] = DEVSstate('__alpha_relay_hook')
		self.states['__relay_hook'] = DEVSstate('__relay_hook')
		self.states['__broadcast_hook'] = DEVSstate('__broadcast_hook')
		self.states['epsilon2149'] = DEVSstate('epsilon2149')
		self.states['epsilon2150'] = DEVSstate('epsilon2150')
		self.states['epsilon2151'] = DEVSstate('epsilon2151')
		self.states['epsilon2152'] = DEVSstate('epsilon2152')
		self.states['epsilon2153'] = DEVSstate('epsilon2153')
		self.states['wait2154'] = DEVSstate('wait2154')
		self.states['epsilon2155'] = DEVSstate('epsilon2155')
		self.states['epsilon2156'] = DEVSstate('epsilon2156')
		self.states['epsilon2157'] = DEVSstate('epsilon2157')
		self.states['epsilon2158'] = DEVSstate('epsilon2158')
		self.states['epsilon2159'] = DEVSstate('epsilon2159')
		self.states['epsilon2160'] = DEVSstate('epsilon2160')
		self.states['epsilon2161'] = DEVSstate('epsilon2161')
		self.states['epsilon2162'] = DEVSstate('epsilon2162')
		self.states['epsilon2163'] = DEVSstate('epsilon2163')
		self.states['epsilon2164'] = DEVSstate('epsilon2164')
		self.states['wait2165'] = DEVSstate('wait2165')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'EXITALL':
						return self.states['epsilon2152']
					elif self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon2149'
						return self.states[temp]
					elif self.event == 'Playing Stopped':
						return self.states['epsilon2158']
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: temp = 'INSCOPE'
						elif self.event.get_param('address')[0] == '_PARENT_':
							temp = 'epsilon2157'
							self.current_child = None
						else:
							temp = 'epsilon2156'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
					elif len(self.event.get_param('address')) == 0:
						if self.event.get_param('broadcast') == 'TRUE': return '__broadcast_hook'
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon2149'
						return self.states[temp]
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: # REACHED DESTINATION
							self.return_address = self.event.get_param('return_address')
							if self.event.get_param('history') == 'TRUE':
								if self.event.get_param('broadcast') == 'TRUE': temp = '__history_star_hook'
								else: temp = '__history_hook'
							else: temp = '__default_hook'
						else:
							temp = 'epsilon2155'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
				return self.states['OUTSCOPE']
			elif self.state == '__history_star_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'wait2165':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2164'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == '__relay_hook':
				return self.states['INSCOPE']
			elif self.state == 'wait2154':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2153'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon2162':
				return self.states['wait2165']
			elif self.state == '__default_hook':
				return self.states['epsilon2148']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2163':
				return self.states['OUTSCOPE']
			elif self.state == '__alpha_relay_hook':
				return self.states[self.restore]
			elif self.state == 'epsilon2151':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2150':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2153':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2152':
				return self.states['wait2154']
			elif self.state == 'epsilon2155':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2157':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2156':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2159':
				theglobals.audio.stop()
				theglobals.audio.rewind()
				return self.states['epsilon2162']
			elif self.state == 'epsilon2158':
				if (1):
					return self.states['epsilon2159']
				else: return self.states['epsilon2160']
			elif self.state == '__history_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'epsilon2160':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2148':
				self.current_child = 'AUDIOPLAY'
				return self.states['INSCOPE']
			elif self.state == 'epsilon2149':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2164':
				return self.states['epsilon2163']
			elif self.state == '__broadcast_hook':
				return self.states['INSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == '__history_star_hook':
			ta = 0
		elif self.state == 'wait2165':
			ta = INFINITY
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == '__relay_hook':
			ta = 0
		elif self.state == 'wait2154':
			ta = INFINITY
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2162':
			ta = 0
		elif self.state == '__default_hook':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2163':
			ta = 0
		elif self.state == '__alpha_relay_hook':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2151':
			ta = 0
		elif self.state == 'epsilon2150':
			ta = 0
		elif self.state == 'epsilon2153':
			ta = 0
		elif self.state == 'epsilon2152':
			ta = 0
		elif self.state == 'epsilon2155':
			ta = 0
		elif self.state == 'epsilon2157':
			ta = 0
		elif self.state == 'epsilon2156':
			ta = 0
		elif self.state == 'epsilon2159':
			ta = 0
		elif self.state == 'epsilon2158':
			ta = 0
		elif self.state == '__history_hook':
			ta = 0
		elif self.state == 'epsilon2160':
			ta = 0
		elif self.state == 'epsilon2161':
			ta = 0
		elif self.state == 'epsilon2148':
			ta = 0
		elif self.state == 'epsilon2149':
			ta = 0
		elif self.state == 'epsilon2164':
			ta = 0
		elif self.state == '__broadcast_hook':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == 'epsilon2151':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2150':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2153':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('address', ['_PARENT_'])
				event.set_param('history_state', 'AUDIOACTIVE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2152':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2155':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2157':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_star_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('broadcast', 'TRUE')
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2156':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2164':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2148':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['AUDIOPLAY'])
				event.set_param('return_address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2149':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2162':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2163':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'AUDIOSTOP'])
				event.set_param('return_address', ['_PARENT_', 'AUDIOACTIVE'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__alpha_relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__broadcast_hook':
			def __outputFnc(self):
				self.event.set_param('address', [self.current_child])
				self.event.set_param('broadcast', 'TRUE')
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class RELAY_AUDIOPLAY_ATOMIC_2167(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 4
		self.is_relay = 1
		self.current_child = None
		self.history = 'AUDIOPLAYING'
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['__default_hook'] = DEVSstate('__default_hook')
		self.states['epsilon2167'] = DEVSstate('epsilon2167')
		self.states['__history_hook'] = DEVSstate('__history_hook')
		self.states['__history_star_hook'] = DEVSstate('__history_star_hook')
		self.states['__alpha_relay_hook'] = DEVSstate('__alpha_relay_hook')
		self.states['__relay_hook'] = DEVSstate('__relay_hook')
		self.states['__broadcast_hook'] = DEVSstate('__broadcast_hook')
		self.states['epsilon2168'] = DEVSstate('epsilon2168')
		self.states['epsilon2169'] = DEVSstate('epsilon2169')
		self.states['epsilon2170'] = DEVSstate('epsilon2170')
		self.states['epsilon2171'] = DEVSstate('epsilon2171')
		self.states['epsilon2172'] = DEVSstate('epsilon2172')
		self.states['wait2173'] = DEVSstate('wait2173')
		self.states['epsilon2174'] = DEVSstate('epsilon2174')
		self.states['epsilon2175'] = DEVSstate('epsilon2175')
		self.states['epsilon2176'] = DEVSstate('epsilon2176')
		self.states['epsilon2177'] = DEVSstate('epsilon2177')
		self.states['epsilon2178'] = DEVSstate('epsilon2178')
		self.states['epsilon2179'] = DEVSstate('epsilon2179')
		self.states['epsilon2180'] = DEVSstate('epsilon2180')
		self.states['epsilon2181'] = DEVSstate('epsilon2181')
		self.states['epsilon2182'] = DEVSstate('epsilon2182')
		self.states['epsilon2183'] = DEVSstate('epsilon2183')
		self.states['wait2184'] = DEVSstate('wait2184')
		self.states['epsilon2185'] = DEVSstate('epsilon2185')
		self.states['epsilon2186'] = DEVSstate('epsilon2186')
		self.states['epsilon2187'] = DEVSstate('epsilon2187')
		self.states['epsilon2188'] = DEVSstate('epsilon2188')
		self.states['epsilon2189'] = DEVSstate('epsilon2189')
		self.states['epsilon2190'] = DEVSstate('epsilon2190')
		self.states['epsilon2191'] = DEVSstate('epsilon2191')
		self.states['wait2192'] = DEVSstate('wait2192')
		self.states['epsilon2193'] = DEVSstate('epsilon2193')
		self.states['epsilon2194'] = DEVSstate('epsilon2194')
		self.states['epsilon2195'] = DEVSstate('epsilon2195')
		self.states['epsilon2196'] = DEVSstate('epsilon2196')
		self.states['epsilon2197'] = DEVSstate('epsilon2197')
		self.states['epsilon2198'] = DEVSstate('epsilon2198')
		self.states['epsilon2199'] = DEVSstate('epsilon2199')
		self.states['wait2200'] = DEVSstate('wait2200')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'GUI Stop':
						return self.states['epsilon2177']
					elif self.event == 'GUI Backward Pressed':
						return self.states['epsilon2193']
					elif self.event == 'EXITALL':
						return self.states['epsilon2171']
					elif self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon2168'
						return self.states[temp]
					elif self.event == 'GUI Forward Pressed':
						return self.states['epsilon2185']
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: temp = 'INSCOPE'
						elif self.event.get_param('address')[0] == '_PARENT_':
							temp = 'epsilon2176'
							self.current_child = None
						else:
							temp = 'epsilon2175'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
					elif len(self.event.get_param('address')) == 0:
						if self.event.get_param('broadcast') == 'TRUE': return '__broadcast_hook'
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon2168'
						return self.states[temp]
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: # REACHED DESTINATION
							self.return_address = self.event.get_param('return_address')
							if self.event.get_param('history') == 'TRUE':
								if self.event.get_param('broadcast') == 'TRUE': temp = '__history_star_hook'
								else: temp = '__history_hook'
							else: temp = '__default_hook'
						else:
							temp = 'epsilon2174'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2182':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2183':
				return self.states['epsilon2182']
			elif self.state == 'epsilon2167':
				self.current_child = 'AUDIOPLAYING'
				return self.states['INSCOPE']
			elif self.state == 'epsilon2186':
				return self.states['epsilon2189']
			elif self.state == 'epsilon2187':
				return self.states['INSCOPE']
			elif self.state == '__history_star_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'epsilon2185':
				if (1):
					return self.states['epsilon2186']
				else: return self.states['epsilon2187']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == '__relay_hook':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2197':
				return self.states['wait2200']
			elif self.state == 'epsilon2189':
				return self.states['wait2192']
			elif self.state == 'epsilon2191':
				return self.states['epsilon2190']
			elif self.state == 'epsilon2190':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2193':
				if (1):
					return self.states['epsilon2194']
				else: return self.states['epsilon2195']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2181':
				return self.states['wait2184']
			elif self.state == '__default_hook':
				return self.states['epsilon2167']
			elif self.state == 'wait2173':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2172'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon2199':
				return self.states['epsilon2198']
			elif self.state == 'epsilon2194':
				return self.states['epsilon2197']
			elif self.state == 'wait2200':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2199'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == '__alpha_relay_hook':
				return self.states[self.restore]
			elif self.state == 'epsilon2198':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2168':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2169':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2179':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2178':
				theglobals.audio.stop()
				theglobals.audio.rewind()
				return self.states['epsilon2181']
			elif self.state == 'epsilon2177':
				if (1):
					return self.states['epsilon2178']
				else: return self.states['epsilon2179']
			elif self.state == 'epsilon2176':
				return self.states['OUTSCOPE']
			elif self.state == '__history_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'epsilon2174':
				return self.states['INSCOPE']
			elif self.state == 'wait2184':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2183'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon2172':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2171':
				return self.states['wait2173']
			elif self.state == 'epsilon2170':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2195':
				return self.states['INSCOPE']
			elif self.state == 'wait2192':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2191'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon2175':
				return self.states['INSCOPE']
			elif self.state == '__broadcast_hook':
				return self.states['INSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon2182':
			ta = 0
		elif self.state == 'epsilon2183':
			ta = 0
		elif self.state == 'epsilon2180':
			ta = 0
		elif self.state == 'epsilon2181':
			ta = 0
		elif self.state == 'epsilon2186':
			ta = 0
		elif self.state == 'epsilon2187':
			ta = 0
		elif self.state == 'epsilon2185':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2188':
			ta = 0
		elif self.state == 'epsilon2189':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == '__alpha_relay_hook':
			ta = 0
		elif self.state == 'wait2173':
			ta = INFINITY
		elif self.state == 'epsilon2179':
			ta = 0
		elif self.state == 'epsilon2178':
			ta = 0
		elif self.state == 'epsilon2177':
			ta = 0
		elif self.state == 'epsilon2176':
			ta = 0
		elif self.state == 'epsilon2175':
			ta = 0
		elif self.state == 'epsilon2174':
			ta = 0
		elif self.state == 'wait2184':
			ta = INFINITY
		elif self.state == 'epsilon2172':
			ta = 0
		elif self.state == 'epsilon2171':
			ta = 0
		elif self.state == 'epsilon2170':
			ta = 0
		elif self.state == 'epsilon2194':
			ta = 0
		elif self.state == '__broadcast_hook':
			ta = 0
		elif self.state == 'epsilon2199':
			ta = 0
		elif self.state == 'epsilon2198':
			ta = 0
		elif self.state == '__history_star_hook':
			ta = 0
		elif self.state == 'epsilon2195':
			ta = 0
		elif self.state == '__relay_hook':
			ta = 0
		elif self.state == 'epsilon2197':
			ta = 0
		elif self.state == 'epsilon2196':
			ta = 0
		elif self.state == 'epsilon2191':
			ta = 0
		elif self.state == 'epsilon2190':
			ta = 0
		elif self.state == 'epsilon2193':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == '__default_hook':
			ta = 0
		elif self.state == 'wait2200':
			ta = INFINITY
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2168':
			ta = 0
		elif self.state == 'epsilon2169':
			ta = 0
		elif self.state == 'wait2192':
			ta = INFINITY
		elif self.state == 'epsilon2167':
			ta = 0
		elif self.state == '__history_hook':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == 'epsilon2182':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', '_PARENT_', 'AUDIOSTOP'])
				event.set_param('return_address', ['_PARENT_', 'AUDIOACTIVE', 'AUDIOPLAY'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2183':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2167':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['AUDIOPLAYING'])
				event.set_param('return_address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2199':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2198':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'AUDIORW'])
				event.set_param('return_address', ['_PARENT_', 'AUDIOPLAY'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_star_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('broadcast', 'TRUE')
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2197':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2189':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2191':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2190':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'AUDIOFF'])
				event.set_param('return_address', ['_PARENT_', 'AUDIOPLAY'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2181':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__alpha_relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2168':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2169':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2176':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2174':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2172':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('address', ['_PARENT_'])
				event.set_param('history_state', 'AUDIOPLAY')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2171':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2170':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2175':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__broadcast_hook':
			def __outputFnc(self):
				self.event.set_param('address', [self.current_child])
				self.event.set_param('broadcast', 'TRUE')
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class AUDIOPLAYING(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 5.5
		self.is_relay = 0
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['epsilon2202'] = DEVSstate('epsilon2202')
		self.states['epsilon2203'] = DEVSstate('epsilon2203')
		self.states['epsilon2204'] = DEVSstate('epsilon2204')
		self.states['epsilon2205'] = DEVSstate('epsilon2205')
		self.states['epsilon2206'] = DEVSstate('epsilon2206')
		self.states['epsilon2207'] = DEVSstate('epsilon2207')
		self.states['epsilon2208'] = DEVSstate('epsilon2208')
		self.states['epsilon2209'] = DEVSstate('epsilon2209')
		self.states['epsilon2210'] = DEVSstate('epsilon2210')
		self.states['epsilon2211'] = DEVSstate('epsilon2211')
		self.states['epsilon2212'] = DEVSstate('epsilon2212')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'EXITALL':
						return self.states['epsilon2205']
					elif self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2204']
					elif self.event == 'GUI Play/Pause':
						return self.states['epsilon2206']
					elif len(self.event.get_param('address')) == 0:
						pass
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2203']
					elif self.event == 'ENTER':
						return self.states['INSCOPE']
				return self.states['OUTSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == 'epsilon2203':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2210':
				return self.states['epsilon2211']
			elif self.state == 'epsilon2205':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2204':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2207':
				theglobals.audio.pause()
				return self.states['epsilon2210']
			elif self.state == 'epsilon2206':
				if (1):
					return self.states['epsilon2207']
				else: return self.states['epsilon2208']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2208':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2211':
				return self.states['OUTSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon2203':
			ta = 0
		elif self.state == 'epsilon2202':
			ta = 0
		elif self.state == 'epsilon2205':
			ta = 0
		elif self.state == 'epsilon2204':
			ta = 0
		elif self.state == 'epsilon2207':
			ta = 0
		elif self.state == 'epsilon2206':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2208':
			ta = 0
		elif self.state == 'epsilon2211':
			ta = 0
		elif self.state == 'epsilon2210':
			ta = 0
		elif self.state == 'epsilon2209':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2212':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == 'epsilon2203':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2205':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('history_state', 'AUDIOPLAYING')
				event.set_param('address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2204':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2210':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2211':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'AUDIOPAUSE'])
				event.set_param('return_address', ['_PARENT_', 'AUDIOPLAYING'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class AUDIOPAUSE(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 5.5
		self.is_relay = 0
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['epsilon2214'] = DEVSstate('epsilon2214')
		self.states['epsilon2215'] = DEVSstate('epsilon2215')
		self.states['epsilon2216'] = DEVSstate('epsilon2216')
		self.states['epsilon2217'] = DEVSstate('epsilon2217')
		self.states['epsilon2218'] = DEVSstate('epsilon2218')
		self.states['epsilon2219'] = DEVSstate('epsilon2219')
		self.states['epsilon2220'] = DEVSstate('epsilon2220')
		self.states['epsilon2221'] = DEVSstate('epsilon2221')
		self.states['epsilon2222'] = DEVSstate('epsilon2222')
		self.states['epsilon2223'] = DEVSstate('epsilon2223')
		self.states['epsilon2224'] = DEVSstate('epsilon2224')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'EXITALL':
						return self.states['epsilon2217']
					elif self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2216']
					elif self.event == 'GUI Play/Pause':
						return self.states['epsilon2218']
					elif len(self.event.get_param('address')) == 0:
						pass
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2215']
					elif self.event == 'ENTER':
						return self.states['INSCOPE']
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2216':
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == 'epsilon2215':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2217':
				return self.states['OUTSCOPE']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2220':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2223':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2222':
				return self.states['epsilon2223']
			elif self.state == 'epsilon2218':
				if (1):
					return self.states['epsilon2219']
				else: return self.states['epsilon2220']
			elif self.state == 'epsilon2219':
				theglobals.audio.resume()
				return self.states['epsilon2222']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon2216':
			ta = 0
		elif self.state == 'epsilon2217':
			ta = 0
		elif self.state == 'epsilon2214':
			ta = 0
		elif self.state == 'epsilon2215':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2224':
			ta = 0
		elif self.state == 'epsilon2223':
			ta = 0
		elif self.state == 'epsilon2222':
			ta = 0
		elif self.state == 'epsilon2218':
			ta = 0
		elif self.state == 'epsilon2220':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2221':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2219':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == 'epsilon2216':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2217':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('history_state', 'AUDIOPAUSE')
				event.set_param('address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2215':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2223':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'AUDIOPLAYING'])
				event.set_param('return_address', ['_PARENT_', 'AUDIOPAUSE'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2222':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class AUDIOPLAY(CoupledDEVS):
	def __init__(self):
		CoupledDEVS.__init__(self)
		self.scope = 4
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.relay=self.addSubModel(RELAY_AUDIOPLAY_ATOMIC_2167())
		self.AUDIOPLAYING=self.addSubModel(AUDIOPLAYING())
		self.AUDIOPAUSE=self.addSubModel(AUDIOPAUSE())
		self.relay.ports['AUDIOPLAYING'] = self.relay.addOutPort('AUDIOPLAYING')
		self.relay.ports['AUDIOPAUSE'] = self.relay.addOutPort('AUDIOPAUSE')
		self.connectPorts(self.relay.ports['AUDIOPLAYING'], self.AUDIOPLAYING.ports['_IN_'])
		self.connectPorts(self.AUDIOPLAYING.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.AUDIOPLAYING.ports['_IN_'])
		self.connectPorts(self.relay.ports['AUDIOPAUSE'], self.AUDIOPAUSE.ports['_IN_'])
		self.connectPorts(self.AUDIOPAUSE.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.AUDIOPAUSE.ports['_IN_'])
		self.connectPorts(self.ports['_IN_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_PARENT_'], self.ports['_PARENT_'])
	def select(self, imm): return choose(self, imm)
class RELAY_AUDIOFF_ATOMIC_2226(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 4
		self.is_relay = 1
		self.current_child = None
		self.history = 'FFNOW'
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['__default_hook'] = DEVSstate('__default_hook')
		self.states['epsilon2226'] = DEVSstate('epsilon2226')
		self.states['__history_hook'] = DEVSstate('__history_hook')
		self.states['__history_star_hook'] = DEVSstate('__history_star_hook')
		self.states['__alpha_relay_hook'] = DEVSstate('__alpha_relay_hook')
		self.states['__relay_hook'] = DEVSstate('__relay_hook')
		self.states['__broadcast_hook'] = DEVSstate('__broadcast_hook')
		self.states['epsilon2227'] = DEVSstate('epsilon2227')
		self.states['epsilon2228'] = DEVSstate('epsilon2228')
		self.states['epsilon2229'] = DEVSstate('epsilon2229')
		self.states['epsilon2230'] = DEVSstate('epsilon2230')
		self.states['epsilon2231'] = DEVSstate('epsilon2231')
		self.states['wait2232'] = DEVSstate('wait2232')
		self.states['epsilon2233'] = DEVSstate('epsilon2233')
		self.states['epsilon2234'] = DEVSstate('epsilon2234')
		self.states['epsilon2235'] = DEVSstate('epsilon2235')
		self.states['epsilon2236'] = DEVSstate('epsilon2236')
		self.states['epsilon2237'] = DEVSstate('epsilon2237')
		self.states['epsilon2238'] = DEVSstate('epsilon2238')
		self.states['epsilon2239'] = DEVSstate('epsilon2239')
		self.states['epsilon2240'] = DEVSstate('epsilon2240')
		self.states['epsilon2241'] = DEVSstate('epsilon2241')
		self.states['epsilon2242'] = DEVSstate('epsilon2242')
		self.states['wait2243'] = DEVSstate('wait2243')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'EXITALL':
						return self.states['epsilon2230']
					elif self.event == 'GUI Forward Released':
						return self.states['epsilon2236']
					elif self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon2227'
						return self.states[temp]
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: temp = 'INSCOPE'
						elif self.event.get_param('address')[0] == '_PARENT_':
							temp = 'epsilon2235'
							self.current_child = None
						else:
							temp = 'epsilon2234'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
					elif len(self.event.get_param('address')) == 0:
						if self.event.get_param('broadcast') == 'TRUE': return '__broadcast_hook'
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon2227'
						return self.states[temp]
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: # REACHED DESTINATION
							self.return_address = self.event.get_param('return_address')
							if self.event.get_param('history') == 'TRUE':
								if self.event.get_param('broadcast') == 'TRUE': temp = '__history_star_hook'
								else: temp = '__history_hook'
							else: temp = '__default_hook'
						else:
							temp = 'epsilon2233'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
				return self.states['OUTSCOPE']
			elif self.state == '__history_star_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == '__relay_hook':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2242':
				return self.states['epsilon2241']
			elif self.state == 'wait2243':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2242'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == '__default_hook':
				return self.states['epsilon2226']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'wait2232':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2231'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon2238':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2229':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2228':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2227':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2226':
				self.current_child = 'FFNOW'
				return self.states['INSCOPE']
			elif self.state == '__history_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'epsilon2237':
				return self.states['epsilon2240']
			elif self.state == 'epsilon2230':
				return self.states['wait2232']
			elif self.state == 'epsilon2231':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2233':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2234':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2241':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2240':
				return self.states['wait2243']
			elif self.state == 'epsilon2235':
				return self.states['OUTSCOPE']
			elif self.state == '__alpha_relay_hook':
				return self.states[self.restore]
			elif self.state == 'epsilon2236':
				if (1):
					return self.states['epsilon2237']
				else: return self.states['epsilon2238']
			elif self.state == '__broadcast_hook':
				return self.states['INSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == '__history_star_hook':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == '__relay_hook':
			ta = 0
		elif self.state == 'epsilon2242':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'wait2243':
			ta = INFINITY
		elif self.state == '__default_hook':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'wait2232':
			ta = INFINITY
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2238':
			ta = 0
		elif self.state == 'epsilon2239':
			ta = 0
		elif self.state == 'epsilon2229':
			ta = 0
		elif self.state == 'epsilon2228':
			ta = 0
		elif self.state == 'epsilon2227':
			ta = 0
		elif self.state == 'epsilon2226':
			ta = 0
		elif self.state == '__history_hook':
			ta = 0
		elif self.state == 'epsilon2237':
			ta = 0
		elif self.state == 'epsilon2230':
			ta = 0
		elif self.state == 'epsilon2231':
			ta = 0
		elif self.state == 'epsilon2233':
			ta = 0
		elif self.state == 'epsilon2234':
			ta = 0
		elif self.state == 'epsilon2241':
			ta = 0
		elif self.state == 'epsilon2240':
			ta = 0
		elif self.state == 'epsilon2235':
			ta = 0
		elif self.state == '__alpha_relay_hook':
			ta = 0
		elif self.state == 'epsilon2236':
			ta = 0
		elif self.state == '__broadcast_hook':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == '__history_star_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('broadcast', 'TRUE')
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2229':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2228':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2227':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2242':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2230':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2231':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('address', ['_PARENT_'])
				event.set_param('history_state', 'AUDIOFF')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2233':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2234':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2241':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'AUDIOPLAY'])
				event.set_param('history', 'TRUE')
				event.set_param('return_address', ['_PARENT_', 'AUDIOFF'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2240':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2226':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['FFNOW'])
				event.set_param('return_address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2235':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__alpha_relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__broadcast_hook':
			def __outputFnc(self):
				self.event.set_param('address', [self.current_child])
				self.event.set_param('broadcast', 'TRUE')
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class FFNOW(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 5.5
		self.is_relay = 0
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['epsilon2245'] = DEVSstate('epsilon2245')
		self.states['epsilon2246'] = DEVSstate('epsilon2246')
		self.states['epsilon2247'] = DEVSstate('epsilon2247')
		self.states['epsilon2248'] = DEVSstate('epsilon2248')
		self.states['epsilon2249'] = DEVSstate('epsilon2249')
		self.states['epsilon2250'] = DEVSstate('epsilon2250')
		self.states['epsilon2251'] = DEVSstate('epsilon2251')
		self.states['epsilon2252'] = DEVSstate('epsilon2252')
		self.states['epsilon2253'] = DEVSstate('epsilon2253')
		self.states['epsilon2254'] = DEVSstate('epsilon2254')
		self.states['epsilon2255'] = DEVSstate('epsilon2255')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		if not self.timeout and round(self.elapsed_since_inscope, 6) >= 0.05:
			self.Q.append(EVENT('_TIMEOUT_'))
			self.elapsed_since_inscope = 0
			self.timeout = 1
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == '_TIMEOUT_':
						return self.states['epsilon2249']
					elif self.event == 'EXITALL':
						return self.states['epsilon2248']
					elif self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2247']
					elif len(self.event.get_param('address')) == 0:
						pass
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2246']
					elif self.event == 'ENTER':
						return self.states['INSCOPE']
				return self.states['OUTSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == 'epsilon2247':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2246':
				return self.states['OUTSCOPE']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2253':
				return self.states['epsilon2254']
			elif self.state == 'epsilon2250':
				return self.states['epsilon2253']
			elif self.state == 'epsilon2251':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2249':
				if (1):
					return self.states['epsilon2250']
				else: return self.states['epsilon2251']
			elif self.state == 'epsilon2248':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2254':
				return self.states['OUTSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2253':
			ta = 0
		elif self.state == 'epsilon2250':
			ta = 0
		elif self.state == 'epsilon2251':
			ta = 0
		elif self.state == 'epsilon2254':
			ta = 0
		elif self.state == 'epsilon2248':
			ta = 0
		elif self.state == 'epsilon2245':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2247':
			ta = 0
		elif self.state == 'epsilon2246':
			ta = 0
		elif self.state == 'epsilon2252':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2255':
			ta = 0
		elif self.state == 'epsilon2249':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		else: ta = INFINITY
		if self.inscope and not self.timeout:
			ta_after = max(0, 0.05-self.elapsed_since_inscope)
		else:
			ta_after = INFINITY
		return minEx(ta, ta_after)
	def outputFnc(self):
		if self.state == 'epsilon2253':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2247':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2246':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2248':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('history_state', 'FFNOW')
				event.set_param('address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2254':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'FFWAIT'])
				event.set_param('return_address', ['_PARENT_', 'FFNOW'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class FFWAIT(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 5.5
		self.is_relay = 0
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['epsilon2257'] = DEVSstate('epsilon2257')
		self.states['epsilon2258'] = DEVSstate('epsilon2258')
		self.states['epsilon2259'] = DEVSstate('epsilon2259')
		self.states['epsilon2260'] = DEVSstate('epsilon2260')
		self.states['epsilon2261'] = DEVSstate('epsilon2261')
		self.states['epsilon2262'] = DEVSstate('epsilon2262')
		self.states['epsilon2263'] = DEVSstate('epsilon2263')
		self.states['epsilon2264'] = DEVSstate('epsilon2264')
		self.states['epsilon2265'] = DEVSstate('epsilon2265')
		self.states['epsilon2266'] = DEVSstate('epsilon2266')
		self.states['epsilon2267'] = DEVSstate('epsilon2267')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		if not self.timeout and round(self.elapsed_since_inscope, 6) >= 0.0:
			self.Q.append(EVENT('_TIMEOUT_'))
			self.elapsed_since_inscope = 0
			self.timeout = 1
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == '_TIMEOUT_':
						return self.states['epsilon2261']
					elif self.event == 'EXITALL':
						return self.states['epsilon2260']
					elif self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2259']
					elif len(self.event.get_param('address')) == 0:
						pass
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2258']
					elif self.event == 'ENTER':
						return self.states['INSCOPE']
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2263':
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == 'epsilon2258':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2259':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2266':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2265':
				return self.states['epsilon2266']
			elif self.state == 'epsilon2262':
				theglobals.audio.forward(1)
				return self.states['epsilon2265']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2260':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2261':
				if (1):
					return self.states['epsilon2262']
				else: return self.states['epsilon2263']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon2258':
			ta = 0
		elif self.state == 'epsilon2259':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2257':
			ta = 0
		elif self.state == 'epsilon2263':
			ta = 0
		elif self.state == 'epsilon2262':
			ta = 0
		elif self.state == 'epsilon2261':
			ta = 0
		elif self.state == 'epsilon2260':
			ta = 0
		elif self.state == 'epsilon2267':
			ta = 0
		elif self.state == 'epsilon2266':
			ta = 0
		elif self.state == 'epsilon2265':
			ta = 0
		elif self.state == 'epsilon2264':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		else: ta = INFINITY
		if self.inscope and not self.timeout:
			ta_after = max(0, 0.0-self.elapsed_since_inscope)
		else:
			ta_after = INFINITY
		return minEx(ta, ta_after)
	def outputFnc(self):
		if self.state == 'epsilon2260':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('history_state', 'FFWAIT')
				event.set_param('address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2258':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2259':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2266':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'FFNOW'])
				event.set_param('return_address', ['_PARENT_', 'FFWAIT'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2265':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class AUDIOFF(CoupledDEVS):
	def __init__(self):
		CoupledDEVS.__init__(self)
		self.scope = 4
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.relay=self.addSubModel(RELAY_AUDIOFF_ATOMIC_2226())
		self.FFNOW=self.addSubModel(FFNOW())
		self.FFWAIT=self.addSubModel(FFWAIT())
		self.relay.ports['FFNOW'] = self.relay.addOutPort('FFNOW')
		self.relay.ports['FFWAIT'] = self.relay.addOutPort('FFWAIT')
		self.connectPorts(self.relay.ports['FFNOW'], self.FFNOW.ports['_IN_'])
		self.connectPorts(self.FFNOW.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.FFNOW.ports['_IN_'])
		self.connectPorts(self.relay.ports['FFWAIT'], self.FFWAIT.ports['_IN_'])
		self.connectPorts(self.FFWAIT.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.FFWAIT.ports['_IN_'])
		self.connectPorts(self.ports['_IN_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_PARENT_'], self.ports['_PARENT_'])
	def select(self, imm): return choose(self, imm)
class RELAY_AUDIORW_ATOMIC_2269(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 4
		self.is_relay = 1
		self.current_child = None
		self.history = 'RWNOW'
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['__default_hook'] = DEVSstate('__default_hook')
		self.states['epsilon2269'] = DEVSstate('epsilon2269')
		self.states['__history_hook'] = DEVSstate('__history_hook')
		self.states['__history_star_hook'] = DEVSstate('__history_star_hook')
		self.states['__alpha_relay_hook'] = DEVSstate('__alpha_relay_hook')
		self.states['__relay_hook'] = DEVSstate('__relay_hook')
		self.states['__broadcast_hook'] = DEVSstate('__broadcast_hook')
		self.states['epsilon2270'] = DEVSstate('epsilon2270')
		self.states['epsilon2271'] = DEVSstate('epsilon2271')
		self.states['epsilon2272'] = DEVSstate('epsilon2272')
		self.states['epsilon2273'] = DEVSstate('epsilon2273')
		self.states['epsilon2274'] = DEVSstate('epsilon2274')
		self.states['wait2275'] = DEVSstate('wait2275')
		self.states['epsilon2276'] = DEVSstate('epsilon2276')
		self.states['epsilon2277'] = DEVSstate('epsilon2277')
		self.states['epsilon2278'] = DEVSstate('epsilon2278')
		self.states['epsilon2279'] = DEVSstate('epsilon2279')
		self.states['epsilon2280'] = DEVSstate('epsilon2280')
		self.states['epsilon2281'] = DEVSstate('epsilon2281')
		self.states['epsilon2282'] = DEVSstate('epsilon2282')
		self.states['epsilon2283'] = DEVSstate('epsilon2283')
		self.states['epsilon2284'] = DEVSstate('epsilon2284')
		self.states['epsilon2285'] = DEVSstate('epsilon2285')
		self.states['wait2286'] = DEVSstate('wait2286')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon2270'
						return self.states[temp]
					elif self.event == 'EXITALL':
						return self.states['epsilon2273']
					elif self.event == 'GUI Backward Released':
						return self.states['epsilon2279']
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: temp = 'INSCOPE'
						elif self.event.get_param('address')[0] == '_PARENT_':
							temp = 'epsilon2278'
							self.current_child = None
						else:
							temp = 'epsilon2277'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
					elif len(self.event.get_param('address')) == 0:
						if self.event.get_param('broadcast') == 'TRUE': return '__broadcast_hook'
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						if len(self.event.get_param('address')) > 0:
							temp = 'epsilon2270'
						return self.states[temp]
					elif self.event == 'ENTER':
						if len(self.event.get_param('address')) == 0: # REACHED DESTINATION
							self.return_address = self.event.get_param('return_address')
							if self.event.get_param('history') == 'TRUE':
								if self.event.get_param('broadcast') == 'TRUE': temp = '__history_star_hook'
								else: temp = '__history_hook'
							else: temp = '__default_hook'
						else:
							temp = 'epsilon2276'
							self.current_child = self.event.get_param('address')[0]
						return self.states[temp]
				return self.states['OUTSCOPE']
			elif self.state == 'wait2286':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2285'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == '__history_star_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == '__relay_hook':
				return self.states['INSCOPE']
			elif self.state == 'wait2275':
				event = get_from_Q(self.Q, 'EXITACK')
				if event != None:
					self.history = event.get_param('history_state')
					temp = 'epsilon2274'
				else: temp = self.state.name
				return self.states[temp]
			elif self.state == 'epsilon2281':
				return self.states['INSCOPE']
			elif self.state == '__default_hook':
				return self.states['epsilon2269']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == '__alpha_relay_hook':
				return self.states[self.restore]
			elif self.state == 'epsilon2283':
				return self.states['wait2286']
			elif self.state == '__history_hook':
				self.current_child = self.history
				return self.states['INSCOPE']
			elif self.state == 'epsilon2270':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2271':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2272':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2273':
				return self.states['wait2275']
			elif self.state == 'epsilon2274':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2276':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2277':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2278':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2279':
				if (1):
					return self.states['epsilon2280']
				else: return self.states['epsilon2281']
			elif self.state == 'epsilon2269':
				self.current_child = 'RWNOW'
				return self.states['INSCOPE']
			elif self.state == 'epsilon2280':
				return self.states['epsilon2283']
			elif self.state == 'epsilon2285':
				return self.states['epsilon2284']
			elif self.state == 'epsilon2284':
				return self.states['OUTSCOPE']
			elif self.state == '__broadcast_hook':
				return self.states['INSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'wait2286':
			ta = INFINITY
		elif self.state == '__history_star_hook':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == '__relay_hook':
			ta = 0
		elif self.state == 'wait2275':
			ta = INFINITY
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == '__default_hook':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2283':
			ta = 0
		elif self.state == '__alpha_relay_hook':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2281':
			ta = 0
		elif self.state == 'epsilon2282':
			ta = 0
		elif self.state == '__history_hook':
			ta = 0
		elif self.state == 'epsilon2270':
			ta = 0
		elif self.state == 'epsilon2271':
			ta = 0
		elif self.state == 'epsilon2272':
			ta = 0
		elif self.state == 'epsilon2273':
			ta = 0
		elif self.state == 'epsilon2274':
			ta = 0
		elif self.state == 'epsilon2276':
			ta = 0
		elif self.state == 'epsilon2277':
			ta = 0
		elif self.state == 'epsilon2278':
			ta = 0
		elif self.state == 'epsilon2279':
			ta = 0
		elif self.state == 'epsilon2269':
			ta = 0
		elif self.state == 'epsilon2280':
			ta = 0
		elif self.state == 'epsilon2285':
			ta = 0
		elif self.state == 'epsilon2284':
			ta = 0
		elif self.state == '__broadcast_hook':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == '__history_star_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('broadcast', 'TRUE')
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__history_hook':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', [self.history])
				event.set_param('history', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2284':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'AUDIOPLAY'])
				event.set_param('history', 'TRUE')
				event.set_param('return_address', ['_PARENT_', 'AUDIORW'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2270':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2271':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2272':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.event.get_param('from_address'))
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2273':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2274':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('address', ['_PARENT_'])
				event.set_param('history_state', 'AUDIORW')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2285':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2276':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2277':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2278':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2269':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['RWNOW'])
				event.set_param('return_address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__alpha_relay_hook':
			def __outputFnc(self):
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2283':
			def __outputFnc(self):
				return DEVSevent('EXITALL', [('address', [self.current_child]), ('broadcast', 'TRUE')])
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == '__broadcast_hook':
			def __outputFnc(self):
				self.event.set_param('address', [self.current_child])
				self.event.set_param('broadcast', 'TRUE')
				return self.event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class RWNOW(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 5.5
		self.is_relay = 0
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['epsilon2288'] = DEVSstate('epsilon2288')
		self.states['epsilon2289'] = DEVSstate('epsilon2289')
		self.states['epsilon2290'] = DEVSstate('epsilon2290')
		self.states['epsilon2291'] = DEVSstate('epsilon2291')
		self.states['epsilon2292'] = DEVSstate('epsilon2292')
		self.states['epsilon2293'] = DEVSstate('epsilon2293')
		self.states['epsilon2294'] = DEVSstate('epsilon2294')
		self.states['epsilon2295'] = DEVSstate('epsilon2295')
		self.states['epsilon2296'] = DEVSstate('epsilon2296')
		self.states['epsilon2297'] = DEVSstate('epsilon2297')
		self.states['epsilon2298'] = DEVSstate('epsilon2298')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		if not self.timeout and round(self.elapsed_since_inscope, 6) >= 0.05:
			self.Q.append(EVENT('_TIMEOUT_'))
			self.elapsed_since_inscope = 0
			self.timeout = 1
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == '_TIMEOUT_':
						return self.states['epsilon2292']
					elif self.event == 'EXITALL':
						return self.states['epsilon2291']
					elif self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2290']
					elif len(self.event.get_param('address')) == 0:
						pass
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2289']
					elif self.event == 'ENTER':
						return self.states['INSCOPE']
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2289':
				return self.states['OUTSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == 'epsilon2296':
				return self.states['epsilon2297']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2297':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2294':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2292':
				if (1):
					return self.states['epsilon2293']
				else: return self.states['epsilon2294']
			elif self.state == 'epsilon2293':
				return self.states['epsilon2296']
			elif self.state == 'epsilon2290':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2291':
				return self.states['OUTSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon2296':
			ta = 0
		elif self.state == 'epsilon2288':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2289':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2298':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2297':
			ta = 0
		elif self.state == 'epsilon2294':
			ta = 0
		elif self.state == 'epsilon2295':
			ta = 0
		elif self.state == 'epsilon2292':
			ta = 0
		elif self.state == 'epsilon2293':
			ta = 0
		elif self.state == 'epsilon2290':
			ta = 0
		elif self.state == 'epsilon2291':
			ta = 0
		else: ta = INFINITY
		if self.inscope and not self.timeout:
			ta_after = max(0, 0.05-self.elapsed_since_inscope)
		else:
			ta_after = INFINITY
		return minEx(ta, ta_after)
	def outputFnc(self):
		if self.state == 'epsilon2289':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2296':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2297':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'RWWAIT'])
				event.set_param('return_address', ['_PARENT_', 'RWNOW'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2290':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2291':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('history_state', 'RWNOW')
				event.set_param('address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class RWWAIT(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 5.5
		self.is_relay = 0
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['epsilon2300'] = DEVSstate('epsilon2300')
		self.states['epsilon2301'] = DEVSstate('epsilon2301')
		self.states['epsilon2302'] = DEVSstate('epsilon2302')
		self.states['epsilon2303'] = DEVSstate('epsilon2303')
		self.states['epsilon2304'] = DEVSstate('epsilon2304')
		self.states['epsilon2305'] = DEVSstate('epsilon2305')
		self.states['epsilon2306'] = DEVSstate('epsilon2306')
		self.states['epsilon2307'] = DEVSstate('epsilon2307')
		self.states['epsilon2308'] = DEVSstate('epsilon2308')
		self.states['epsilon2309'] = DEVSstate('epsilon2309')
		self.states['epsilon2310'] = DEVSstate('epsilon2310')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		if not self.timeout and round(self.elapsed_since_inscope, 6) >= 0.0:
			self.Q.append(EVENT('_TIMEOUT_'))
			self.elapsed_since_inscope = 0
			self.timeout = 1
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == '_TIMEOUT_':
						return self.states['epsilon2304']
					elif self.event == 'EXITALL':
						return self.states['epsilon2303']
					elif self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2302']
					elif len(self.event.get_param('address')) == 0:
						pass
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2301']
					elif self.event == 'ENTER':
						return self.states['INSCOPE']
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2308':
				return self.states['epsilon2309']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == 'epsilon2309':
				return self.states['OUTSCOPE']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2301':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2302':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2303':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2304':
				if (1):
					return self.states['epsilon2305']
				else: return self.states['epsilon2306']
			elif self.state == 'epsilon2305':
				theglobals.audio.backward(1)
				return self.states['epsilon2308']
			elif self.state == 'epsilon2306':
				return self.states['INSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon2310':
			ta = 0
		elif self.state == 'epsilon2309':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2305':
			ta = 0
		elif self.state == 'epsilon2308':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2300':
			ta = 0
		elif self.state == 'epsilon2301':
			ta = 0
		elif self.state == 'epsilon2302':
			ta = 0
		elif self.state == 'epsilon2303':
			ta = 0
		elif self.state == 'epsilon2304':
			ta = 0
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2306':
			ta = 0
		elif self.state == 'epsilon2307':
			ta = 0
		else: ta = INFINITY
		if self.inscope and not self.timeout:
			ta_after = max(0, 0.0-self.elapsed_since_inscope)
		else:
			ta_after = INFINITY
		return minEx(ta, ta_after)
	def outputFnc(self):
		if self.state == 'epsilon2308':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2301':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2302':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2303':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('history_state', 'RWWAIT')
				event.set_param('address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2309':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'RWNOW'])
				event.set_param('return_address', ['_PARENT_', 'RWWAIT'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class AUDIORW(CoupledDEVS):
	def __init__(self):
		CoupledDEVS.__init__(self)
		self.scope = 4
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.relay=self.addSubModel(RELAY_AUDIORW_ATOMIC_2269())
		self.RWNOW=self.addSubModel(RWNOW())
		self.RWWAIT=self.addSubModel(RWWAIT())
		self.relay.ports['RWNOW'] = self.relay.addOutPort('RWNOW')
		self.relay.ports['RWWAIT'] = self.relay.addOutPort('RWWAIT')
		self.connectPorts(self.relay.ports['RWNOW'], self.RWNOW.ports['_IN_'])
		self.connectPorts(self.RWNOW.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.RWNOW.ports['_IN_'])
		self.connectPorts(self.relay.ports['RWWAIT'], self.RWWAIT.ports['_IN_'])
		self.connectPorts(self.RWWAIT.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.RWWAIT.ports['_IN_'])
		self.connectPorts(self.ports['_IN_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_PARENT_'], self.ports['_PARENT_'])
	def select(self, imm): return choose(self, imm)
class AUDIOACTIVE(CoupledDEVS):
	def __init__(self):
		CoupledDEVS.__init__(self)
		self.scope = 3
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.relay=self.addSubModel(RELAY_AUDIOACTIVE_ATOMIC_2148())
		self.AUDIOPLAY=self.addSubModel(AUDIOPLAY())
		self.AUDIOFF=self.addSubModel(AUDIOFF())
		self.AUDIORW=self.addSubModel(AUDIORW())
		self.relay.ports['AUDIOPLAY'] = self.relay.addOutPort('AUDIOPLAY')
		self.relay.ports['AUDIOFF'] = self.relay.addOutPort('AUDIOFF')
		self.relay.ports['AUDIORW'] = self.relay.addOutPort('AUDIORW')
		self.connectPorts(self.relay.ports['AUDIOPLAY'], self.AUDIOPLAY.ports['_IN_'])
		self.connectPorts(self.AUDIOPLAY.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.AUDIOPLAY.ports['_IN_'])
		self.connectPorts(self.relay.ports['AUDIOFF'], self.AUDIOFF.ports['_IN_'])
		self.connectPorts(self.AUDIOFF.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.AUDIOFF.ports['_IN_'])
		self.connectPorts(self.relay.ports['AUDIORW'], self.AUDIORW.ports['_IN_'])
		self.connectPorts(self.AUDIORW.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.AUDIORW.ports['_IN_'])
		self.connectPorts(self.ports['_IN_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_PARENT_'], self.ports['_PARENT_'])
	def select(self, imm): return choose(self, imm)
class AUDIOSTOP(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 3.5
		self.is_relay = 0
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['epsilon2312'] = DEVSstate('epsilon2312')
		self.states['epsilon2313'] = DEVSstate('epsilon2313')
		self.states['epsilon2314'] = DEVSstate('epsilon2314')
		self.states['epsilon2315'] = DEVSstate('epsilon2315')
		self.states['epsilon2316'] = DEVSstate('epsilon2316')
		self.states['epsilon2317'] = DEVSstate('epsilon2317')
		self.states['epsilon2318'] = DEVSstate('epsilon2318')
		self.states['epsilon2319'] = DEVSstate('epsilon2319')
		self.states['epsilon2320'] = DEVSstate('epsilon2320')
		self.states['epsilon2321'] = DEVSstate('epsilon2321')
		self.states['epsilon2322'] = DEVSstate('epsilon2322')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'EXITALL':
						return self.states['epsilon2315']
					elif self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2314']
					elif self.event == 'GUI Play/Pause':
						return self.states['epsilon2316']
					elif len(self.event.get_param('address')) == 0:
						pass
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2313']
					elif self.event == 'ENTER':
						return self.states['INSCOPE']
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2318':
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == 'epsilon2320':
				return self.states['epsilon2321']
			elif self.state == 'epsilon2321':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2313':
				return self.states['OUTSCOPE']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'epsilon2317':
				theglobals.audio.play()
				return self.states['epsilon2320']
			elif self.state == 'epsilon2316':
				if (1):
					return self.states['epsilon2317']
				else: return self.states['epsilon2318']
			elif self.state == 'epsilon2315':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2314':
				return self.states['INSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'epsilon2321':
			ta = 0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'epsilon2320':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2322':
			ta = 0
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2319':
			ta = 0
		elif self.state == 'epsilon2318':
			ta = 0
		elif self.state == 'epsilon2313':
			ta = 0
		elif self.state == 'epsilon2312':
			ta = 0
		elif self.state == 'epsilon2317':
			ta = 0
		elif self.state == 'epsilon2316':
			ta = 0
		elif self.state == 'epsilon2315':
			ta = 0
		elif self.state == 'epsilon2314':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == 'epsilon2313':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2320':
			def __outputFnc(self):
				# return an instance of DEVSevent or None
				return None
				
				
				
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2321':
			def __outputFnc(self):
				event = DEVSevent('ENTER')
				event.set_param('address', ['_PARENT_', 'AUDIOACTIVE', 'AUDIOPLAY', 'AUDIOPLAYING'])
				event.set_param('return_address', ['_PARENT_', '_PARENT_', '_PARENT_', 'AUDIOSTOP'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2315':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('history_state', 'AUDIOSTOP')
				event.set_param('address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2314':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class AUDIO(CoupledDEVS):
	def __init__(self):
		CoupledDEVS.__init__(self)
		self.scope = 2
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.relay=self.addSubModel(RELAY_AUDIO_ATOMIC_2137())
		self.AUDIOACTIVE=self.addSubModel(AUDIOACTIVE())
		self.AUDIOSTOP=self.addSubModel(AUDIOSTOP())
		self.relay.ports['AUDIOACTIVE'] = self.relay.addOutPort('AUDIOACTIVE')
		self.relay.ports['AUDIOSTOP'] = self.relay.addOutPort('AUDIOSTOP')
		self.connectPorts(self.relay.ports['AUDIOACTIVE'], self.AUDIOACTIVE.ports['_IN_'])
		self.connectPorts(self.AUDIOACTIVE.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.AUDIOACTIVE.ports['_IN_'])
		self.connectPorts(self.relay.ports['AUDIOSTOP'], self.AUDIOSTOP.ports['_IN_'])
		self.connectPorts(self.AUDIOSTOP.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.AUDIOSTOP.ports['_IN_'])
		self.connectPorts(self.ports['_IN_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_PARENT_'], self.ports['_PARENT_'])
	def select(self, imm): return choose(self, imm)
class MP3(CoupledDEVS):
	def __init__(self):
		CoupledDEVS.__init__(self)
		self.scope = 1
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.relay=self.addSubModel(RELAY_MP3_ATOMIC_1952())
		self.GUI=self.addSubModel(GUI())
		self.AUDIO=self.addSubModel(AUDIO())
		self.relay.ports['GUI'] = self.relay.addOutPort('GUI')
		self.relay.ports['AUDIO'] = self.relay.addOutPort('AUDIO')
		self.connectPorts(self.relay.ports['GUI'], self.GUI.ports['_IN_'])
		self.connectPorts(self.GUI.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.GUI.ports['_IN_'])
		self.connectPorts(self.relay.ports['AUDIO'], self.AUDIO.ports['_IN_'])
		self.connectPorts(self.AUDIO.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.AUDIO.ports['_IN_'])
		self.connectPorts(self.ports['_IN_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_PARENT_'], self.ports['_PARENT_'])
	def select(self, imm): return choose(self, imm)
class DEAD(AtomicDEVS):
	def __init__(self):
		AtomicDEVS.__init__(self)
		self.scope = 1.5
		self.is_relay = 0
		self.Q = []
		self.delta_ext = 0
		self.inscope = 0
		self.timeout = 0
		self.elapsed_since_inscope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.states = {}
		self.states['INSCOPE'] = DEVSstate('INSCOPE')
		self.states['OUTSCOPE'] = DEVSstate('OUTSCOPE')
		self.states['INSCOPE_DQ'] = DEVSstate('INSCOPE_DQ')
		self.states['OUTSCOPE_DQ'] = DEVSstate('OUTSCOPE_DQ')
		self.states['epsilon2324'] = DEVSstate('epsilon2324')
		self.states['epsilon2325'] = DEVSstate('epsilon2325')
		self.states['epsilon2326'] = DEVSstate('epsilon2326')
		self.states['epsilon2327'] = DEVSstate('epsilon2327')
		self.state = self.states['OUTSCOPE']
	def extTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		event = self.peek(self.ports['_IN_'])
		if event == 'ENTER' or event == 'EXITALL' or event == 'EXITACK':
			if len(event.get_param('address')) > 0:
				if event.get_param('address')[0] != '_PARENT_':
					if self.state.name == 'OUTSCOPE': self.restore = 'INSCOPE'
					else: self.restore = self.state.name
					self.event = event; self.current_child = event.get_param('address')[0]; return '__alpha_relay_hook'
		self.Q.append(event)
		self.delta_ext = 1
		return self.state
	def intTransition(self):
		if self.inscope: self.elapsed_since_inscope += self.elapsed
		else: self.elapsed_since_inscope = 0
		def get_new_state():
			if self.state == 'INSCOPE_DQ':
				while len(self.Q) > 0:
					self.event=self.Q[0];del self.Q[0]
					if self.event == 'EXITALL':
						return self.states['epsilon2327']
					elif self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2326']
					elif len(self.event.get_param('address')) == 0:
						pass
					else: return '__relay_hook'
				return self.states['INSCOPE']
			elif self.state == 'OUTSCOPE_DQ':
				while len(self.Q) > 0:

					self.event=self.Q[0];del self.Q[0]
					if self.event == 'CSQ':
						self.from_address = self.event.get_param('from_address')
						return self.states['epsilon2325']
					elif self.event == 'ENTER':
						return self.states['INSCOPE']
				return self.states['OUTSCOPE']
			elif self.state == 'INSCOPE':
				return self.states['INSCOPE_DQ']
			elif self.state == 'OUTSCOPE':
				return self.states['OUTSCOPE_DQ']
			elif self.state == 'epsilon2326':
				return self.states['INSCOPE']
			elif self.state == 'epsilon2327':
				return self.states['OUTSCOPE']
			elif self.state == 'epsilon2325':
				return self.states['OUTSCOPE']
			else: return self.state
		new_state = get_new_state()
		if new_state == 'INSCOPE':
			self.inscope = 1
			if len(self.Q) == 0: self.timeout = 0
		elif new_state == 'OUTSCOPE':
			self.inscope = 0
			if len(self.Q) == 0: self.timeout = 0
		return new_state
	def timeAdvance(self):
		if self.state == 'INSCOPE' and len(self.Q) > 0: ta = 0
		elif self.state == 'OUTSCOPE' and len(self.Q) > 0: ta = 0
		elif self.delta_ext: ta = 0;self.delta_ext=0
		elif self.state == 'OUTSCOPE':
			ta = INFINITY
		elif self.state == 'OUTSCOPE_DQ':
			ta = 0
		elif self.state == 'epsilon2326':
			ta = 0
		elif self.state == 'epsilon2327':
			ta = 0
		elif self.state == 'epsilon2324':
			ta = 0
		elif self.state == 'epsilon2325':
			ta = 0
		elif self.state == 'INSCOPE':
			ta = INFINITY
		elif self.state == 'INSCOPE_DQ':
			ta = 0
		else: ta = INFINITY
		return ta
	def outputFnc(self):
		if self.state == 'epsilon2326':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'TRUE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2327':
			def __outputFnc(self):
				event = DEVSevent('EXITACK')
				event.set_param('history_state', 'DEAD')
				event.set_param('address', ['_PARENT_'])
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
		elif self.state == 'epsilon2325':
			def __outputFnc(self):
				event = DEVSevent('CSR')
				event.set_param('address', self.from_address)
				event.set_param('value', 'FALSE')
				return event
			event = __outputFnc(self)
			if event != None:
				port_name = event.get_param('address')[0]
				del event.get_param('address')[0]
				self.poke(self.ports[port_name], event)
class ROOT(CoupledDEVS):
	def __init__(self):
		CoupledDEVS.__init__(self)
		self.scope = 0
		self.ports = {}
		self.ports['_IN_'] = self.addInPort('_IN_')
		self.ports['_PARENT_'] = self.addOutPort('_PARENT_')
		self.ports['_ALL_'] = self.addOutPort('_ALL_')
		self.relay=self.addSubModel(RELAY_ROOT_ATOMIC_1941())
		self.MP3=self.addSubModel(MP3())
		self.DEAD=self.addSubModel(DEAD())
		self.relay.ports['MP3'] = self.relay.addOutPort('MP3')
		self.relay.ports['DEAD'] = self.relay.addOutPort('DEAD')
		self.connectPorts(self.relay.ports['MP3'], self.MP3.ports['_IN_'])
		self.connectPorts(self.MP3.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.MP3.ports['_IN_'])
		self.connectPorts(self.relay.ports['DEAD'], self.DEAD.ports['_IN_'])
		self.connectPorts(self.DEAD.ports['_PARENT_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_ALL_'], self.DEAD.ports['_IN_'])
		self.connectPorts(self.ports['_IN_'], self.relay.ports['_IN_'])
		self.connectPorts(self.relay.ports['_PARENT_'], self.ports['_PARENT_'])
	def select(self, imm): return choose(self, imm)
