"""
__ballAll_MDL.py_____________________________________________________

Automatically generated AToM3 Model File (Do not modify directly)
Author: kyle
Modified: Wed Apr 30 02:41:52 2008
_____________________________________________________________________
"""
from stickylink import *
from widthXfillXdecoration import *
from Composite import *
from Basic import *
from Orthogonal import *
from contains import *
from Hyperedge import *
from orthogonality import *
from graph_Basic import *
from graph_Orthogonal import *
from graph_Hyperedge import *
from graph_orthogonality import *
from graph_contains import *
from graph_Composite import *
from ATOM3Enum import *
from ATOM3String import *
from ATOM3BottomType import *
from ATOM3Constraint import *
from ATOM3Attribute import *
from ATOM3Float import *
from ATOM3List import *
from ATOM3Link import *
from ATOM3Connection import *
from ATOM3Boolean import *
from ATOM3Appearance import *
from ATOM3Text import *
from ATOM3Action import *
from ATOM3Integer import *
from ATOM3Port import *
from ATOM3MSEnum import *

def ballAll_MDL(self, rootNode, DChartsRootNode=None):

    # --- Generating attributes code for ASG DCharts ---
    if( DChartsRootNode ): 
        # variables
        DChartsRootNode.variables.setValue('\n')
        DChartsRootNode.variables.setHeight(15)

        # misc
        DChartsRootNode.misc.setValue('\n')
        DChartsRootNode.misc.setHeight(15)

        # event_clauses
        DChartsRootNode.event_clauses.setValue('\n')
        DChartsRootNode.event_clauses.setHeight(15)
    # --- ASG attributes over ---


    self.obj3233=Composite(self)
    self.obj3233.isGraphObjectVisual = True

    if(hasattr(self.obj3233, '_setHierarchicalLink')):
      self.obj3233._setHierarchicalLink(False)

    # auto_adjust
    self.obj3233.auto_adjust.setValue((None, 1))
    self.obj3233.auto_adjust.config = 0

    # name
    self.obj3233.name.setValue('compo_0')

    # is_default
    self.obj3233.is_default.setValue((None, 0))
    self.obj3233.is_default.config = 0

    # visible
    self.obj3233.visible.setValue((None, 1))
    self.obj3233.visible.config = 0

    # exit_action
    self.obj3233.exit_action.setValue('\n')
    self.obj3233.exit_action.setHeight(15)

    # enter_action
    self.obj3233.enter_action.setValue('\n')
    self.obj3233.enter_action.setHeight(15)

    self.obj3233.graphClass_= graph_Composite
    if self.genGraphics:
       new_obj = graph_Composite(280.0,160.0,self.obj3233)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Composite", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf2.handler,101.0,278.0,900.0,530.0)
       self.UMLmodel.itemconfig(new_obj.gf2.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf2.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf2.handler, outline='DARKBLUE')
       self.UMLmodel.itemconfig(new_obj.gf2.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,101.0,271.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='compo_0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3233.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3233)
    self.globalAndLocalPostcondition(self.obj3233, rootNode)
    self.obj3233.postAction( rootNode.CREATE )

    self.obj3234=Basic(self)
    self.obj3234.isGraphObjectVisual = True

    if(hasattr(self.obj3234, '_setHierarchicalLink')):
      self.obj3234._setHierarchicalLink(False)

    # is_default
    self.obj3234.is_default.setValue((None, 1))
    self.obj3234.is_default.config = 0

    # name
    self.obj3234.name.setValue('init')

    # exit_action
    self.obj3234.exit_action.setValue('\n')
    self.obj3234.exit_action.setHeight(15)

    # enter_action
    self.obj3234.enter_action.setValue('counter = 0\nmax = 160\nballs = {}\n')
    self.obj3234.enter_action.setHeight(15)

    self.obj3234.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(460.0,120.0,self.obj3234)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,472.0,123.0,490.0,141.0)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,483.125,150.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='init')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font87440840')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3234.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3234)
    self.globalAndLocalPostcondition(self.obj3234, rootNode)
    self.obj3234.postAction( rootNode.CREATE )

    self.obj3235=Basic(self)
    self.obj3235.isGraphObjectVisual = True

    if(hasattr(self.obj3235, '_setHierarchicalLink')):
      self.obj3235._setHierarchicalLink(False)

    # is_default
    self.obj3235.is_default.setValue((None, 1))
    self.obj3235.is_default.config = 0

    # name
    self.obj3235.name.setValue('moving')

    # exit_action
    self.obj3235.exit_action.setValue('\n')
    self.obj3235.exit_action.setHeight(15)

    # enter_action
    self.obj3235.enter_action.setValue('\n')
    self.obj3235.enter_action.setHeight(15)

    self.obj3235.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(380.0,480.0,self.obj3235)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,392.0,483.0,410.0,501.0)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,403.125,510.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='moving')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font90189656')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3235.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3235)
    self.globalAndLocalPostcondition(self.obj3235, rootNode)
    self.obj3235.postAction( rootNode.CREATE )

    self.obj3236=Basic(self)
    self.obj3236.isGraphObjectVisual = True

    if(hasattr(self.obj3236, '_setHierarchicalLink')):
      self.obj3236._setHierarchicalLink(False)

    # is_default
    self.obj3236.is_default.setValue((None, 1))
    self.obj3236.is_default.config = 0

    # name
    self.obj3236.name.setValue('blowUp')

    # exit_action
    self.obj3236.exit_action.setValue('\n')
    self.obj3236.exit_action.setHeight(15)

    # enter_action
    self.obj3236.enter_action.setValue('\n')
    self.obj3236.enter_action.setHeight(15)

    self.obj3236.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(840.0,300.0,self.obj3236)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,852.0,303.0,870.0,321.0)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,863.125,330.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='blowUp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font104356400')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3236.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3236)
    self.globalAndLocalPostcondition(self.obj3236, rootNode)
    self.obj3236.postAction( rootNode.CREATE )

    self.obj3237=Basic(self)
    self.obj3237.isGraphObjectVisual = True

    if(hasattr(self.obj3237, '_setHierarchicalLink')):
      self.obj3237._setHierarchicalLink(False)

    # is_default
    self.obj3237.is_default.setValue((None, 1))
    self.obj3237.is_default.config = 0

    # name
    self.obj3237.name.setValue('blowLeft')

    # exit_action
    self.obj3237.exit_action.setValue('\n')
    self.obj3237.exit_action.setHeight(15)

    # enter_action
    self.obj3237.enter_action.setValue('\n')
    self.obj3237.enter_action.setHeight(15)

    self.obj3237.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(180.0,440.0,self.obj3237)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,199.06575098,441.2,216.16575098,462.8)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,209.63450098,473.6)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='blowLeft')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font102340648')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [0.94999999999999996, 1.2000000000000002]
    else: new_obj = None
    self.obj3237.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3237)
    self.globalAndLocalPostcondition(self.obj3237, rootNode)
    self.obj3237.postAction( rootNode.CREATE )

    self.obj3238=Basic(self)
    self.obj3238.isGraphObjectVisual = True

    if(hasattr(self.obj3238, '_setHierarchicalLink')):
      self.obj3238._setHierarchicalLink(False)

    # is_default
    self.obj3238.is_default.setValue((None, 1))
    self.obj3238.is_default.config = 0

    # name
    self.obj3238.name.setValue('blowRight')

    # exit_action
    self.obj3238.exit_action.setValue('\n')
    self.obj3238.exit_action.setHeight(15)

    # enter_action
    self.obj3238.enter_action.setValue('\n')
    self.obj3238.enter_action.setHeight(15)

    self.obj3238.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(800.0,440.0,self.obj3238)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,812.0,443.0,830.0,461.0)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,823.125,470.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='blowRight')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font102376432')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3238.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3238)
    self.globalAndLocalPostcondition(self.obj3238, rootNode)
    self.obj3238.postAction( rootNode.CREATE )

    self.obj3239=Basic(self)
    self.obj3239.isGraphObjectVisual = True

    if(hasattr(self.obj3239, '_setHierarchicalLink')):
      self.obj3239._setHierarchicalLink(False)

    # is_default
    self.obj3239.is_default.setValue((None, 1))
    self.obj3239.is_default.config = 0

    # name
    self.obj3239.name.setValue('color')

    # exit_action
    self.obj3239.exit_action.setValue('\n')
    self.obj3239.exit_action.setHeight(15)

    # enter_action
    self.obj3239.enter_action.setValue('\n')
    self.obj3239.enter_action.setHeight(15)

    self.obj3239.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(200.0,300.0,self.obj3239)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,212.0,303.0,230.0,321.0)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,223.125,330.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='color')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font105249488')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3239.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3239)
    self.globalAndLocalPostcondition(self.obj3239, rootNode)
    self.obj3239.postAction( rootNode.CREATE )

    self.obj3240=Basic(self)
    self.obj3240.isGraphObjectVisual = True

    if(hasattr(self.obj3240, '_setHierarchicalLink')):
      self.obj3240._setHierarchicalLink(False)

    # is_default
    self.obj3240.is_default.setValue((None, 1))
    self.obj3240.is_default.config = 0

    # name
    self.obj3240.name.setValue('shape')

    # exit_action
    self.obj3240.exit_action.setValue('\n')
    self.obj3240.exit_action.setHeight(15)

    # enter_action
    self.obj3240.enter_action.setValue('\n')
    self.obj3240.enter_action.setHeight(15)

    self.obj3240.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(640.0,340.0,self.obj3240)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,652.0,343.0,670.0,361.0)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,663.125,370.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='shape')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font105247808')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3240.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3240)
    self.globalAndLocalPostcondition(self.obj3240, rootNode)
    self.obj3240.postAction( rootNode.CREATE )

    self.obj3241=Basic(self)
    self.obj3241.isGraphObjectVisual = True

    if(hasattr(self.obj3241, '_setHierarchicalLink')):
      self.obj3241._setHierarchicalLink(False)

    # is_default
    self.obj3241.is_default.setValue((None, 1))
    self.obj3241.is_default.config = 0

    # name
    self.obj3241.name.setValue('produceBall')

    # exit_action
    self.obj3241.exit_action.setValue('\n')
    self.obj3241.exit_action.setHeight(15)

    # enter_action
    self.obj3241.enter_action.setValue('\n')
    self.obj3241.enter_action.setHeight(15)

    self.obj3241.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(460.0,340.0,self.obj3241)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,472.0,343.0,490.0,361.0)
       self.UMLmodel.itemconfig(new_obj.gf3.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, outline='DARKGREEN')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,483.125,370.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='produceBall')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font105202712')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3241.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3241)
    self.globalAndLocalPostcondition(self.obj3241, rootNode)
    self.obj3241.postAction( rootNode.CREATE )

    self.obj3242=Orthogonal(self)
    self.obj3242.isGraphObjectVisual = True

    if(hasattr(self.obj3242, '_setHierarchicalLink')):
      self.obj3242._setHierarchicalLink(False)

    # visible
    self.obj3242.visible.setValue((None, 1))
    self.obj3242.visible.config = 0

    # name
    self.obj3242.name.setValue('move_comp')

    # auto_adjust
    self.obj3242.auto_adjust.setValue((None, 1))
    self.obj3242.auto_adjust.config = 0

    self.obj3242.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(300.0,380.0,self.obj3242)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,373.0,442.0,525.0,523.0)
       self.UMLmodel.itemconfig(new_obj.gf5.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, outline='darkgray')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,373.0,435.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='move_comp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3242.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3242)
    self.globalAndLocalPostcondition(self.obj3242, rootNode)
    self.obj3242.postAction( rootNode.CREATE )

    self.obj3243=Orthogonal(self)
    self.obj3243.isGraphObjectVisual = True

    if(hasattr(self.obj3243, '_setHierarchicalLink')):
      self.obj3243._setHierarchicalLink(False)

    # visible
    self.obj3243.visible.setValue((None, 1))
    self.obj3243.visible.config = 0

    # name
    self.obj3243.name.setValue('up_comp')

    # auto_adjust
    self.obj3243.auto_adjust.setValue((None, 1))
    self.obj3243.auto_adjust.config = 0

    self.obj3243.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(720.0,320.0,self.obj3243)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,794.0,297.0,893.0,376.0)
       self.UMLmodel.itemconfig(new_obj.gf5.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, outline='DARKGRAY')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,794.0,290.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='up_comp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3243.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3243)
    self.globalAndLocalPostcondition(self.obj3243, rootNode)
    self.obj3243.postAction( rootNode.CREATE )

    self.obj3244=Orthogonal(self)
    self.obj3244.isGraphObjectVisual = True

    if(hasattr(self.obj3244, '_setHierarchicalLink')):
      self.obj3244._setHierarchicalLink(False)

    # visible
    self.obj3244.visible.setValue((None, 1))
    self.obj3244.visible.config = 0

    # name
    self.obj3244.name.setValue('left_comp')

    # auto_adjust
    self.obj3244.auto_adjust.setValue((None, 1))
    self.obj3244.auto_adjust.config = 0

    self.obj3244.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(220.0,360.0,self.obj3244)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,134.0,435.0,248.0,523.0)
       self.UMLmodel.itemconfig(new_obj.gf5.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, outline='DARKGRAY')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,134.0,428.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='left_comp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3244.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3244)
    self.globalAndLocalPostcondition(self.obj3244, rootNode)
    self.obj3244.postAction( rootNode.CREATE )

    self.obj3245=Orthogonal(self)
    self.obj3245.isGraphObjectVisual = True

    if(hasattr(self.obj3245, '_setHierarchicalLink')):
      self.obj3245._setHierarchicalLink(False)

    # visible
    self.obj3245.visible.setValue((None, 1))
    self.obj3245.visible.config = 0

    # name
    self.obj3245.name.setValue('right_comp')

    # auto_adjust
    self.obj3245.auto_adjust.setValue((None, 1))
    self.obj3245.auto_adjust.config = 0

    self.obj3245.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(700.0,380.0,self.obj3245)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,745.0,437.0,865.0,521.0)
       self.UMLmodel.itemconfig(new_obj.gf5.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, outline='DARKGRAY')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,745.0,430.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='right_comp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3245.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3245)
    self.globalAndLocalPostcondition(self.obj3245, rootNode)
    self.obj3245.postAction( rootNode.CREATE )

    self.obj3246=Orthogonal(self)
    self.obj3246.isGraphObjectVisual = True

    if(hasattr(self.obj3246, '_setHierarchicalLink')):
      self.obj3246._setHierarchicalLink(False)

    # visible
    self.obj3246.visible.setValue((None, 1))
    self.obj3246.visible.config = 0

    # name
    self.obj3246.name.setValue('color_comp')

    # auto_adjust
    self.obj3246.auto_adjust.setValue((None, 1))
    self.obj3246.auto_adjust.config = 0

    self.obj3246.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(280.0,320.0,self.obj3246)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,197.0,297.0,326.0,372.0)
       self.UMLmodel.itemconfig(new_obj.gf5.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, outline='DARKGRAY')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,197.0,290.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='color_comp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3246.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3246)
    self.globalAndLocalPostcondition(self.obj3246, rootNode)
    self.obj3246.postAction( rootNode.CREATE )

    self.obj3247=Orthogonal(self)
    self.obj3247.isGraphObjectVisual = True

    if(hasattr(self.obj3247, '_setHierarchicalLink')):
      self.obj3247._setHierarchicalLink(False)

    # visible
    self.obj3247.visible.setValue((None, 1))
    self.obj3247.visible.config = 0

    # name
    self.obj3247.name.setValue('shape_comp')

    # auto_adjust
    self.obj3247.auto_adjust.setValue((None, 1))
    self.obj3247.auto_adjust.config = 0

    self.obj3247.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(580.0,380.0,self.obj3247)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,593.0,337.0,689.0,417.0)
       self.UMLmodel.itemconfig(new_obj.gf5.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, outline='DARKGRAY')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,593.0,330.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='shape_comp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3247.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3247)
    self.globalAndLocalPostcondition(self.obj3247, rootNode)
    self.obj3247.postAction( rootNode.CREATE )

    self.obj3248=Orthogonal(self)
    self.obj3248.isGraphObjectVisual = True

    if(hasattr(self.obj3248, '_setHierarchicalLink')):
      self.obj3248._setHierarchicalLink(False)

    # visible
    self.obj3248.visible.setValue((None, 1))
    self.obj3248.visible.config = 0

    # name
    self.obj3248.name.setValue('produceBall_comp')

    # auto_adjust
    self.obj3248.auto_adjust.setValue((None, 1))
    self.obj3248.auto_adjust.config = 0

    self.obj3248.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(340.0,320.0,self.obj3248)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,401.0,297.0,533.0,383.0)
       self.UMLmodel.itemconfig(new_obj.gf5.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, width='2.0')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, outline='DARKGRAY')
       self.UMLmodel.itemconfig(new_obj.gf5.handler, fill='')
       self.UMLmodel.coords(new_obj.gf1.handler,401.0,290.0)
       self.UMLmodel.itemconfig(new_obj.gf1.handler, stipple='')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, fill='black')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, text='produceBall_comp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='Helvetica -12')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, anchor='center')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, justify='left')
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3248.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3248)
    self.globalAndLocalPostcondition(self.obj3248, rootNode)
    self.obj3248.postAction( rootNode.CREATE )

    self.obj3249=contains(self)
    self.obj3249.isGraphObjectVisual = True

    if(hasattr(self.obj3249, '_setHierarchicalLink')):
      self.obj3249._setHierarchicalLink(False)

    self.obj3249.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(324.931194496,630.723429936,self.obj3249)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3249.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3249)
    self.globalAndLocalPostcondition(self.obj3249, rootNode)
    self.obj3249.postAction( rootNode.CREATE )

    self.obj3250=contains(self)
    self.obj3250.isGraphObjectVisual = True

    if(hasattr(self.obj3250, '_setHierarchicalLink')):
      self.obj3250._setHierarchicalLink(False)

    self.obj3250.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(822.996331187,345.990384303,self.obj3250)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3250.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3250)
    self.globalAndLocalPostcondition(self.obj3250, rootNode)
    self.obj3250.postAction( rootNode.CREATE )

    self.obj3251=contains(self)
    self.obj3251.isGraphObjectVisual = True

    if(hasattr(self.obj3251, '_setHierarchicalLink')):
      self.obj3251._setHierarchicalLink(False)

    self.obj3251.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(224.208641098,427.771673945,self.obj3251)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3251.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3251)
    self.globalAndLocalPostcondition(self.obj3251, rootNode)
    self.obj3251.postAction( rootNode.CREATE )

    self.obj3252=contains(self)
    self.obj3252.isGraphObjectVisual = True

    if(hasattr(self.obj3252, '_setHierarchicalLink')):
      self.obj3252._setHierarchicalLink(False)

    self.obj3252.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(1031.85114616,406.638746452,self.obj3252)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3252.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3252)
    self.globalAndLocalPostcondition(self.obj3252, rootNode)
    self.obj3252.postAction( rootNode.CREATE )

    self.obj3253=contains(self)
    self.obj3253.isGraphObjectVisual = True

    if(hasattr(self.obj3253, '_setHierarchicalLink')):
      self.obj3253._setHierarchicalLink(False)

    self.obj3253.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(163.32476027,551.955835996,self.obj3253)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3253.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3253)
    self.globalAndLocalPostcondition(self.obj3253, rootNode)
    self.obj3253.postAction( rootNode.CREATE )

    self.obj3254=contains(self)
    self.obj3254.isGraphObjectVisual = True

    if(hasattr(self.obj3254, '_setHierarchicalLink')):
      self.obj3254._setHierarchicalLink(False)

    self.obj3254.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(659.47006494,623.328205065,self.obj3254)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3254.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3254)
    self.globalAndLocalPostcondition(self.obj3254, rootNode)
    self.obj3254.postAction( rootNode.CREATE )

    self.obj3255=contains(self)
    self.obj3255.isGraphObjectVisual = True

    if(hasattr(self.obj3255, '_setHierarchicalLink')):
      self.obj3255._setHierarchicalLink(False)

    self.obj3255.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(36.435459386,530.201302615,self.obj3255)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3255.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3255)
    self.globalAndLocalPostcondition(self.obj3255, rootNode)
    self.obj3255.postAction( rootNode.CREATE )

    self.obj3256=Hyperedge(self)
    self.obj3256.isGraphObjectVisual = True

    if(hasattr(self.obj3256, '_setHierarchicalLink')):
      self.obj3256._setHierarchicalLink(False)

    # name
    self.obj3256.name.setValue('')
    self.obj3256.name.setNone()

    # broadcast
    self.obj3256.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3256.broadcast.setHeight(15)

    # guard
    self.obj3256.guard.setValue('1')

    # trigger
    self.obj3256.trigger.setValue('start')

    # action
    self.obj3256.action.setValue('ctl = [PARAMS]\nbid = counter\ncounter += 1\ngid, pos, speed = ctl.init(bid)\nballs[bid] = {\'pos\': pos, \'speed\': speed, \'gid\':gid}\nwidth = ctl.getWidth()\nheight = ctl.getHeight()\n')
    self.obj3256.action.setHeight(15)

    # broadcast_to
    self.obj3256.broadcast_to.setValue('')
    self.obj3256.broadcast_to.setNone()

    # display
    self.obj3256.display.setValue('start')

    self.obj3256.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(502.089287355,207.954704835,self.obj3256)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [0.93999999999999961, 1.0399999999999998]
    else: new_obj = None
    self.obj3256.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3256)
    self.globalAndLocalPostcondition(self.obj3256, rootNode)
    self.obj3256.postAction( rootNode.CREATE )

    self.obj3257=Hyperedge(self)
    self.obj3257.isGraphObjectVisual = True

    if(hasattr(self.obj3257, '_setHierarchicalLink')):
      self.obj3257._setHierarchicalLink(False)

    # name
    self.obj3257.name.setValue('')
    self.obj3257.name.setNone()

    # broadcast
    self.obj3257.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3257.broadcast.setHeight(15)

    # guard
    self.obj3257.guard.setValue('1')

    # trigger
    self.obj3257.trigger.setValue('AFTER(0.01)')

    # action
    self.obj3257.action.setValue('for b in balls: ctl.bounce(b, 0.01)\n')
    self.obj3257.action.setHeight(15)

    # broadcast_to
    self.obj3257.broadcast_to.setValue('')
    self.obj3257.broadcast_to.setNone()

    # display
    self.obj3257.display.setValue('AFTER(0.01)')

    self.obj3257.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(455.8,476.0,self.obj3257)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3257.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3257)
    self.globalAndLocalPostcondition(self.obj3257, rootNode)
    self.obj3257.postAction( rootNode.CREATE )

    self.obj3258=Hyperedge(self)
    self.obj3258.isGraphObjectVisual = True

    if(hasattr(self.obj3258, '_setHierarchicalLink')):
      self.obj3258._setHierarchicalLink(False)

    # name
    self.obj3258.name.setValue('')
    self.obj3258.name.setNone()

    # broadcast
    self.obj3258.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3258.broadcast.setHeight(15)

    # guard
    self.obj3258.guard.setValue('1')

    # trigger
    self.obj3258.trigger.setValue('AFTER(10)')

    # action
    self.obj3258.action.setValue('for b in balls: ctl.blowUp(b)\n')
    self.obj3258.action.setHeight(15)

    # broadcast_to
    self.obj3258.broadcast_to.setValue('')
    self.obj3258.broadcast_to.setNone()

    # display
    self.obj3258.display.setValue('AFTER(10)')

    self.obj3258.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(814.2,344.0,self.obj3258)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3258.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3258)
    self.globalAndLocalPostcondition(self.obj3258, rootNode)
    self.obj3258.postAction( rootNode.CREATE )

    self.obj3259=Hyperedge(self)
    self.obj3259.isGraphObjectVisual = True

    if(hasattr(self.obj3259, '_setHierarchicalLink')):
      self.obj3259._setHierarchicalLink(False)

    # name
    self.obj3259.name.setValue('')
    self.obj3259.name.setNone()

    # broadcast
    self.obj3259.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3259.broadcast.setHeight(15)

    # guard
    self.obj3259.guard.setValue('1')

    # trigger
    self.obj3259.trigger.setValue('AFTER(13)')

    # action
    self.obj3259.action.setValue('for b in balls: ctl.blowLeft(b)\n')
    self.obj3259.action.setHeight(15)

    # broadcast_to
    self.obj3259.broadcast_to.setValue('')
    self.obj3259.broadcast_to.setNone()

    # display
    self.obj3259.display.setValue('AFTER(23)')

    self.obj3259.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(154.8,487.4,self.obj3259)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3259.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3259)
    self.globalAndLocalPostcondition(self.obj3259, rootNode)
    self.obj3259.postAction( rootNode.CREATE )

    self.obj3260=Hyperedge(self)
    self.obj3260.isGraphObjectVisual = True

    if(hasattr(self.obj3260, '_setHierarchicalLink')):
      self.obj3260._setHierarchicalLink(False)

    # name
    self.obj3260.name.setValue('')
    self.obj3260.name.setNone()

    # broadcast
    self.obj3260.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3260.broadcast.setHeight(15)

    # guard
    self.obj3260.guard.setValue('1')

    # trigger
    self.obj3260.trigger.setValue('AFTER(15)')

    # action
    self.obj3260.action.setValue('for b in balls: ctl.blowRight(b)\n')
    self.obj3260.action.setHeight(15)

    # broadcast_to
    self.obj3260.broadcast_to.setValue('')
    self.obj3260.broadcast_to.setNone()

    # display
    self.obj3260.display.setValue('AFTER(15)')

    self.obj3260.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(764.6,484.0,self.obj3260)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3260.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3260)
    self.globalAndLocalPostcondition(self.obj3260, rootNode)
    self.obj3260.postAction( rootNode.CREATE )

    self.obj3261=Hyperedge(self)
    self.obj3261.isGraphObjectVisual = True

    if(hasattr(self.obj3261, '_setHierarchicalLink')):
      self.obj3261._setHierarchicalLink(False)

    # name
    self.obj3261.name.setValue('')
    self.obj3261.name.setNone()

    # broadcast
    self.obj3261.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3261.broadcast.setHeight(15)

    # guard
    self.obj3261.guard.setValue('1')

    # trigger
    self.obj3261.trigger.setValue('AFTER(0.3)')

    # action
    self.obj3261.action.setValue('for b in balls: ctl.changeColor(b)\n')
    self.obj3261.action.setHeight(15)

    # broadcast_to
    self.obj3261.broadcast_to.setValue('')
    self.obj3261.broadcast_to.setNone()

    # display
    self.obj3261.display.setValue('AFTER(1)')

    self.obj3261.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(265.4,343.0,self.obj3261)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3261.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3261)
    self.globalAndLocalPostcondition(self.obj3261, rootNode)
    self.obj3261.postAction( rootNode.CREATE )

    self.obj3262=Hyperedge(self)
    self.obj3262.isGraphObjectVisual = True

    if(hasattr(self.obj3262, '_setHierarchicalLink')):
      self.obj3262._setHierarchicalLink(False)

    # name
    self.obj3262.name.setValue('')
    self.obj3262.name.setNone()

    # broadcast
    self.obj3262.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3262.broadcast.setHeight(15)

    # guard
    self.obj3262.guard.setValue('1')

    # trigger
    self.obj3262.trigger.setValue('AFTER(0.01)')

    # action
    self.obj3262.action.setValue('for b in balls: ctl.changeShape(b)\n')
    self.obj3262.action.setHeight(15)

    # broadcast_to
    self.obj3262.broadcast_to.setValue('')
    self.obj3262.broadcast_to.setNone()

    # display
    self.obj3262.display.setValue('AFTER(0.01)')

    self.obj3262.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(613.4,384.0,self.obj3262)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3262.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3262)
    self.globalAndLocalPostcondition(self.obj3262, rootNode)
    self.obj3262.postAction( rootNode.CREATE )

    self.obj3263=Hyperedge(self)
    self.obj3263.isGraphObjectVisual = True

    if(hasattr(self.obj3263, '_setHierarchicalLink')):
      self.obj3263._setHierarchicalLink(False)

    # name
    self.obj3263.name.setValue('')
    self.obj3263.name.setNone()

    # broadcast
    self.obj3263.broadcast.setValue('# return an instance of DEVSevent or None\nreturn None\n')
    self.obj3263.broadcast.setHeight(15)

    # guard
    self.obj3263.guard.setValue('1')

    # trigger
    self.obj3263.trigger.setValue('AFTER(0.1)')

    # action
    self.obj3263.action.setValue('bid = counter\ncounter += 1\nif counter <= max: gid, pos, speed = ctl.init(bid)\nif counter <= max: balls[bid] = {\'pos\': pos, \'speed\': speed, \'gid\':gid}\n')
    self.obj3263.action.setHeight(15)

    # broadcast_to
    self.obj3263.broadcast_to.setValue('')
    self.obj3263.broadcast_to.setNone()

    # display
    self.obj3263.display.setValue('AFTER(1)')

    self.obj3263.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(421.4,336.0,self.obj3263)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Hyperedge", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj3263.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3263)
    self.globalAndLocalPostcondition(self.obj3263, rootNode)
    self.obj3263.postAction( rootNode.CREATE )

    self.obj3264=orthogonality(self)
    self.obj3264.isGraphObjectVisual = True

    if(hasattr(self.obj3264, '_setHierarchicalLink')):
      self.obj3264._setHierarchicalLink(False)

    self.obj3264.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(353.0,432.5,self.obj3264)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("orthogonality", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3264.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3264)
    self.globalAndLocalPostcondition(self.obj3264, rootNode)
    self.obj3264.postAction( rootNode.CREATE )

    self.obj3265=orthogonality(self)
    self.obj3265.isGraphObjectVisual = True

    if(hasattr(self.obj3265, '_setHierarchicalLink')):
      self.obj3265._setHierarchicalLink(False)

    self.obj3265.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(563.5,287.5,self.obj3265)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("orthogonality", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3265.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3265)
    self.globalAndLocalPostcondition(self.obj3265, rootNode)
    self.obj3265.postAction( rootNode.CREATE )

    self.obj3266=orthogonality(self)
    self.obj3266.isGraphObjectVisual = True

    if(hasattr(self.obj3266, '_setHierarchicalLink')):
      self.obj3266._setHierarchicalLink(False)

    self.obj3266.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(117.5,356.5,self.obj3266)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("orthogonality", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3266.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3266)
    self.globalAndLocalPostcondition(self.obj3266, rootNode)
    self.obj3266.postAction( rootNode.CREATE )

    self.obj3267=orthogonality(self)
    self.obj3267.isGraphObjectVisual = True

    if(hasattr(self.obj3267, '_setHierarchicalLink')):
      self.obj3267._setHierarchicalLink(False)

    self.obj3267.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(423.0,357.5,self.obj3267)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("orthogonality", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3267.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3267)
    self.globalAndLocalPostcondition(self.obj3267, rootNode)
    self.obj3267.postAction( rootNode.CREATE )

    self.obj3268=orthogonality(self)
    self.obj3268.isGraphObjectVisual = True

    if(hasattr(self.obj3268, '_setHierarchicalLink')):
      self.obj3268._setHierarchicalLink(False)

    self.obj3268.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(149.0,287.5,self.obj3268)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("orthogonality", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3268.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3268)
    self.globalAndLocalPostcondition(self.obj3268, rootNode)
    self.obj3268.postAction( rootNode.CREATE )

    self.obj3269=orthogonality(self)
    self.obj3269.isGraphObjectVisual = True

    if(hasattr(self.obj3269, '_setHierarchicalLink')):
      self.obj3269._setHierarchicalLink(False)

    self.obj3269.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(347.0,307.5,self.obj3269)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("orthogonality", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3269.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3269)
    self.globalAndLocalPostcondition(self.obj3269, rootNode)
    self.obj3269.postAction( rootNode.CREATE )

    self.obj3270=orthogonality(self)
    self.obj3270.isGraphObjectVisual = True

    if(hasattr(self.obj3270, '_setHierarchicalLink')):
      self.obj3270._setHierarchicalLink(False)

    self.obj3270.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(251.0,287.5,self.obj3270)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("orthogonality", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj3270.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj3270)
    self.globalAndLocalPostcondition(self.obj3270, rootNode)
    self.obj3270.postAction( rootNode.CREATE )

    # Connections for obj3233 (graphObject_: Obj1416) named compo_0
    self.drawConnections(
(self.obj3233,self.obj3264,[499.0, 277.99999999999994, 353.0, 432.49999999999994],"bezier", 2),
(self.obj3233,self.obj3265,[98.999999999999986, 404.0, 563.49999999959221, 287.50000000039631],"bezier", 2),
(self.obj3233,self.obj3266,[98.999999999999986, 404.0, 117.50000000041885, 356.49999999992394],"bezier", 2),
(self.obj3233,self.obj3267,[98.999999999999986, 404.0, 422.99999999966303, 357.50000000016195],"bezier", 2),
(self.obj3233,self.obj3268,[98.999999999999986, 404.0, 149.00000000020577, 287.49999999965593],"bezier", 2),
(self.obj3233,self.obj3269,[499.0, 277.99999999999994, 346.99999999999994, 307.5],"bezier", 2),
(self.obj3233,self.obj3270,[499.0, 277.99999999999994, 250.99999999999997, 287.5],"bezier", 2) )
    # Connections for obj3234 (graphObject_: Obj1417) named init
    self.drawConnections(
(self.obj3234,self.obj3256,[485.27658095602618, 139.88694466351214, 498.65843259354796, 173.4264410005342, 502.08928735454163, 207.95470483465616],"bezier", 3) )
    # Connections for obj3235 (graphObject_: Obj1418) named moving
    self.drawConnections(
(self.obj3235,self.obj3257,[408.92020890121108, 487.49479166666657, 443.80000000000001, 449.60000000000002, 455.80000000000001, 476.0],"bezier", 3) )
    # Connections for obj3236 (graphObject_: Obj1419) named blowUp
    self.drawConnections(
(self.obj3236,self.obj3258,[856.56603289956797, 319.88694466351205, 826.20000000000005, 368.39999999999998, 814.20000000000005, 344.0],"bezier", 3) )
    # Connections for obj3237 (graphObject_: Obj1420) named blowLeft
    self.drawConnections(
(self.obj3237,self.obj3259,[203.4034822345896, 461.46433359621454, 168.0, 515.00000000000023, 154.80000000000001, 487.40000000000003],"bezier", 3) )
    # Connections for obj3238 (graphObject_: Obj1421) named blowRight
    self.drawConnections(
(self.obj3238,self.obj3260,[816.56603289956809, 459.88694466351205, 776.60000000000002, 513.20000000000005, 764.60000000000002, 483.99999999999989],"bezier", 3) )
    # Connections for obj3239 (graphObject_: Obj1422) named color
    self.drawConnections(
(self.obj3239,self.obj3261,[230.00191094743792, 311.9650203732914, 277.39999999999998, 321.80000000000001, 265.39999999999998, 343.0],"bezier", 3) )
    # Connections for obj3240 (graphObject_: Obj1423) named shape
    self.drawConnections(
(self.obj3240,self.obj3262,[656.56603289956809, 359.88694466351205, 625.39999999999998, 408.80000000000001, 613.39999999999998, 384.0],"bezier", 3) )
    # Connections for obj3241 (graphObject_: Obj1424) named produceBall
    self.drawConnections(
(self.obj3241,self.obj3263,[472.01149796808693, 352.07819072029434, 409.39999999999998, 366.80000000000007, 421.39999999999998, 336.0],"bezier", 3) )
    # Connections for obj3242 (graphObject_: Obj1425) named move_comp
    self.drawConnections(
(self.obj3242,self.obj3249,[434.00000000000006, 523.0, 324.93119449599988, 630.723429936],"bezier", 2) )
    # Connections for obj3243 (graphObject_: Obj1426) named up_comp
    self.drawConnections(
(self.obj3243,self.obj3250,[725.00000000000011, 362.99999999999983, 822.99633118650627, 345.99038430334002],"bezier", 2) )
    # Connections for obj3244 (graphObject_: Obj1427) named left_comp
    self.drawConnections(
(self.obj3244,self.obj3251,[188.0, 435.00000000000006, 224.20864109799999, 427.77167394500003],"bezier", 2) )
    # Connections for obj3245 (graphObject_: Obj1428) named right_comp
    self.drawConnections(
(self.obj3245,self.obj3252,[864.99999999999989, 470.00000000000011, 1031.8511461600001, 406.63874645200008],"bezier", 2) )
    # Connections for obj3246 (graphObject_: Obj1429) named color_comp
    self.drawConnections(
(self.obj3246,self.obj3253,[264.0, 376.0, 163.32476027000001, 551.95583599600025],"bezier", 2) )
    # Connections for obj3247 (graphObject_: Obj1430) named shape_comp
    self.drawConnections(
(self.obj3247,self.obj3254,[641.0, 404.0, 659.47006494000004, 623.32820506499979],"bezier", 2) )
    # Connections for obj3248 (graphObject_: Obj1431) named produceBall_comp
    self.drawConnections(
(self.obj3248,self.obj3255,[416.00000000000006, 340.0, 36.435459386000041, 530.20130261500015],"bezier", 2) )
    # Connections for obj3249 (graphObject_: Obj1432) of type contains
    self.drawConnections(
(self.obj3249,self.obj3235,[324.93119449599988, 630.723429936, 336.72556937513076, 643.47957067605569, 396.56603289956797, 499.886944663512],"bezier", 3) )
    # Connections for obj3250 (graphObject_: Obj1433) of type contains
    self.drawConnections(
(self.obj3250,self.obj3236,[822.99633118650627, 345.99038430334002, 840.51195618650627, 332.9725412434031, 856.61703493148116, 319.73738170346996],"bezier", 3) )
    # Connections for obj3251 (graphObject_: Obj1434) of type contains
    self.drawConnections(
(self.obj3251,self.obj3237,[224.20864109799999, 427.77167394500003, 219.30476976676508, 437.9950572259587, 211.73258799044726, 442.45171529968462],"bezier", 3) )
    # Connections for obj3252 (graphObject_: Obj1435) of type contains
    self.drawConnections(
(self.obj3252,self.obj3238,[1031.8511461600001, 406.63874645200008, 1044.6996966711561, 412.5063036282159, 830.00191094743798, 451.96502037329134],"bezier", 3) )
    # Connections for obj3253 (graphObject_: Obj1436) of type contains
    self.drawConnections(
(self.obj3253,self.obj3239,[163.32476027000001, 551.95583599600025, 149.28909716022446, 540.27725752551373, 216.56603289956797, 319.88694466351205],"bezier", 3) )
    # Connections for obj3254 (graphObject_: Obj1437) of type contains
    self.drawConnections(
(self.obj3254,self.obj3240,[659.47006494000004, 623.32820506500002, 669.72764960778386, 613.39962659541823, 660.83590939783187, 360.96206296004192],"bezier", 3) )
    # Connections for obj3255 (graphObject_: Obj1438) of type contains
    self.drawConnections(
(self.obj3255,self.obj3241,[36.435459386000041, 530.20130261500015, 54.193044054296202, 528.27272414473316, 472.97933664102663, 356.43524907991582],"bezier", 3) )
    # Connections for obj3256 (graphObject_: Obj1439) named 
    self.drawConnections(
(self.obj3256,self.obj3233,[502.08928735454163, 207.95470483465616, 505.52014211553507, 242.48296866877811, 499.0, 277.99999999999994],"bezier", 3) )
    # Connections for obj3257 (graphObject_: Obj1441) named 
    self.drawConnections(
(self.obj3257,self.obj3235,[455.80000000000001, 476.0, 467.79999999999995, 502.39999999999992, 410.00191094743786, 491.96502037329134],"bezier", 3) )
    # Connections for obj3258 (graphObject_: Obj1443) named 
    self.drawConnections(
(self.obj3258,self.obj3236,[814.20000000000005, 344.0, 802.20000000000005, 319.60000000000008, 852.01149796808693, 312.07819072029434],"bezier", 3) )
    # Connections for obj3259 (graphObject_: Obj1445) named 
    self.drawConnections(
(self.obj3259,self.obj3237,[154.80000000000001, 487.40000000000003, 141.60000000000002, 459.79999999999995, 199.07667404968251, 452.09382886435327],"bezier", 3) )
    # Connections for obj3260 (graphObject_: Obj1447) named 
    self.drawConnections(
(self.obj3260,self.obj3238,[764.60000000000002, 483.99999999999989, 752.60000000000002, 454.80000000000001, 812.01149796808693, 452.07819072029434],"bezier", 3) )
    # Connections for obj3261 (graphObject_: Obj1449) named 
    self.drawConnections(
(self.obj3261,self.obj3239,[265.39999999999998, 343.0, 253.39999999999995, 364.19999999999999, 225.27658095602618, 319.88694466351205],"bezier", 3) )
    # Connections for obj3262 (graphObject_: Obj1451) named 
    self.drawConnections(
(self.obj3262,self.obj3240,[613.39999999999998, 384.0, 601.39999999999986, 359.19999999999999, 652.01149796808693, 352.07819072029434],"bezier", 3) )
    # Connections for obj3263 (graphObject_: Obj1453) named 
    self.drawConnections(
(self.obj3263,self.obj3241,[421.39999999999998, 336.0, 433.39999999999998, 305.19999999999999, 473.34320001431377, 347.61979166666663],"bezier", 3) )
    # Connections for obj3264 (graphObject_: Obj1455) of type orthogonality
    self.drawConnections(
(self.obj3264,self.obj3242,[353.0, 432.49999999999994, 359.49999999999881, 441.49999999955639, 434.00000000000006, 418.0],"bezier", 3) )
    # Connections for obj3265 (graphObject_: Obj1456) of type orthogonality
    self.drawConnections(
(self.obj3265,self.obj3243,[563.49999999959221, 287.50000000039631, 601.74999999959221, 302.25000000039637, 725.00000000000011, 362.99999999999983],"bezier", 3) )
    # Connections for obj3266 (graphObject_: Obj1457) of type orthogonality
    self.drawConnections(
(self.obj3266,self.obj3244,[117.50000000041885, 356.49999999992394, 94.50000000041868, 374.49999999992411, 251.99999999999994, 375.99999999999994],"bezier", 3) )
    # Connections for obj3267 (graphObject_: Obj1458) of type orthogonality
    self.drawConnections(
(self.obj3267,self.obj3245,[423.0, 357.49999999999994, 431.49999999966309, 369.00000000016183, 746.0, 470.00000000000011],"bezier", 3) )
    # Connections for obj3268 (graphObject_: Obj1459) of type orthogonality
    self.drawConnections(
(self.obj3268,self.obj3246,[148.99999999999997, 287.5, 138.00000000020574, 270.74999999965587, 264.0, 296.99999999999994],"bezier", 3) )
    # Connections for obj3269 (graphObject_: Obj1460) of type orthogonality
    self.drawConnections(
(self.obj3269,self.obj3247,[346.99999999999994, 307.5, 352.49999999954412, 284.50000000021714, 593.0, 370.0],"bezier", 3) )
    # Connections for obj3270 (graphObject_: Obj1461) of type orthogonality
    self.drawConnections(
(self.obj3270,self.obj3248,[250.99999999999997, 287.5, 294.2499999999402, 257.2499999999477, 474.0, 298.0],"bezier", 3) )

newfunction = ballAll_MDL

loadedMMName = 'DCharts'

atom3version = '0.3'