                                     extern
                                     const
                                     char
                                     VersionAndBuildTime
                                     [
                                     ]
                                     ;
                                     typedef
                                     int
                                     BOOL
                                     ;
                                     typedef
                                     struct
                                     {
                                     int
                                     VersionAndSize
                                     ;
                                     int
                                     ADC
                                     [
                                     8
                                     +
                                     2
                                     *
                                     8
                                     ]
                                     ;
                                     int
                                     DAC
                                     [
                                     8
                                     ]
                                     ;
                                     int
                                     PWM
                                     [
                                     8
                                     +
                                     2
                                     *
                                     4
                                     ]
                                     ;
                                     double
                                     Position
                                     [
                                     8
                                     ]
                                     ;
                                     double
                                     Dest
                                     [
                                     8
                                     ]
                                     ;
                                     unsigned
                                     char
                                     OutputChan0
                                     [
                                     8
                                     ]
                                     ;
                                     int
                                     InputModes
                                     ;
                                     int
                                     InputModes2
                                     ;
                                     int
                                     OutputModes
                                     ;
                                     int
                                     OutputModes2
                                     ;
                                     int
                                     Enables
                                     ;
                                     int
                                     AxisDone
                                     ;
                                     int
                                     BitsDirection
                                     [
                                     2
                                     ]
                                     ;
                                     int
                                     BitsState
                                     [
                                     2
                                     ]
                                     ;
                                     int
                                     SnapBitsDirection0
                                     ;
                                     int
                                     SnapBitsDirection1
                                     ;
                                     int
                                     SnapBitsState0
                                     ;
                                     int
                                     SnapBitsState1
                                     ;
                                     int
                                     KanalogBitsStateInputs
                                     ;
                                     int
                                     KanalogBitsStateOutputs
                                     ;
                                     int
                                     RunOnStartUp
                                     ;
                                     int
                                     ThreadActive
                                     ;
                                     int
                                     StopImmediateState
                                     ;
                                     }
                                     MAIN_STATUS
                                     ;
                                     extern
                                     float
                                     sqrtf
                                     (
                                     float
                                     x
                                     )
                                     ;
                                     extern
                                     float
                                     expf
                                     (
                                     float
                                     x
                                     )
                                     ;
                                     extern
                                     float
                                     logf
                                     (
                                     float
                                     x
                                     )
                                     ;
                                     extern
                                     float
                                     log10f
                                     (
                                     float
                                     x
                                     )
                                     ;
                                     extern
                                     float
                                     powf
                                     (
                                     float
                                     x
                                     ,
                                     float
                                     y
                                     )
                                     ;
                                     extern
                                     float
                                     sinf
                                     (
                                     float
                                     x
                                     )
                                     ;
                                     extern
                                     float
                                     cosf
                                     (
                                     float
                                     x
                                     )
                                     ;
                                     extern
                                     float
                                     tanf
                                     (
                                     float
                                     x
                                     )
                                     ;
                                     extern
                                     float
                                     asinf
                                     (
                                     float
                                     x
                                     )
                                     ;
                                     extern
                                     float
                                     acosf
                                     (
                                     float
                                     x
                                     )
                                     ;
                                     extern
                                     float
                                     atanf
                                     (
                                     float
                                     x
                                     )
                                     ;
                                     extern
                                     float
                                     atan2f
                                     (
                                     float
                                     y
                                     ,
                                     float
                                     x
                                     )
                                     ;
                                     extern
                                     float
                                     fast_fabsf
                                     (
                                     float
                                     y
                                     )
                                     ;
                                     extern
                                     double
                                     sqrt
                                     (
                                     double
                                     x
                                     )
                                     ;
                                     extern
                                     double
                                     exp
                                     (
                                     double
                                     x
                                     )
                                     ;
                                     extern
                                     double
                                     log
                                     (
                                     double
                                     x
                                     )
                                     ;
                                     extern
                                     double
                                     log10
                                     (
                                     double
                                     x
                                     )
                                     ;
                                     extern
                                     double
                                     pow
                                     (
                                     double
                                     x
                                     ,
                                     double
                                     y
                                     )
                                     ;
                                     extern
                                     double
                                     sin
                                     (
                                     double
                                     x
                                     )
                                     ;
                                     extern
                                     double
                                     cos
                                     (
                                     double
                                     x
                                     )
                                     ;
                                     extern
                                     double
                                     tan
                                     (
                                     double
                                     x
                                     )
                                     ;
                                     extern
                                     double
                                     asin
                                     (
                                     double
                                     x
                                     )
                                     ;
                                     extern
                                     double
                                     acos
                                     (
                                     double
                                     x
                                     )
                                     ;
                                     extern
                                     double
                                     atan
                                     (
                                     double
                                     x
                                     )
                                     ;
                                     extern
                                     double
                                     atan2
                                     (
                                     double
                                     y
                                     ,
                                     double
                                     x
                                     )
                                     ;
                                     extern
                                     double
                                     fast_fabs
                                     (
                                     double
                                     y
                                     )
                                     ;
                                     typedef
                                     struct
                                     {
                                     int
                                     RunOnStartUp
                                     ;
                                     unsigned
                                     int
                                     EntryPoints
                                     [
                                     7
                                     ]
                                     ;
                                     int
                                     UserData
                                     [
                                     100
                                     ]
                                     ;
                                     }
                                     PERSIST
                                     ;
                                     extern
                                     PERSIST
                                     persist
                                     ;
                                     extern
                                     int
                                     StatusRequestCounter
                                     ;
                                     typedef
                                     struct
                                     {
                                     int
                                     type
                                     ;
                                     void
                                     *
                                     addr
                                     ;
                                     }
                                     GATHER_VALUE_DEF
                                     ;
                                     typedef
                                     struct
                                     {
                                     double
                                     *
                                     bufptr
                                     ;
                                     double
                                     *
                                     endptr
                                     ;
                                     double
                                     Dest
                                     ;
                                     int
                                     Inject
                                     ;
                                     GATHER_VALUE_DEF
                                     list
                                     [
                                     32
                                     ]
                                     ;
                                     }
                                     GATHER
                                     ;
                                     extern
                                     GATHER
                                     gather
                                     ;
                                     extern
                                     double
                                     *
                                     gather_buffer
                                     ;
                                     extern
                                     float
                                     *
                                     input
                                     ;
                                     void
                                     SetupGatherAllOnAxis
                                     (
                                     int
                                     c
                                     ,
                                     int
                                     n_Samples
                                     )
                                     ;
                                     void
                                     TriggerGather
                                     (
                                     )
                                     ;
                                     extern
                                     double
                                     CS0_TimeBase
                                     ;
                                     extern
                                     double
                                     CS0_TimeBaseDelta
                                     ;
                                     extern
                                     float
                                     CS0_DecelTime
                                     ;
                                     extern
                                     int
                                     CS0_StoppingState
                                     ;
                                     void
                                     StopCoordinatedMotion
                                     (
                                     void
                                     )
                                     ;
                                     void
                                     ResumeCoordinatedMotion
                                     (
                                     void
                                     )
                                     ;
                                     void
                                     ClearStopImmediately
                                     (
                                     void
                                     )
                                     ;
                                     void
                                     UpdateStoppingState
                                     (
                                     void
                                     )
                                     ;
                                     typedef
                                     struct
                                     {
                                     double
                                     a
                                     ;
                                     double
                                     b
                                     ;
                                     double
                                     c
                                     ;
                                     double
                                     d
                                     ;
                                     }
                                     TRIP_CIRCLE_LINEAR
                                     ;
                                     typedef
                                     struct
                                     {
                                     double
                                     c
                                     ;
                                     double
                                     d
                                     ;
                                     }
                                     TRIP_LINEAR
                                     ;
                                     typedef
                                     struct
                                     {
                                     char
                                     trajectory_mode
                                     ;
                                     unsigned
                                     char
                                     x_axis
                                     ;
                                     unsigned
                                     char
                                     y_axis
                                     ;
                                     unsigned
                                     char
                                     z_axis
                                     ;
                                     unsigned
                                     char
                                     a_axis
                                     ;
                                     unsigned
                                     char
                                     b_axis
                                     ;
                                     unsigned
                                     char
                                     c_axis
                                     ;
                                     double
                                     t
                                     ;
                                     double
                                     a
                                     ;
                                     double
                                     b
                                     ;
                                     double
                                     c
                                     ;
                                     double
                                     d
                                     ;
                                     TRIP_CIRCLE_LINEAR
                                     X
                                     ,
                                     Y
                                     ;
                                     TRIP_LINEAR
                                     Z
                                     ,
                                     A
                                     ,
                                     B
                                     ,
                                     C
                                     ;
                                     }
                                     PARAMETRIC_COEFF
                                     ;
                                     typedef
                                     struct
                                     {
                                     int
                                     trajectory_mode
                                     ;
                                     double
                                     t
                                     ;
                                     double
                                     a
                                     ;
                                     double
                                     b
                                     ;
                                     double
                                     c
                                     ;
                                     double
                                     d
                                     ;
                                     }
                                     TRIP_COEFF
                                     ;
                                     typedef
                                     struct
                                     {
                                     float
                                     A1
                                     ;
                                     float
                                     A2
                                     ;
                                     float
                                     B0
                                     ;
                                     float
                                     B1
                                     ;
                                     float
                                     B2
                                     ;
                                     float
                                     d0
                                     ,
                                     d1
                                     ;
                                     }
                                     IIR
                                     ;
                                     extern
                                     TRIP_COEFF
                                     TripCoeffs
                                     [
                                     8
                                     ]
                                     [
                                     20
                                     ]
                                     ;
                                     typedef
                                     struct
                                     {
                                     int
                                     ChanNumber
                                     ;
                                     int
                                     Enable
                                     ;
                                     int
                                     InputMode
                                     ;
                                     int
                                     OutputMode
                                     ;
                                     int
                                     LimitSwitchOptions
                                     ;
                                     int
                                     MasterAxis
                                     ;
                                     double
                                     SlaveGain
                                     ;
                                     double
                                     MaxFollowingError
                                     ;
                                     double
                                     LastFollowingError
                                     ;
                                     double
                                     t
                                     ;
                                     double
                                     Dest
                                     ;
                                     double
                                     DestOffset
                                     ;
                                     float
                                     Vel
                                     ;
                                     float
                                     Accel
                                     ;
                                     float
                                     Jerk
                                     ;
                                     float
                                     FFAccel
                                     ;
                                     float
                                     FFVel
                                     ;
                                     double
                                     Position
                                     ;
                                     double
                                     invDistPerCycle
                                     ;
                                     float
                                     StepperAmplitude
                                     ;
                                     float
                                     Output
                                     ;
                                     float
                                     Lead
                                     ;
                                     TRIP_COEFF
                                     *
                                     pcoeff
                                     ;
                                     double
                                     last_position
                                     ;
                                     double
                                     last_dest
                                     ;
                                     float
                                     last_vel
                                     ;
                                     float
                                     x1last
                                     ,
                                     x2last
                                     ;
                                     int
                                     OutputChan0
                                     ,
                                     OutputChan1
                                     ;
                                     int
                                     InputChan0
                                     ,
                                     InputChan1
                                     ;
                                     float
                                     InputOffset0
                                     ,
                                     InputGain0
                                     ;
                                     float
                                     InputOffset1
                                     ,
                                     InputGain1
                                     ;
                                     float
                                     OutputGain
                                     ;
                                     float
                                     OutputOffset
                                     ;
                                     float
                                     CommutationOffset
                                     ;
                                     float
                                     last_theta
                                     ;
                                     float
                                     theta_correction
                                     ;
                                     signed
                                     char
                                     last_enc
                                     ;
                                     float
                                     P
                                     ,
                                     I
                                     ,
                                     D
                                     ;
                                     float
                                     MaxI
                                     ;
                                     float
                                     MaxErr
                                     ;
                                     float
                                     integrator
                                     ;
                                     float
                                     MaxOutput
                                     ;
                                     float
                                     DeadBandRange
                                     ;
                                     float
                                     DeadBandGain
                                     ;
                                     int
                                     LastMotionType
                                     ;
                                     double
                                     LastMotionDest
                                     ;
                                     float
                                     SoftLimitNeg
                                     ;
                                     float
                                     SoftLimitPos
                                     ;
                                     TRIP_COEFF
                                     *
                                     c
                                     ;
                                     IIR
                                     iir
                                     [
                                     3
                                     ]
                                     ;
                                     }
                                     CHAN
                                     ;
                                     extern
                                     short
                                     int
                                     DAC_Buffer
                                     [
                                     8
                                     ]
                                     ;
                                     extern
                                     int
                                     ADC_BufferIn
                                     [
                                     8
                                     ]
                                     ;
                                     extern
                                     int
                                     ADC_BufferInSnap
                                     [
                                     2
                                     *
                                     8
                                     ]
                                     ;
                                     void
                                     WritePWMR
                                     (
                                     int
                                     ch
                                     ,
                                     int
                                     v
                                     )
                                     ;
                                     void
                                     WritePWM
                                     (
                                     int
                                     ch
                                     ,
                                     int
                                     v
                                     )
                                     ;
                                     void
                                     WritePWMC
                                     (
                                     int
                                     ch
                                     ,
                                     int
                                     v
                                     )
                                     ;
                                     extern
                                     int
                                     SnapAmpPresent
                                     ;
                                     void
                                     WriteSnapAmp
                                     (
                                     int
                                     add
                                     ,
                                     int
                                     data
                                     )
                                     ;
                                     int
                                     ReadSnapAmp
                                     (
                                     int
                                     add
                                     )
                                     ;
                                     extern
                                     int
                                     KanalogPresent
                                     ;
                                     void
                                     Write3PH
                                     (
                                     CHAN
                                     *
                                     ch0
                                     ,
                                     float
                                     v
                                     ,
                                     double
                                     angle_in_cycles
                                     )
                                     ;
                                     void
                                     Write4PH
                                     (
                                     CHAN
                                     *
                                     ch0
                                     ,
                                     float
                                     v
                                     ,
                                     double
                                     angle_in_cycles
                                     )
                                     ;
                                     extern
                                     int
                                     LastPWM
                                     [
                                     8
                                     +
                                     2
                                     *
                                     4
                                     ]
                                     ;
                                     int
                                     ReadADC
                                     (
                                     int
                                     ch
                                     )
                                     ;
                                     void
                                     WriteDAC
                                     (
                                     int
                                     ch
                                     ,
                                     int
                                     v
                                     )
                                     ;
                                     double
                                     Time_sec
                                     (
                                     )
                                     ;
                                     void
                                     WaitUntil
                                     (
                                     double
                                     time_sec
                                     )
                                     ;
                                     void
                                     Delay_sec
                                     (
                                     double
                                     sec
                                     )
                                     ;
                                     double
                                     WaitNextTimeSlice
                                     (
                                     void
                                     )
                                     ;
                                     extern
                                     volatile
                                     double
                                     ServoTick
                                     ;
                                     extern
                                     volatile
                                     unsigned
                                     int
                                     LastTimer0
                                     ;
                                     extern
                                     CHAN
                                     chan
                                     [
                                     8
                                     ]
                                     ;
                                     extern
                                     CHAN
                                     *
                                     ch0
                                     ;
                                     extern
                                     CHAN
                                     *
                                     ch1
                                     ;
                                     extern
                                     CHAN
                                     *
                                     ch2
                                     ;
                                     extern
                                     CHAN
                                     *
                                     ch3
                                     ;
                                     extern
                                     CHAN
                                     *
                                     ch4
                                     ;
                                     extern
                                     CHAN
                                     *
                                     ch5
                                     ;
                                     extern
                                     CHAN
                                     *
                                     ch6
                                     ;
                                     extern
                                     CHAN
                                     *
                                     ch7
                                     ;
                                     extern
                                     MAIN_STATUS
                                     MainStatus
                                     ;
                                     void
                                     DisableAxis
                                     (
                                     int
                                     ch
                                     )
                                     ;
                                     void
                                     EnableAxisDest
                                     (
                                     int
                                     ch
                                     ,
                                     double
                                     Dest
                                     )
                                     ;
                                     void
                                     EnableAxis
                                     (
                                     int
                                     ch
                                     )
                                     ;
                                     void
                                     ResetFilters
                                     (
                                     int
                                     ch
                                     )
                                     ;
                                     void
                                     Zero
                                     (
                                     int
                                     ch
                                     )
                                     ;
                                     void
                                     Move
                                     (
                                     int
                                     ch
                                     ,
                                     double
                                     x
                                     )
                                     ;
                                     void
                                     MoveAtVel
                                     (
                                     int
                                     chno
                                     ,
                                     double
                                     x
                                     ,
                                     float
                                     MaxVel
                                     )
                                     ;
                                     void
                                     MoveRel
                                     (
                                     int
                                     ch
                                     ,
                                     double
                                     dx
                                     )
                                     ;
                                     void
                                     MoveRelAtVel
                                     (
                                     int
                                     chno
                                     ,
                                     double
                                     x
                                     ,
                                     float
                                     MaxVel
                                     )
                                     ;
                                     void
                                     Jog
                                     (
                                     int
                                     ch
                                     ,
                                     double
                                     vel
                                     )
                                     ;
                                     void
                                     MoveExp
                                     (
                                     int
                                     chno
                                     ,
                                     double
                                     x
                                     ,
                                     double
                                     Tau
                                     )
                                     ;
                                     int
                                     CheckDone
                                     (
                                     int
                                     ch
                                     )
                                     ;
                                     void
                                     MoveXYZABC
                                     (
                                     double
                                     x
                                     ,
                                     double
                                     y
                                     ,
                                     double
                                     z
                                     ,
                                     double
                                     a
                                     ,
                                     double
                                     b
                                     ,
                                     double
                                     c
                                     )
                                     ;
                                     int
                                     CheckDoneXYZABC
                                     (
                                     )
                                     ;
                                     int
                                     CheckDoneBuf
                                     (
                                     )
                                     ;
                                     int
                                     CheckDoneGather
                                     (
                                     )
                                     ;
                                     void
                                     StartMove
                                     (
                                     int
                                     ch
                                     )
                                     ;
                                     void
                                     SetupForMove
                                     (
                                     double
                                     From
                                     ,
                                     double
                                     To
                                     ,
                                     float
                                     MaxVel
                                     ,
                                     CHAN
                                     *
                                     ch
                                     ,
                                     int
                                     CoeffOffset
                                     ,
                                     int
                                     NoJerkControlAtStart
                                     ,
                                     int
                                     NoJerkControlAtEnd
                                     ,
                                     int
                                     Start
                                     )
                                     ;
                                     void
                                     SetupForMotionPause
                                     (
                                     double
                                     x
                                     ,
                                     CHAN
                                     *
                                     ch
                                     ,
                                     int
                                     CoeffOffset
                                     ,
                                     double
                                     time
                                     )
                                     ;
                                     extern
                                     int
                                     CS0_axis_x
                                     ;
                                     extern
                                     int
                                     CS0_axis_y
                                     ;
                                     extern
                                     int
                                     CS0_axis_z
                                     ;
                                     extern
                                     int
                                     CS0_axis_a
                                     ;
                                     extern
                                     int
                                     CS0_axis_b
                                     ;
                                     extern
                                     int
                                     CS0_axis_c
                                     ;
                                     void
                                     DefineCoordSystem
                                     (
                                     int
                                     axisx
                                     ,
                                     int
                                     axisy
                                     ,
                                     int
                                     axisz
                                     ,
                                     int
                                     axisa
                                     )
                                     ;
                                     void
                                     DefineCoordSystem6
                                     (
                                     int
                                     axisx
                                     ,
                                     int
                                     axisy
                                     ,
                                     int
                                     axisz
                                     ,
                                     int
                                     axisa
                                     ,
                                     int
                                     axisb
                                     ,
                                     int
                                     axisc
                                     )
                                     ;
                                     void
                                     StopMotion
                                     (
                                     CHAN
                                     *
                                     ch
                                     )
                                     ;
                                     void
                                     SetupForMotionEnd
                                     (
                                     CHAN
                                     *
                                     ch
                                     ,
                                     int
                                     CoeffOffset
                                     )
                                     ;
                                     extern
                                     int
                                     VirtualBits
                                     ;
                                     extern
                                     int
                                     BitDirShadow
                                     [
                                     2
                                     ]
                                     ;
                                     extern
                                     int
                                     BitDirShadowSnap0
                                     ;
                                     extern
                                     int
                                     BitDirShadowSnap1
                                     ;
                                     void
                                     SetBitDirection
                                     (
                                     int
                                     bit
                                     ,
                                     int
                                     dir
                                     )
                                     ;
                                     int
                                     GetBitDirection
                                     (
                                     int
                                     bit
                                     )
                                     ;
                                     void
                                     SetBit
                                     (
                                     int
                                     bit
                                     )
                                     ;
                                     void
                                     ClearBit
                                     (
                                     int
                                     bit
                                     )
                                     ;
                                     void
                                     SetStateBit
                                     (
                                     int
                                     bit
                                     ,
                                     int
                                     state
                                     )
                                     ;
                                     int
                                     ReadBit
                                     (
                                     int
                                     bit
                                     )
                                     ;
                                     int
                                     printf
                                     (
                                     const
                                     char
                                     *
                                     format
                                     ,
                                     
                                     )
                                     ;
                                     int
                                     sprintf
                                     (
                                     char
                                     *
                                     s
                                     ,
                                     const
                                     char
                                     *
                                     format
                                     ,
                                     
                                     )
                                     ;
                                     int
                                     Print
                                     (
                                     char
                                     *
                                     s
                                     )
                                     ;
                                     int
                                     PrintFloat
                                     (
                                     char
                                     *
                                     Format
                                     ,
                                     double
                                     v
                                     )
                                     ;
                                     int
                                     PrintInt
                                     (
                                     char
                                     *
                                     Format
                                     ,
                                     int
                                     v
                                     )
                                     ;
                                     void
                                     DoResolverInput2
                                     (
                                     CHAN
                                     *
                                     chx
                                     ,
                                     float
                                     x
                                     ,
                                     float
                                     y
                                     )
                                     ;
                                     void
                                     StartThread
                                     (
                                     int
                                     thread
                                     )
                                     ;
                                     void
                                     PauseThread
                                     (
                                     int
                                     thread
                                     )
                                     ;
                                     int
                                     ResumeThread
                                     (
                                     int
                                     thread
                                     )
                                     ;
                                     void
                                     ThreadDone
                                     (
                                     void
                                     )
                                     ;
                                     void
                                     MutexLock
                                     (
                                     int
                                     *
                                     mutex
                                     )
                                     ;
                                     void
                                     MutexUnlock
                                     (
                                     int
                                     *
                                     mutex
                                     )
                                     ;
                                     main
                                     (
                                     )
                                     {
0000  003C0058 MV.L 0 108 105
0004  07BC1058 MV.L 0 106 108
0008  07800052 ADDK 0 106 0
000C  003C54F4 STW.D SP POST DEC 105 0 0
0010  01BC54F6 STW.D SP POST DEC 107 0 0
                                     printf
                                     (
                                     (
                                     "Hello World!\n"
                                     )
                                     "Hello World!\n"
                                     
                                     "Hello World!\n"
                                     
0014  02000028 MVKL. 0 4 0
0018  02000068 MVKH. 0 4 0
001C  023C54F4 STW.D SP POST DEC 4 0 0
                                     ;
0020  023C52E4 LDW.D SP PRE INC 4 0 0
0024  07FFFC52 ADDK -8 106 0
0028  00004000 NOP 3 0 0
002C  023C22F4 STW.D +* 4 106 1
0030  00000028 MVKL. 0 105 0
0034  00000068 MVKH. 0 105 0
0038  00001362 B.S2 0 -1 105
003C  0180002A MVKL. 0 107 0
0040  0180006A MVKH. 0 107 0
0044  00004000 NOP 3 0 0
0048  07800452 ADDK 8 106 0
                                     }
                                     
004C  01BC52E6 LDW.D SP PRE INC 107 0 0
0050  00006000 NOP 4 0 0
0054  000C0362 B.S2 0 -1 107
0058  07BC52E4 LDW.D SP PRE INC 108 0 0
005C  07800052 ADDK 0 106 0
0060  00004000 NOP 3 0 0
