"""
__ballCSULFP_MDL.py_____________________________________________________

Automatically generated AToM3 Model File (Do not modify directly)
Author: kyle
Modified: Wed Apr 30 00:09:48 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 ballCSULFP_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.obj2315=Composite(self)
    self.obj2315.isGraphObjectVisual = True

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

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

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

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

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

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

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

    self.obj2315.graphClass_= graph_Composite
    if self.genGraphics:
       new_obj = graph_Composite(280.0,160.0,self.obj2315)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Composite", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf2.handler,344.0,239.0,572.0,370.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,344.0,232.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.obj2315.graphObject_ = new_obj

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

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

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

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

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

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

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

    self.obj2316.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(440.0,140.0,self.obj2316)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,452.0,143.0,470.0,161.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,463.125,170.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.obj2316.graphObject_ = new_obj

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

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

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

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

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

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

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

    self.obj2317.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(420.0,320.0,self.obj2317)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,432.0,323.0,450.0,341.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='DARKBLUE')
       self.UMLmodel.itemconfig(new_obj.gf3.handler, fill='lightgray')
       self.UMLmodel.coords(new_obj.gf1.handler,443.125,350.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.obj2317.graphObject_ = new_obj

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

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

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

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

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

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

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

    self.obj2464.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(740.0,280.0,self.obj2464)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,752.0,283.0,770.0,301.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,763.125,310.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='font40359496')
       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.obj2464.graphObject_ = new_obj

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

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

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

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

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

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

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

    self.obj2469.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(200.0,320.0,self.obj2469)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,212.0,323.0,230.0,341.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,350.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='font96967736')
       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.obj2469.graphObject_ = new_obj

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

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

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

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

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

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

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

    self.obj2490.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(400.0,440.0,self.obj2490)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,412.0,443.0,430.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,423.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='blowUp')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font64954496')
       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.obj2490.graphObject_ = new_obj

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

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

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

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

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

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

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

    self.obj2516.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(720.0,120.0,self.obj2516)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,732.0,123.0,750.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,743.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='blowRight')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font98052496')
       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['Text Scale'] = 1.11
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj2516.graphObject_ = new_obj

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

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

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

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

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

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

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

    self.obj2545.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(160.0,200.0,self.obj2545)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,172.0,203.0,190.0,221.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,183.125,230.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='blowLeft')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, width='0')
       self.UMLmodel.itemconfig(new_obj.gf1.handler, font='font98711872')
       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.obj2545.graphObject_ = new_obj

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

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

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

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

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

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

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

    self.obj2579.graphClass_= graph_Basic
    if self.genGraphics:
       new_obj = graph_Basic(780.0,460.0,self.obj2579)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Basic", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf3.handler,792.0,463.0,810.0,481.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,803.125,490.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='font98757528')
       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.obj2579.graphObject_ = new_obj

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

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

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

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

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

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

    self.obj2318.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(340.0,220.0,self.obj2318)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,384.0,258.0,565.0,363.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,384.0,251.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.obj2318.graphObject_ = new_obj

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

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

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

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

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

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

    self.obj2461.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(620.0,260.0,self.obj2461)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,625.0,276.0,682.0,332.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,643.0,267.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.obj2461.graphObject_ = new_obj

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

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

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

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

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

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

    self.obj2466.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(260.0,280.0,self.obj2466)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,265.0,296.0,322.0,352.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,283.0,287.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.obj2466.graphObject_ = new_obj

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

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

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

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

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

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

    self.obj2487.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(480.0,400.0,self.obj2487)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,485.0,416.0,542.0,472.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,503.0,407.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.obj2487.graphObject_ = new_obj

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

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

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

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

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

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

    self.obj2513.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(580.0,140.0,self.obj2513)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,585.0,156.0,642.0,212.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,603.0,147.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.obj2513.graphObject_ = new_obj

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

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

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

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

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

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

    self.obj2542.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(260.0,190.0,self.obj2542)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,265.0,206.0,322.0,262.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,283.0,197.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.obj2542.graphObject_ = new_obj

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

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

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

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

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

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

    self.obj2576.graphClass_= graph_Orthogonal
    if self.genGraphics:
       new_obj = graph_Orthogonal(660.0,400.0,self.obj2576)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Orthogonal", new_obj.tag)
       self.UMLmodel.coords(new_obj.gf5.handler,665.0,416.0,722.0,472.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,683.0,407.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.obj2576.graphObject_ = new_obj

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

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

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

    self.obj2319.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(404.931194496,310.723429936,self.obj2319)
       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.obj2319.graphObject_ = new_obj

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

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

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

    self.obj2462.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(718.594879287,310.084383505,self.obj2462)
       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.obj2462.graphObject_ = new_obj

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

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

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

    self.obj2467.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(248.182972314,335.100671194,self.obj2467)
       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.obj2467.graphObject_ = new_obj

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

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

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

    self.obj2488.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(457.758818692,455.142676605,self.obj2488)
       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.obj2488.graphObject_ = new_obj

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

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

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

    self.obj2514.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(692.036566907,166.621496023,self.obj2514)
       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.obj2514.graphObject_ = new_obj

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

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

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

    self.obj2543.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(224.784591885,234.410284528,self.obj2543)
       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.obj2543.graphObject_ = new_obj

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

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

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

    self.obj2577.graphClass_= graph_contains
    if self.genGraphics:
       new_obj = graph_contains(754.574110952,465.234952932,self.obj2577)
       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.obj2577.graphObject_ = new_obj

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

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

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

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

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

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

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

    # action
    self.obj2320.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.obj2320.action.setHeight(15)

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

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

    self.obj2320.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(449.424551194,199.617869818,self.obj2320)
       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.obj2320.graphObject_ = new_obj

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

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

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

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

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

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

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

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

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

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

    self.obj2321.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(495.8,316.0,self.obj2321)
       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.obj2321.graphObject_ = new_obj

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

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

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

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

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

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

    # trigger
    self.obj2460.trigger.setValue('AFTER(0.03)')

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

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

    # display
    self.obj2460.display.setValue('AFTER(0.03)')

    self.obj2460.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(810.2,324.0,self.obj2460)
       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.obj2460.graphObject_ = new_obj

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

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

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

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

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

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

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

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

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

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

    self.obj2465.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(160.0,340.0,self.obj2465)
       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.obj2465.graphObject_ = new_obj

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

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

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

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

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

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

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

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

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

    # display
    self.obj2486.display.setValue('AFTER(5)')

    self.obj2486.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(375.8,484.0,self.obj2486)
       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.obj2486.graphObject_ = new_obj

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

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

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

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

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

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

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

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

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

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

    self.obj2512.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(686.2,165.8,self.obj2512)
       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.obj2512.graphObject_ = new_obj

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

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

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

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

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

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

    # trigger
    self.obj2541.trigger.setValue('AFTER(23)')

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

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

    # display
    self.obj2541.display.setValue('')
    self.obj2541.display.setNone()

    self.obj2541.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(183.0,190.0,self.obj2541)
       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.obj2541.graphObject_ = new_obj

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

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

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

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

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

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

    # trigger
    self.obj2575.trigger.setValue('AFTER(1)')

    # action
    self.obj2575.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.obj2575.action.setHeight(15)

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

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

    self.obj2575.graphClass_= graph_Hyperedge
    if self.genGraphics:
       new_obj = graph_Hyperedge(862.2,456.0,self.obj2575)
       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.obj2575.graphObject_ = new_obj

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

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

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

    self.obj2322.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(364.0,248.5,self.obj2322)
       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.obj2322.graphObject_ = new_obj

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

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

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

    self.obj2463.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(598.688645669,313.498220482,self.obj2463)
       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.obj2463.graphObject_ = new_obj

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

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

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

    self.obj2468.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(339.72672794,321.399400734,self.obj2468)
       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.obj2468.graphObject_ = new_obj

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

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

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

    self.obj2489.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(491.484664556,385.387567695,self.obj2489)
       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.obj2489.graphObject_ = new_obj

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

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

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

    self.obj2515.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(583.903119961,253.847076504,self.obj2515)
       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.obj2515.graphObject_ = new_obj

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

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

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

    self.obj2544.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(325.431920864,275.342951352,self.obj2544)
       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.obj2544.graphObject_ = new_obj

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

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

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

    self.obj2578.graphClass_= graph_orthogonality
    if self.genGraphics:
       new_obj = graph_orthogonality(638.823182504,352.689447318,self.obj2578)
       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.obj2578.graphObject_ = new_obj

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

    # Connections for obj2315 (graphObject_: Obj900) named compo_0
    self.drawConnections(
(self.obj2315,self.obj2322,[345.0, 201.00000000000003, 363.99999999999875, 248.49999999955631],"bezier", 2),
(self.obj2315,self.obj2463,[344.0, 304.0, 598.68864566947616, 313.49822048223524],"bezier", 2),
(self.obj2315,self.obj2468,[344.0, 304.0, 339.7267279399631, 321.39940073395934],"bezier", 2),
(self.obj2315,self.obj2489,[344.0, 304.0, 491.48466455599782, 385.38756769513287],"bezier", 2),
(self.obj2315,self.obj2515,[344.0, 304.0, 583.90311996136961, 253.84707650410354],"bezier", 2),
(self.obj2315,self.obj2544,[344.0, 304.0, 325.43192086423272, 275.34295135210391],"bezier", 2),
(self.obj2315,self.obj2578,[457.99999999999994, 239.0, 638.82318250360015, 352.68944731757131],"bezier", 2) )
    # Connections for obj2316 (graphObject_: Obj901) named init
    self.drawConnections(
(self.obj2316,self.obj2320,[470.00191094743786, 151.96502037329131, 449.42455119424102, 199.61786981801143],"bezier", 2) )
    # Connections for obj2317 (graphObject_: Obj902) named moving
    self.drawConnections(
(self.obj2317,self.obj2321,[436.74796458621154, 324.16809608307045, 392.30000000000007, 265.5, 495.80000000000001, 316.0],"bezier", 3) )
    # Connections for obj2464 (graphObject_: Obj1051) named color
    self.drawConnections(
(self.obj2464,self.obj2460,[765.32758298793908, 299.73738170347002, 810.20000000000005, 324.0],"bezier", 2) )
    # Connections for obj2469 (graphObject_: Obj1057) named shape
    self.drawConnections(
(self.obj2469,self.obj2465,[212.0625, 331.92862776025225, 159.99999999999994, 340.0],"bezier", 2) )
    # Connections for obj2490 (graphObject_: Obj1063) named blowUp
    self.drawConnections(
(self.obj2490,self.obj2486,[413.03033867293959, 456.28568611987379, 375.79999999999995, 483.99999999999989],"bezier", 2) )
    # Connections for obj2516 (graphObject_: Obj1069) named blowRight
    self.drawConnections(
(self.obj2516,self.obj2512,[748.9712109331241, 127.34522870662454, 686.20000000000005, 165.80000000000001],"bezier", 2) )
    # Connections for obj2545 (graphObject_: Obj1075) named blowLeft
    self.drawConnections(
(self.obj2545,self.obj2541,[185.38451467458265, 203.89353312302836, 182.99999999999997, 190.0],"bezier", 2) )
    # Connections for obj2579 (graphObject_: Obj1081) named produceBall
    self.drawConnections(
(self.obj2579,self.obj2575,[801.22850154960611, 462.87499999999994, 862.20000000000005, 456.0],"bezier", 2) )
    # Connections for obj2318 (graphObject_: Obj903) named move_comp
    self.drawConnections(
(self.obj2318,self.obj2319,[384.0, 310.00000000000006, 404.93119449599999, 310.723429936],"bezier", 2) )
    # Connections for obj2461 (graphObject_: Obj1048) named color_comp
    self.drawConnections(
(self.obj2461,self.obj2462,[625.0, 303.0, 718.59487928687781, 310.08438350510892],"bezier", 2) )
    # Connections for obj2466 (graphObject_: Obj1054) named shape_comp
    self.drawConnections(
(self.obj2466,self.obj2467,[265.0, 323.0, 248.18297231409045, 335.10067119402595],"bezier", 2) )
    # Connections for obj2487 (graphObject_: Obj1060) named up_comp
    self.drawConnections(
(self.obj2487,self.obj2488,[484.99999999999994, 442.99999999999994, 457.7588186918631, 455.14267660528543],"bezier", 2) )
    # Connections for obj2513 (graphObject_: Obj1066) named right_comp
    self.drawConnections(
(self.obj2513,self.obj2514,[585.0, 183.0, 692.03656690690877, 166.62149602337649],"bezier", 2) )
    # Connections for obj2542 (graphObject_: Obj1072) named left_comp
    self.drawConnections(
(self.obj2542,self.obj2543,[265.0, 233.0, 224.78459188535865, 234.41028452786594],"bezier", 2) )
    # Connections for obj2576 (graphObject_: Obj1078) named produceBall_comp
    self.drawConnections(
(self.obj2576,self.obj2577,[665.0, 443.0, 754.57411095218049, 465.2349529317753],"bezier", 2) )
    # Connections for obj2319 (graphObject_: Obj904) of type contains
    self.drawConnections(
(self.obj2319,self.obj2317,[404.93119449599999, 310.723429936, 416.72556937513104, 323.47957067605591, 433.34320001431377, 327.61979166666663],"bezier", 3) )
    # Connections for obj2462 (graphObject_: Obj1049) of type contains
    self.drawConnections(
(self.obj2462,self.obj2464,[718.59487928687793, 310.08438350510886, 736.35246395511285, 308.15580503507732, 753.03033867293959, 296.28568611987379],"bezier", 3) )
    # Connections for obj2467 (graphObject_: Obj1055) of type contains
    self.drawConnections(
(self.obj2467,self.obj2469,[248.18297231409042, 335.10067119402589, 239.17577504737147, 336.18697837068203, 230.05291297935108, 331.81545741324925],"bezier", 3) )
    # Connections for obj2488 (graphObject_: Obj1061) of type contains
    self.drawConnections(
(self.obj2488,self.obj2490,[457.7588186918631, 455.14267660528543, 443.75162142514415, 456.22898378194162, 430.05291297935111, 451.81545741324925],"bezier", 3) )
    # Connections for obj2514 (graphObject_: Obj1067) of type contains
    self.drawConnections(
(self.obj2514,self.obj2516,[692.03656690690889, 166.62149602337649, 714.55219190690877, 153.6036529634396, 733.03033867293959, 136.28568611987379],"bezier", 3) )
    # Connections for obj2543 (graphObject_: Obj1073) of type contains
    self.drawConnections(
(self.obj2543,self.obj2545,[224.78459188535862, 234.41028452786594, 205.74892877531795, 230.23170605783434, 188.85734755983731, 216.28568611987379],"bezier", 3) )
    # Connections for obj2577 (graphObject_: Obj1079) of type contains
    self.drawConnections(
(self.obj2577,self.obj2579,[754.57411095218049, 465.23495293177524, 772.4226614637372, 471.10251010843149, 792.0625, 471.92862776025237],"bezier", 3) )
    # Connections for obj2320 (graphObject_: Obj905) named 
    self.drawConnections(
(self.obj2320,self.obj2315,[449.42455119424102, 199.61786981801143, 448.71557384478308, 219.12735407800091, 457.99999999999994, 239.0],"bezier", 3) )
    # Connections for obj2321 (graphObject_: Obj907) named 
    self.drawConnections(
(self.obj2321,self.obj2317,[495.80000000000001, 316.0, 507.80000000000007, 342.39999999999998, 450.00191094743781, 331.96502037329128],"bezier", 3) )
    # Connections for obj2460 (graphObject_: Obj1046) named 
    self.drawConnections(
(self.obj2460,self.obj2464,[810.20000000000005, 324.0, 798.20000000000005, 347.60000000000002, 765.32758298793931, 299.73738170347008],"bezier", 3) )
    # Connections for obj2465 (graphObject_: Obj1052) named 
    self.drawConnections(
(self.obj2465,self.obj2469,[159.99999999999997, 340.0, 159.99999999999994, 372.0, 213.03033867293962, 336.28568611987373],"bezier", 3) )
    # Connections for obj2486 (graphObject_: Obj1058) named 
    self.drawConnections(
(self.obj2486,self.obj2490,[375.80000000000001, 483.99999999999989, 363.79999999999995, 460.39999999999998, 412.0625, 451.92862776025237],"bezier", 3) )
    # Connections for obj2512 (graphObject_: Obj1064) named 
    self.drawConnections(
(self.obj2512,self.obj2516,[686.20000000000005, 165.80000000000001, 673.80000000000007, 137.40000000000001, 732.0625, 131.92862776025237],"bezier", 3) )
    # Connections for obj2541 (graphObject_: Obj1070) named 
    self.drawConnections(
(self.obj2541,self.obj2545,[183.0, 190.0, 197.99999999999997, 190.0, 185.38451467458265, 203.89353312302836],"bezier", 3) )
    # Connections for obj2575 (graphObject_: Obj1076) named 
    self.drawConnections(
(self.obj2575,self.obj2579,[862.20000000000005, 455.99999999999994, 874.19999999999993, 485.60000000000008, 810.05291297935094, 471.81545741324925],"bezier", 3) )
    # Connections for obj2322 (graphObject_: Obj909) of type orthogonality
    self.drawConnections(
(self.obj2322,self.obj2318,[363.99999999999875, 248.49999999955631, 370.49999999999881, 257.49999999955639, 345.0, 262.99999999999994],"bezier", 3) )
    # Connections for obj2463 (graphObject_: Obj1050) of type orthogonality
    self.drawConnections(
(self.obj2463,self.obj2461,[598.68864566947616, 313.49822048223524, 611.93864566947616, 313.24822048223524, 625.0, 303.0],"bezier", 3) )
    # Connections for obj2468 (graphObject_: Obj1056) of type orthogonality
    self.drawConnections(
(self.obj2468,self.obj2466,[339.7267279399631, 321.3994007339594, 334.2267279399631, 326.39940073395945, 321.99999999999989, 324.0],"bezier", 3) )
    # Connections for obj2489 (graphObject_: Obj1062) of type orthogonality
    self.drawConnections(
(self.obj2489,self.obj2487,[491.48466455599794, 385.38756769513287, 504.98466455599788, 396.88756769513287, 512.0, 416.00000000000006],"bezier", 3) )
    # Connections for obj2515 (graphObject_: Obj1068) of type orthogonality
    self.drawConnections(
(self.obj2515,self.obj2513,[583.9031199613695, 253.84707650410354, 594.40311996136961, 230.84707650410354, 613.99999999999989, 211.99999999999997],"bezier", 3) )
    # Connections for obj2544 (graphObject_: Obj1074) of type orthogonality
    self.drawConnections(
(self.obj2544,self.obj2542,[325.43192086423272, 275.34295135210391, 312.93192086423272, 264.84295135210391, 294.0, 262.0],"bezier", 3) )
    # Connections for obj2578 (graphObject_: Obj1080) of type orthogonality
    self.drawConnections(
(self.obj2578,self.obj2576,[638.82318250360015, 352.68944731757131, 668.82318250360004, 380.68944731757131, 692.0, 416.00000000000006],"bezier", 3) )

newfunction = ballCSULFP_MDL

loadedMMName = 'DCharts'

atom3version = '0.3'