Nap instruction sometimes executed with wrong permissions.

    When executing the nap instruction, all thread state can be
    lost.  This was causing r0 to be lost, which contained the
    system-call number for the idle thread to request permission
    to execute nap and as a result 'task-yield' was executed
    instead of 'cpu-nap' after the idle thread took its first
    nap.

    Re-arranged the sreset code that handles nap-wakeup to deal
    with thread-state being lost when entering nap and instead
    using the previously saved task-state from the 'cpu-nap'
    system call.

Change-Id: Id7468a8577c4d7b273b23bc97e7dd040555e7b67
Reviewed-on: http://gfw160.austin.ibm.com:8080/gerrit/1567
Tested-by: Jenkins Server
Reviewed-by: A. Patrick Williams III <iawillia@us.ibm.com>

7 files changed, 217 insertions, 1903 deletions

diff --git a/src/build/citest/etc/patches/p8_inst.act b/src/build/citest/etc/patches/p8_inst.act
deleted file mode 100644
index f9b47ae21..000000000
--- a/src/build/citest/etc/patches/p8_inst.act
+++ /dev/null
@@ -1,1802 +0,0 @@
-# Actions for P8 chips related to Instruction Processing
-
-#  Flag  PTR/DCR#  Userid    Date      Description
-#  ----  --------  --------  --------  -----------
-#        D841334   dcrowell  06/11/11  File Created
-#   @01  D846452   dcrowell  07/31/12  Add Winkle/IPI support
-
-
-# Actions work like this:
-#  Scoms to action bits will set state bits in THREADSTATE regspace
-#  Changes to THREADSTATE regspace will update status bits in Scom regs
-#
-# See p8.chip for THREADSTATE bit definitions
-
-###################
-## Scom Triggers ##
-
-##### SRESET #####
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Sreset Instructions - cXt0]
-  WATCH=[REG(MYCHIPLET,0x013000)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013000)] OP=[BIT,ON] BIT=[60] # SRESET
-  EFFECT: TARGET=[PROCREG(nia, MYCORE, 0)] OP=[EQUALTO,BUF] DATA=[LITERAL(64,00000000 00000100)]
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 0)] OP=[MODULECALL]
-  # Clear quiesce, por, maint mode, and all idle states
-  # Set running, active
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x0)] OP=[EQUALTO,BUF] DATA=[LITERAL(32,28000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013000)] OP=[BIT,OFF] BIT=[60] # register is pulsed, clear the bit we just set
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Sreset Instructions - cXt1]
-  WATCH=[REG(MYCHIPLET,0x013010)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013010)] OP=[BIT,ON] BIT=[60] # SRESET
-  EFFECT: TARGET=[PROCREG(nia, MYCORE, 1)] OP=[EQUALTO,BUF] DATA=[LITERAL(64,00000000 00000100)]
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 1)] OP=[MODULECALL] # Start Hostboot
-  # Clear quiesce, por, maint mode, and all idle states
-  # Set running, active
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x1)] OP=[EQUALTO,BUF] DATA=[LITERAL(32,28000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013010)] OP=[BIT,OFF] BIT=[60] # register is pulsed, clear the bit we just set
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Sreset Instructions - cXt2]
-  WATCH=[REG(MYCHIPLET,0x013020)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013020)] OP=[BIT,ON] BIT=[60] # SRESET
-  EFFECT: TARGET=[PROCREG(nia, MYCORE, 2)] OP=[EQUALTO,BUF] DATA=[LITERAL(64,00000000 00000100)]
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 2)] OP=[MODULECALL] # Start Hostboot
-  # Clear quiesce, por, maint mode, and all idle states
-  # Set running, active
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x2)] OP=[EQUALTO,BUF] DATA=[LITERAL(32,28000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013020)] OP=[BIT,OFF] BIT=[60] # register is pulsed, clear the bit we just set
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Sreset Instructions - cXt3]
-  WATCH=[REG(MYCHIPLET,0x013030)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013030)] OP=[BIT,ON] BIT=[60] # SRESET
-  EFFECT: TARGET=[PROCREG(nia, MYCORE, 3)] OP=[EQUALTO,BUF] DATA=[LITERAL(64,00000000 00000100)]
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 3)] OP=[MODULECALL] # Start Hostboot
-  # Clear quiesce, por, maint mode, and all idle states
-  # Set running, active
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x3)] OP=[EQUALTO,BUF] DATA=[LITERAL(32,28000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013030)] OP=[BIT,OFF] BIT=[60] # register is pulsed, clear the bit we just set
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Sreset Instructions - cXt4]
-  WATCH=[REG(MYCHIPLET,0x013040)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013040)] OP=[BIT,ON] BIT=[60] # SRESET
-  EFFECT: TARGET=[PROCREG(nia, MYCORE, 4)] OP=[EQUALTO,BUF] DATA=[LITERAL(64,00000000 00000100)]
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 4)] OP=[MODULECALL] # Start Hostboot
-  # Clear quiesce, por, maint mode, and all idle states
-  # Set running, active
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x4)] OP=[EQUALTO,BUF] DATA=[LITERAL(32,28000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013040)] OP=[BIT,OFF] BIT=[60] # register is pulsed, clear the bit we just set
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Sreset Instructions - cXt5]
-  WATCH=[REG(MYCHIPLET,0x013050)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013050)] OP=[BIT,ON] BIT=[60] # SRESET
-  EFFECT: TARGET=[PROCREG(nia, MYCORE, 5)] OP=[EQUALTO,BUF] DATA=[LITERAL(64,00000000 00000100)]
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 5)] OP=[MODULECALL] # Start Hostboot
-  # Clear quiesce, por, maint mode, and all idle states
-  # Set running, active
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x5)] OP=[EQUALTO,BUF] DATA=[LITERAL(32,28000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013050)] OP=[BIT,OFF] BIT=[60] # register is pulsed, clear the bit we just set
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Sreset Instructions - cXt6]
-  WATCH=[REG(MYCHIPLET,0x013060)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013060)] OP=[BIT,ON] BIT=[60] # SRESET
-  EFFECT: TARGET=[PROCREG(nia, MYCORE, 6)] OP=[EQUALTO,BUF] DATA=[LITERAL(64,00000000 00000100)]
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 6)] OP=[MODULECALL] # Start Hostboot
-  # Clear quiesce, por, maint mode, and all idle states
-  # Set running, active
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x6)] OP=[EQUALTO,BUF] DATA=[LITERAL(32,28000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013060)] OP=[BIT,OFF] BIT=[60] # register is pulsed, clear the bit we just set
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Sreset Instructions - cXt7]
-  WATCH=[REG(MYCHIPLET,0x013070)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013070)] OP=[BIT,ON] BIT=[60] # SRESET
-  EFFECT: TARGET=[PROCREG(nia, MYCORE, 7)] OP=[EQUALTO,BUF] DATA=[LITERAL(64,00000000 00000100)]
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 7)] OP=[MODULECALL] # Start Hostboot
-  # Clear quiesce, por, maint mode, and all idle states
-  # Set running, active
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x7)] OP=[EQUALTO,BUF] DATA=[LITERAL(32,28000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013070)] OP=[BIT,OFF] BIT=[60] # register is pulsed, clear the bit we just set
-}
-
-
-##### Start #####
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Start Instructions - cXt0]
-  WATCH=[REG(MYCHIPLET,0x013000)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013000)] OP=[BIT,ON] BIT=[62] # Start
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 0)] OP=[MODULECALL]
-  # Clear quiesce, por, maint mode
-  # Set running
-  # Leave other bits alone
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x0)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,70000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013000)] OP=[BIT,OFF] BIT=[62] # register is pulsed, clear the bit we just set
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Start Instructions - cXt1]
-  WATCH=[REG(MYCHIPLET,0x013010)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013010)] OP=[BIT,ON] BIT=[62] # Start
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 1)] OP=[MODULECALL] # Start Hostboot
-  # Clear quiesce, por, maint mode
-  # Set running
-  # Leave other bits alone
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x1)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,70000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013010)] OP=[BIT,OFF] BIT=[62] # register is pulsed, clear the bit we just set
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Start Instructions - cXt2]
-  WATCH=[REG(MYCHIPLET,0x013020)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013020)] OP=[BIT,ON] BIT=[62] # Start
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 2)] OP=[MODULECALL] # Start Hostboot
-  # Clear quiesce, por, maint mode
-  # Set running
-  # Leave other bits alone
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x2)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,70000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013020)] OP=[BIT,OFF] BIT=[62] # register is pulsed, clear the bit we just set
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Start Instructions - cXt3]
-  WATCH=[REG(MYCHIPLET,0x013030)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013030)] OP=[BIT,ON] BIT=[62] # Start
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 3)] OP=[MODULECALL] # Start Hostboot
-  # Clear quiesce, por, maint mode
-  # Set running
-  # Leave other bits alone
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x3)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,70000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013030)] OP=[BIT,OFF] BIT=[62] # register is pulsed, clear the bit we just set
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Start Instructions - cXt4]
-  WATCH=[REG(MYCHIPLET,0x013040)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013040)] OP=[BIT,ON] BIT=[62] # Start
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 4)] OP=[MODULECALL] # Start Hostboot
-  # Clear quiesce, por, maint mode
-  # Set running
-  # Leave other bits alone
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x4)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,70000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013040)] OP=[BIT,OFF] BIT=[62] # register is pulsed, clear the bit we just set
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Start Instructions - cXt5]
-  WATCH=[REG(MYCHIPLET,0x013050)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013050)] OP=[BIT,ON] BIT=[62] # Start
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 5)] OP=[MODULECALL] # Start Hostboot
-  # Clear quiesce, por, maint mode
-  # Set running
-  # Leave other bits alone
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x5)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,70000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013050)] OP=[BIT,OFF] BIT=[62] # register is pulsed, clear the bit we just set
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Start Instructions - cXt6]
-  WATCH=[REG(MYCHIPLET,0x013062)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,ON] BIT=[62] # Start
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 6)] OP=[MODULECALL] # Start Hostboot
-  # Clear quiesce, por, maint mode
-  # Set running
-  # Leave other bits alone
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x6)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,70000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,OFF] BIT=[62] # register is pulsed, clear the bit we just set
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Start Instructions - cXt7]
-  WATCH=[REG(MYCHIPLET,0x013070)] # RAS Control Reg
-  CAUSE: TARGET=[REG(MYCHIPLET,0x013070)] OP=[BIT,ON] BIT=[62] # Start
-  EFFECT: TARGET=[MODULE(startInstructions, MYCORE, 7)] OP=[MODULECALL] # Start Hostboot
-  # Clear quiesce, por, maint mode
-  # Set running
-  # Leave other bits alone
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x7)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,70000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013070)] OP=[BIT,OFF] BIT=[62] # register is pulsed, clear the bit we just set
-}
-
-
-
-####################
-## Status Updates ##
-
-##### Running #####
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Running - cXt0]
-  WATCH=[THREADSTATE(MYCHIPLET,0x0)]
-  WATCH=[REG(MYCHIPLET,0x013002)]
-  # running=1, quiesced=0, idle states=0, por=0, maintmode=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x0)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,F7000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,OFF] BIT=[49] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Running - cXt1]
-  WATCH=[THREADSTATE(MYCHIPLET,0x1)]
-  WATCH=[REG(MYCHIPLET,0x013012)]
-  # running=1, quiesced=0, idle states=0, por=0, maintmode=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x1)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,F7000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,OFF] BIT=[49] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Running - cXt2]
-  WATCH=[THREADSTATE(MYCHIPLET,0x2)]
-  WATCH=[REG(MYCHIPLET,0x013022)]
-  # running=1, quiesced=0, idle states=0, por=0, maintmode=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x2)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,F7000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,OFF] BIT=[49] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Running - cXt3]
-  WATCH=[THREADSTATE(MYCHIPLET,0x3)]
-  WATCH=[REG(MYCHIPLET,0x013032)]
-  # running=1, quiesced=0, idle states=0, por=0, maintmode=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x3)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,F7000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,OFF] BIT=[49] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Running - cXt4]
-  WATCH=[THREADSTATE(MYCHIPLET,0x4)]
-  WATCH=[REG(MYCHIPLET,0x013042)]
-  # running=1, quiesced=0, idle states=0, por=0, maintmode=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x4)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,F7000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,OFF] BIT=[49] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Running - cXt5]
-  WATCH=[THREADSTATE(MYCHIPLET,0x5)]
-  WATCH=[REG(MYCHIPLET,0x013052)]
-  # running=1, quiesced=0, idle states=0, por=0, maintmode=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x5)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,F7000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,OFF] BIT=[49] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Running - cXt6]
-  WATCH=[THREADSTATE(MYCHIPLET,0x6)]
-  WATCH=[REG(MYCHIPLET,0x013062)]
-  # running=1, quiesced=0, idle states=0, por=0, maintmode=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x6)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,F7000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,OFF] BIT=[49] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Running - cXt7]
-  WATCH=[THREADSTATE(MYCHIPLET,0x7)]
-  WATCH=[REG(MYCHIPLET,0x013072)]
-  # running=1, quiesced=0, idle states=0, por=0, maintmode=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x7)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,20000000)] MASK=[LITERAL(32,F7000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,OFF] BIT=[49] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
-}
-
-##### Active #####
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt0]
-  WATCH=[THREADSTATE(MYCHIPLET,0x0)]
-  WATCH=[REG(MYCHIPLET,0x013002)]
-  # active=1, idle states=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x0)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,ON] BIT=[48]  #THREAD_ENABLED
-  ELSE: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,OFF] BIT=[48]  #THREAD_ENABLED
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt1]
-  WATCH=[THREADSTATE(MYCHIPLET,0x1)]
-  WATCH=[REG(MYCHIPLET,0x013012)]
-  # active=1, idle states=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x1)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,ON] BIT=[48]  #THREAD_ENABLED
-  ELSE: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,OFF] BIT=[48]  #THREAD_ENABLED
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt2]
-  WATCH=[THREADSTATE(MYCHIPLET,0x2)]
-  WATCH=[REG(MYCHIPLET,0x013022)]
-  # active=1, idle states=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x2)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,ON] BIT=[48]  #THREAD_ENABLED
-  ELSE: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,OFF] BIT=[48]  #THREAD_ENABLED
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt3]
-  WATCH=[THREADSTATE(MYCHIPLET,0x3)]
-  WATCH=[REG(MYCHIPLET,0x013032)]
-  # active=1, idle states=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x3)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,ON] BIT=[48]  #THREAD_ENABLED
-  ELSE: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,OFF] BIT=[48]  #THREAD_ENABLED
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt4]
-  WATCH=[THREADSTATE(MYCHIPLET,0x4)]
-  WATCH=[REG(MYCHIPLET,0x013042)]
-  # active=1, idle states=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x4)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,ON] BIT=[48]  #THREAD_ENABLED
-  ELSE: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,OFF] BIT=[48]  #THREAD_ENABLED
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt5]
-  WATCH=[THREADSTATE(MYCHIPLET,0x5)]
-  WATCH=[REG(MYCHIPLET,0x013052)]
-  # active=1, idle states=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x5)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,ON] BIT=[48]  #THREAD_ENABLED
-  ELSE: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,OFF] BIT=[48]  #THREAD_ENABLED
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt6]
-  WATCH=[THREADSTATE(MYCHIPLET,0x6)]
-  WATCH=[REG(MYCHIPLET,0x013062)]
-  # active=1, idle states=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x6)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,ON] BIT=[48]  #THREAD_ENABLED
-  ELSE: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,OFF] BIT=[48]  #THREAD_ENABLED
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt7]
-  WATCH=[THREADSTATE(MYCHIPLET,0x7)]
-  WATCH=[REG(MYCHIPLET,0x013072)]
-  # active=1, idle states=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x7)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,ON] BIT=[48]  #THREAD_ENABLED
-  ELSE: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,OFF] BIT=[48]  #THREAD_ENABLED
-}
-
-##### Quiesced #####
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Quiesced - cXt0]
-  WATCH=[THREADSTATE(MYCHIPLET,0x0)]
-  WATCH=[REG(MYCHIPLET,0x013002)]
-  # quiesced=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x0)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,40000000)] MASK=[LITERAL(32,60000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,ON]  BIT=[49] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,OFF] BIT=[50] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,OFF] BIT=[51] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,OFF] BIT=[52] #QUIESCE=0b1000
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Quiesced - cXt1]
-  WATCH=[THREADSTATE(MYCHIPLET,0x1)]
-  WATCH=[REG(MYCHIPLET,0x013012)]
-  # Quiesced=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x1)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,40000000)] MASK=[LITERAL(32,60000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,ON]  BIT=[49] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,OFF] BIT=[50] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,OFF] BIT=[51] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,OFF] BIT=[52] #QUIESCE=0b1000
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Quiesced - cXt2]
-  WATCH=[THREADSTATE(MYCHIPLET,0x2)]
-  WATCH=[REG(MYCHIPLET,0x013022)]
-  # Quiesced=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x2)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,40000000)] MASK=[LITERAL(32,60000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,ON]  BIT=[49] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,OFF] BIT=[50] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,OFF] BIT=[51] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,OFF] BIT=[52] #QUIESCE=0b1000
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Quiesced - cXt4]
-  WATCH=[THREADSTATE(MYCHIPLET,0x4)]
-  WATCH=[REG(MYCHIPLET,0x013042)]
-  # Quiesced=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x4)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,40000000)] MASK=[LITERAL(32,60000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,ON]  BIT=[49] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,OFF] BIT=[50] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,OFF] BIT=[51] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,OFF] BIT=[52] #QUIESCE=0b1000
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Quiesced - cXt5]
-  WATCH=[THREADSTATE(MYCHIPLET,0x5)]
-  WATCH=[REG(MYCHIPLET,0x013052)]
-  # Quiesced=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x5)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,40000000)] MASK=[LITERAL(32,60000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,ON]  BIT=[49] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,OFF] BIT=[50] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,OFF] BIT=[51] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,OFF] BIT=[52] #QUIESCE=0b1000
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Quiesced - cXt6]
-  WATCH=[THREADSTATE(MYCHIPLET,0x6)]
-  WATCH=[REG(MYCHIPLET,0x013062)]
-  # Quiesced=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x6)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,40000000)] MASK=[LITERAL(32,60000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,ON]  BIT=[49] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,OFF] BIT=[50] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,OFF] BIT=[51] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,OFF] BIT=[52] #QUIESCE=0b1000
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Quiesced - cXt7]
-  WATCH=[THREADSTATE(MYCHIPLET,0x7)]
-  WATCH=[REG(MYCHIPLET,0x013072)]
-  # Quiesced=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x7)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,40000000)] MASK=[LITERAL(32,60000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BUF,AND,OFF] DATA=[LITERAL(64,0x00000FFF FFFF87FF]  #clear all state bits
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,ON]  BIT=[49] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,OFF] BIT=[50] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,OFF] BIT=[51] #QUIESCE=0b1000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,OFF] BIT=[52] #QUIESCE=0b1000
-}
-
-##### Maintmode #####
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Maintmode - cXt0]
-  WATCH=[THREADSTATE(MYCHIPLET,0x0)]
-  WATCH=[REG(MYCHIPLET,0x013002)]
-  # maintmode=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x0)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
-  ELSE: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Maintmode - cXt1]
-  WATCH=[THREADSTATE(MYCHIPLET,0x1)]
-  WATCH=[REG(MYCHIPLET,0x013012)]
-  # maintmode=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x1)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
-  ELSE: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Maintmode - cXt2]
-  WATCH=[THREADSTATE(MYCHIPLET,0x2)]
-  WATCH=[REG(MYCHIPLET,0x013022)]
-  # maintmode=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x2)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
-  ELSE: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Maintmode - cXt3]
-  WATCH=[THREADSTATE(MYCHIPLET,0x3)]
-  WATCH=[REG(MYCHIPLET,0x013032)]
-  # maintmode=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x3)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
-  ELSE: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Maintmode - cXt4]
-  WATCH=[THREADSTATE(MYCHIPLET,0x4)]
-  WATCH=[REG(MYCHIPLET,0x013042)]
-  # maintmode=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x4)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
-  ELSE: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Maintmode - cXt5]
-  WATCH=[THREADSTATE(MYCHIPLET,0x5)]
-  WATCH=[REG(MYCHIPLET,0x013052)]
-  # maintmode=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x5)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
-  ELSE: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Maintmode - cXt6]
-  WATCH=[THREADSTATE(MYCHIPLET,0x6)]
-  WATCH=[REG(MYCHIPLET,0x013062)]
-  # maintmode=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x6)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
-  ELSE: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
-}
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Maintmode - cXt7]
-  WATCH=[THREADSTATE(MYCHIPLET,0x7)]
-  WATCH=[REG(MYCHIPLET,0x013072)]
-  # maintmode=1, running=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x7)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
-  ELSE: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
-}
-
-#@01 begin
-##### Winkle #####
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Winkle - cXt0]
-  WATCH=[THREADSTATE(MYCHIPLET,0x0)]
-  WATCH=[REG(MYCHIPLET,0x013004)]
-  # active=0,nap=0,sleep=0,winkle=1
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x0)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=111
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013004)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C0001C0 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Winkle - cXt1]
-  WATCH=[THREADSTATE(MYCHIPLET,0x1)]
-  WATCH=[REG(MYCHIPLET,0x013014)]
-  # active=0,nap=0,sleep=0,winkle=1
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x1)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=111
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013014)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C0001C0 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Winkle - cXt2]
-  WATCH=[THREADSTATE(MYCHIPLET,0x2)]
-  WATCH=[REG(MYCHIPLET,0x013024)]
-  # active=0,nap=0,sleep=0,winkle=1
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x2)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=111
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013024)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C0001C0 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Winkle - cXt3]
-  WATCH=[THREADSTATE(MYCHIPLET,0x3)]
-  WATCH=[REG(MYCHIPLET,0x013034)]
-  # active=0,nap=0,sleep=0,winkle=1
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x3)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=111
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013034)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C0001C0 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Winkle - cXt4]
-  WATCH=[THREADSTATE(MYCHIPLET,0x4)]
-  WATCH=[REG(MYCHIPLET,0x013044)]
-  # active=0,nap=0,sleep=0,winkle=1
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x4)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=111
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013044)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C0001C0 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Winkle - cXt5]
-  WATCH=[THREADSTATE(MYCHIPLET,0x5)]
-  WATCH=[REG(MYCHIPLET,0x013054)]
-  # active=0,nap=0,sleep=0,winkle=1
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x5)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=111
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013054)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C0001C0 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Winkle - cXt6]
-  WATCH=[THREADSTATE(MYCHIPLET,0x6)]
-  WATCH=[REG(MYCHIPLET,0x013064)]
-  # active=0,nap=0,sleep=0,winkle=1
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x6)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=111
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013064)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C0001C0 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Winkle - cXt7]
-  WATCH=[THREADSTATE(MYCHIPLET,0x7)]
-  WATCH=[REG(MYCHIPLET,0x013074)]
-  # active=0,nap=0,sleep=0,winkle=1
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x7)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=111
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013074)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C0001C0 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-
-##### Sleep #####
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Sleep - cXt0]
-  WATCH=[THREADSTATE(MYCHIPLET,0x0)]
-  WATCH=[REG(MYCHIPLET,0x013004)]
-  # active=0,nap=0,sleep=1,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x0)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,02000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=110
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013004)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C000180 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Sleep - cXt1]
-  WATCH=[THREADSTATE(MYCHIPLET,0x1)]
-  WATCH=[REG(MYCHIPLET,0x013014)]
-  # active=0,nap=0,sleep=1,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x1)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,02000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=110
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013014)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C000180 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Sleep - cXt2]
-  WATCH=[THREADSTATE(MYCHIPLET,0x2)]
-  WATCH=[REG(MYCHIPLET,0x013024)]
-  # active=0,nap=0,sleep=1,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x2)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,02000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=110
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013024)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C000180 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Sleep - cXt3]
-  WATCH=[THREADSTATE(MYCHIPLET,0x3)]
-  WATCH=[REG(MYCHIPLET,0x013034)]
-  # active=0,nap=0,sleep=1,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x3)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,02000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=110
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013034)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C000180 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Sleep - cXt4]
-  WATCH=[THREADSTATE(MYCHIPLET,0x4)]
-  WATCH=[REG(MYCHIPLET,0x013044)]
-  # active=0,nap=0,sleep=1,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x4)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,02000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=110
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013044)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C000180 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Sleep - cXt5]
-  WATCH=[THREADSTATE(MYCHIPLET,0x5)]
-  WATCH=[REG(MYCHIPLET,0x013054)]
-  # active=0,nap=0,sleep=1,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x5)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,02000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=110
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013054)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C000180 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Sleep - cXt6]
-  WATCH=[THREADSTATE(MYCHIPLET,0x6)]
-  WATCH=[REG(MYCHIPLET,0x013064)]
-  # active=0,nap=0,sleep=1,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x6)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,02000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=110
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013064)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C000180 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Sleep - cXt7]
-  WATCH=[THREADSTATE(MYCHIPLET,0x7)]
-  WATCH=[REG(MYCHIPLET,0x013074)]
-  # active=0,nap=0,sleep=1,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x7)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,02000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=11, 23:25=110
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013074)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0C000180 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-
-##### Active #####
-
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt0]
-  WATCH=[THREADSTATE(MYCHIPLET,0x0)]
-  WATCH=[REG(MYCHIPLET,0x013004)]
-  # active=1,nap=0,sleep=0,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x0)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=00, 23:25=000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013004)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,00000000 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt1]
-  WATCH=[THREADSTATE(MYCHIPLET,0x1)]
-  WATCH=[REG(MYCHIPLET,0x013014)]
-  # active=1,nap=0,sleep=0,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x1)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=00, 23:25=000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013014)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,00000000 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt2]
-  WATCH=[THREADSTATE(MYCHIPLET,0x2)]
-  WATCH=[REG(MYCHIPLET,0x013024)]
-  # active=1,nap=0,sleep=0,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x2)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=00, 23:25=000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013024)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,00000000 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt3]
-  WATCH=[THREADSTATE(MYCHIPLET,0x3)]
-  WATCH=[REG(MYCHIPLET,0x013034)]
-  # active=1,nap=0,sleep=0,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x3)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=00, 23:25=000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013034)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,00000000 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt4]
-  WATCH=[THREADSTATE(MYCHIPLET,0x4)]
-  WATCH=[REG(MYCHIPLET,0x013044)]
-  # active=1,nap=0,sleep=0,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x4)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=00, 23:25=000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013044)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,00000000 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt5]
-  WATCH=[THREADSTATE(MYCHIPLET,0x5)]
-  WATCH=[REG(MYCHIPLET,0x013054)]
-  # active=1,nap=0,sleep=0,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x5)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=00, 23:25=000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013054)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,00000000 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt6]
-  WATCH=[THREADSTATE(MYCHIPLET,0x6)]
-  WATCH=[REG(MYCHIPLET,0x013064)]
-  # active=1,nap=0,sleep=0,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x6)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=00, 23:25=000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013064)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,00000000 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Status - Active - cXt7]
-  WATCH=[THREADSTATE(MYCHIPLET,0x7)]
-  WATCH=[REG(MYCHIPLET,0x013074)]
-  # active=1,nap=0,sleep=0,winkle=0
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x7)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,08000000)] MASK=[LITERAL(32,0F000000)]
-  # 4:5=00, 23:25=000
-  EFFECT: TARGET=[REG(MYCHIPLET,0x013074)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,00000000 00000000)] MASK=[LITERAL(64,0C0001C0 00000000)]
-}
-
-
-###################
-## HAP Triggers ##
-
-# HAP Actions work like this:
-#  Simics sets bits in HAP regs (below)
-#  Action will set status bit in THREADSTATE
-#  Changes to THREADSTATE regspace will update status bits in Scom regs
-
-# Each bit represents the state of a given core/thread, and the bit 
-# position is computed as:
-#
-#  bit = core * threadsPerCore + thread
-#
-#0xFF000020, 64       # ADDR_LOGIC_THREAD_BREAKPOINT
-#0xFF000030, 64       # ADDR_LOGIC_THREAD_NAP
-#0xFF000040, 64       # ADDR_LOGIC_THREAD_SLEEP
-#0xFF000050, 64       # ADDR_LOGIC_THREAD_SRESET
-#0xFF000060, 64       # ADDR_LOGIC_THREAD_WINKLE     
-
-#### Winkle ####
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c1t0]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[8]
-  EFFECT: TARGET=[THREADSTATE(0x11000000)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x11000000)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c1t1]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[9]
-  EFFECT: TARGET=[THREADSTATE(0x11000001)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x11000001)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c1t2]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[10]
-  EFFECT: TARGET=[THREADSTATE(0x11000002)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x11000002)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c1t3]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[11]
-  EFFECT: TARGET=[THREADSTATE(0x11000003)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x11000003)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c1t4]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[12]
-  EFFECT: TARGET=[THREADSTATE(0x11000004)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x11000004)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c1t5]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[13]
-  EFFECT: TARGET=[THREADSTATE(0x11000005)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x11000005)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c1t6]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[14]
-  EFFECT: TARGET=[THREADSTATE(0x11000006)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x11000006)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c1t7]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[15]
-  EFFECT: TARGET=[THREADSTATE(0x11000007)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x11000007)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c2t0]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[16]
-  EFFECT: TARGET=[THREADSTATE(0x12000000)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x12000000)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c2t1]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[17]
-  EFFECT: TARGET=[THREADSTATE(0x12000001)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x12000001)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c2t2]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[18]
-  EFFECT: TARGET=[THREADSTATE(0x12000002)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x12000002)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c2t3]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[19]
-  EFFECT: TARGET=[THREADSTATE(0x12000003)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x12000003)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c2t4]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[20]
-  EFFECT: TARGET=[THREADSTATE(0x12000004)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x12000004)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c2t5]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[21]
-  EFFECT: TARGET=[THREADSTATE(0x12000005)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x12000005)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c2t6]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[22]
-  EFFECT: TARGET=[THREADSTATE(0x12000006)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x12000006)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c2t7]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[23]
-  EFFECT: TARGET=[THREADSTATE(0x12000007)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x12000007)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c3t0]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[24]
-  EFFECT: TARGET=[THREADSTATE(0x13000000)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x13000000)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c3t1]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[25]
-  EFFECT: TARGET=[THREADSTATE(0x13000001)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x13000001)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c3t2]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[26]
-  EFFECT: TARGET=[THREADSTATE(0x13000002)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x13000002)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c3t3]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[27]
-  EFFECT: TARGET=[THREADSTATE(0x13000003)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x13000003)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c3t4]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[28]
-  EFFECT: TARGET=[THREADSTATE(0x13000004)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x13000004)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c3t5]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[29]
-  EFFECT: TARGET=[THREADSTATE(0x13000005)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x13000005)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c3t6]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[30]
-  EFFECT: TARGET=[THREADSTATE(0x13000006)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x13000006)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c3t7]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[31]
-  EFFECT: TARGET=[THREADSTATE(0x13000007)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x13000007)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c4t0]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[32]
-  EFFECT: TARGET=[THREADSTATE(0x14000000)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x14000000)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c4t1]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[33]
-  EFFECT: TARGET=[THREADSTATE(0x14000001)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x14000001)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c4t2]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[34]
-  EFFECT: TARGET=[THREADSTATE(0x14000002)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x14000002)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c4t3]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[35]
-  EFFECT: TARGET=[THREADSTATE(0x14000003)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x14000003)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c4t4]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[36]
-  EFFECT: TARGET=[THREADSTATE(0x14000004)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x14000004)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c4t5]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[37]
-  EFFECT: TARGET=[THREADSTATE(0x14000005)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x14000005)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c4t6]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[38]
-  EFFECT: TARGET=[THREADSTATE(0x14000006)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x14000006)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c4t7]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[39]
-  EFFECT: TARGET=[THREADSTATE(0x14000007)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x14000007)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c5t0]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[40]
-  EFFECT: TARGET=[THREADSTATE(0x15000000)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x15000000)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c5t1]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[41]
-  EFFECT: TARGET=[THREADSTATE(0x15000001)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x15000001)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c5t2]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[42]
-  EFFECT: TARGET=[THREADSTATE(0x15000002)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x15000002)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c5t3]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[43]
-  EFFECT: TARGET=[THREADSTATE(0x15000003)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x15000003)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c5t4]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[44]
-  EFFECT: TARGET=[THREADSTATE(0x15000004)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x15000004)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c5t5]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[45]
-  EFFECT: TARGET=[THREADSTATE(0x15000005)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x15000005)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c5t6]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[46]
-  EFFECT: TARGET=[THREADSTATE(0x15000006)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x15000006)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c5t7]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[47]
-  EFFECT: TARGET=[THREADSTATE(0x15000007)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x15000007)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c6t0]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[48]
-  EFFECT: TARGET=[THREADSTATE(0x16000000)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x16000000)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c6t1]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[49]
-  EFFECT: TARGET=[THREADSTATE(0x16000001)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x16000001)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c6t2]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[50]
-  EFFECT: TARGET=[THREADSTATE(0x16000002)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x16000002)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c6t3]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[51]
-  EFFECT: TARGET=[THREADSTATE(0x16000003)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x16000003)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c6t4]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[52]
-  EFFECT: TARGET=[THREADSTATE(0x16000004)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x16000004)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c6t5]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[53]
-  EFFECT: TARGET=[THREADSTATE(0x16000005)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x16000005)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c6t6]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[54]
-  EFFECT: TARGET=[THREADSTATE(0x16000006)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x16000006)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-CAUSE_EFFECT {
-  LABEL=[HAP - Winkle - c6t7]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[55]
-  EFFECT: TARGET=[THREADSTATE(0x16000007)] OP=[BIT,ON]  BIT=[7] #winkle=1
-  ELSE: TARGET=[THREADSTATE(0x16000007)] OP=[BIT,OFF]  BIT=[7] #winkle=0
-}
-
-
-#### Active ####
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c1t0]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[8] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[8] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[8] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x11000000)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x11000000)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c1t1]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[9] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[9] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[9] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x11000001)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x11000001)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c1t2]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[10] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[10] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[10] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x11000002)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x11000002)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c1t3]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[11] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[11] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[11] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x11000003)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x11000003)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c1t4]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[12] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[12] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[12] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x11000004)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x11000004)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c1t5]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[13] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[13] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[13] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x11000005)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x11000005)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c1t6]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[14] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[14] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[14] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x11000006)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x11000006)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c1t7]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[15] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[15] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[15] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x11000007)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x11000007)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c2t0]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[16] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[16] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[16] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x12000000)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x12000000)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c2t1]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[17] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[17] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[17] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x12000001)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x12000001)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c2t2]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[18] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[18] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[18] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x12000002)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x12000002)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c2t3]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[19] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[19] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[19] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x12000003)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x12000003)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c2t4]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[20] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[20] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[20] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x12000004)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x12000004)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c2t5]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[21] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[21] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[21] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x12000005)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x12000005)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c2t6]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[22] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[22] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[22] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x12000006)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x12000006)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c2t7]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[23] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[23] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[23] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x12000007)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x12000007)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c3t0]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[24] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[24] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[24] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x13000000)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x13000000)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c3t1]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[25] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[25] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[25] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x13000001)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x13000001)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c3t2]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[26] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[26] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[26] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x13000002)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x13000002)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c3t3]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[27] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[27] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[27] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x13000003)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x13000003)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c3t4]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[28] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[28] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[28] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x13000004)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x13000004)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c3t5]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[29] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[29] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[29] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x13000005)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x13000005)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c3t6]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[30] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[30] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[30] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x13000006)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x13000006)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c3t7]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[31] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[31] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[31] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x13000007)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x13000007)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c4t0]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[32] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[32] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[32] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x14000000)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x14000000)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c4t1]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[33] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[33] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[33] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x14000001)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x14000001)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c4t2]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[34] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[34] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[34] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x14000002)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x14000002)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c4t3]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[35] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[35] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[35] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x14000003)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x14000003)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c4t4]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[36] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[36] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[36] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x14000004)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x14000004)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c4t5]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[37] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[37] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[37] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x14000005)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x14000005)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c4t6]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[38] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[38] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[38] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x14000006)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x14000006)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c4t7]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[39] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[39] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[39] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x14000007)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x14000007)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c5t0]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[40] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[40] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[40] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x15000000)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x15000000)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c5t1]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[41] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[41] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[41] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x15000001)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x15000001)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c5t2]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[42] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[42] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[42] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x15000002)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x15000002)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c5t3]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[43] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[43] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[43] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x15000003)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x15000003)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c5t4]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[44] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[44] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[44] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x15000004)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x15000004)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c5t5]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[45] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[45] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[45] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x15000005)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x15000005)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c5t6]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[46] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[46] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[46] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x15000006)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x15000006)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c5t7]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[47] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[47] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[47] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x15000007)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x15000007)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c6t0]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[48] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[48] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[48] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x16000000)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x16000000)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c6t1]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[49] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[49] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[49] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x16000001)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x16000001)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c6t2]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[50] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[50] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[50] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x16000002)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x16000002)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c6t3]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[51] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[51] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[51] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x16000003)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x16000003)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c6t4]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[52] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[52] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[52] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x16000004)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x16000004)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c6t5]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[53] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[53] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[53] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x16000005)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x16000005)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c6t6]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[54] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[54] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[54] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x16000006)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x16000006)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-CAUSE_EFFECT {
-  LABEL=[HAP - Active - c6t7]
-  WATCH=[LOGIC(0xFF000030)]
-  WATCH=[LOGIC(0xFF000050)]
-  WATCH=[LOGIC(0xFF000060)]
-  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,OFF]  BIT=[55] #no winkle
-  CAUSE: TARGET=[LOGIC(0xFF000030)] OP=[BIT,OFF]  BIT=[55] #no nap
-  CAUSE: TARGET=[LOGIC(0xFF000050)] OP=[BIT,OFF]  BIT=[55] #no sleep
-  EFFECT: TARGET=[THREADSTATE(0x16000007)] OP=[BIT,ON] BIT=[4] #active=1
-  ELSE: TARGET=[THREADSTATE(0x16000007)] OP=[BIT,OFF] BIT=[4] #active=0
-}
-
-
-
-#### Sreset ####
-#CAUSE_EFFECT {
-#  LABEL=[HAP - Sreset - c5t0]
-#  WATCH=[LOGIC(0xFF000050)]
-#  CAUSE: TARGET=[LOGIC(0xFF000060)] OP=[BIT,ON]  BIT=[40] #c5t0
-#  EFFECT: TARGET=[THREADSTATE(0x15000000)] OP=[BIT,ON]  BIT=[4] #active=1
-#  EFFECT: TARGET=[THREADSTATE(0x15000000)] OP=[BIT,OFF] BIT=[5] #nap=0
-#  EFFECT: TARGET=[THREADSTATE(0x15000000)] OP=[BIT,OFF] BIT=[6] #sleep=0
-#  EFFECT: TARGET=[THREADSTATE(0x15000000)] OP=[BIT,OFF] BIT=[7] #winkle=0
-#}
-
-##########################################
-# SBE Master Winkle Wakeup
-CAUSE_EFFECT CHIPLETS ex {
-  LABEL=[Master Winkle Wakeup]
-  WATCH=[THREADSTATE(MYCHIPLET,0x0)]
-  WATCH=[THREADSTATE(MYCHIPLET,0x1)]
-  WATCH=[THREADSTATE(MYCHIPLET,0x2)]
-  WATCH=[THREADSTATE(MYCHIPLET,0x3)]
-  WATCH=[THREADSTATE(MYCHIPLET,0x4)]
-  WATCH=[THREADSTATE(MYCHIPLET,0x5)]
-  WATCH=[THREADSTATE(MYCHIPLET,0x6)]
-  WATCH=[THREADSTATE(MYCHIPLET,0x7)]
-  # active=0,nap=0,sleep=0,winkle=1 on all 8 threads
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x0)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x1)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x2)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x3)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x4)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x5)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x6)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x7)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,01000000)] MASK=[LITERAL(32,0F000000)]
-  # check that substep_deadman_start program is running in SBE  @todo: Hostboot RTC:41412
-  #CAUSE: TARGET=[FSIMBOX(0x1C)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(64,0000F012 00000000)] MASK=[LITERAL(64,0000FFFF 00000000)]
-  # Restore LPCR for wake-up options.
-  EFFECT: TARGET=[PROCREG(lpcr, MYCORE, 0)] OP=[BIT,ON] BIT=[49]
-  EFFECT: TARGET=[PROCREG(lpcr, MYCORE, 1)] OP=[BIT,ON] BIT=[49]
-  EFFECT: TARGET=[PROCREG(lpcr, MYCORE, 2)] OP=[BIT,ON] BIT=[49]
-  EFFECT: TARGET=[PROCREG(lpcr, MYCORE, 3)] OP=[BIT,ON] BIT=[49]
-  EFFECT: TARGET=[PROCREG(lpcr, MYCORE, 4)] OP=[BIT,ON] BIT=[49]
-  EFFECT: TARGET=[PROCREG(lpcr, MYCORE, 5)] OP=[BIT,ON] BIT=[49]
-  EFFECT: TARGET=[PROCREG(lpcr, MYCORE, 6)] OP=[BIT,ON] BIT=[49]
-  EFFECT: TARGET=[PROCREG(lpcr, MYCORE, 7)] OP=[BIT,ON] BIT=[49]
-  # Clear Timebase (to simulate core losing state).
-  EFFECT: TARGET=[PROCREG(tb, MYCORE, 0)] OP=[EQUALTO,BUF] DATA=[LITERAL(64,00000000 00000000)]
-  # Send IPI to thread
-  EFFECT: TARGET=[MODULE(interProcessorInterrupt, MYCORE, 0 )] OP=[MODULECALL]
-  EFFECT: TARGET=[MODULE(interProcessorInterrupt, MYCORE, 1 )] OP=[MODULECALL]
-  EFFECT: TARGET=[MODULE(interProcessorInterrupt, MYCORE, 2 )] OP=[MODULECALL]
-  EFFECT: TARGET=[MODULE(interProcessorInterrupt, MYCORE, 3 )] OP=[MODULECALL]
-  EFFECT: TARGET=[MODULE(interProcessorInterrupt, MYCORE, 4 )] OP=[MODULECALL]
-  EFFECT: TARGET=[MODULE(interProcessorInterrupt, MYCORE, 5 )] OP=[MODULECALL]
-  EFFECT: TARGET=[MODULE(interProcessorInterrupt, MYCORE, 6 )] OP=[MODULECALL]
-  EFFECT: TARGET=[MODULE(interProcessorInterrupt, MYCORE, 7 )] OP=[MODULECALL]
-  EFFECT: TARGET=[THREADSTATE(MYCHIPLET,0x0)] OP=[BIT,OFF] BIT=[7]
-}
-
-#@01 end
diff --git a/src/build/citest/etc/patches/p8_inst.act.patch b/src/build/citest/etc/patches/p8_inst.act.patch
new file mode 100644
index 000000000..45277789f
--- /dev/null
+++ b/src/build/citest/etc/patches/p8_inst.act.patch
@@ -0,0 +1,130 @@
+--- p8_inst.act.old	2012-08-30 16:03:15.000000000 -0500
++++ p8_inst.act	2012-08-30 16:09:54.000000000 -0500
+@@ -231,6 +231,7 @@
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,ON]  BIT=[12] #PTC_RAS_STAT_INST_COMP
+ }
+ 
+ CAUSE_EFFECT CHIPLETS ex {
+@@ -244,6 +245,7 @@
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,ON]  BIT=[12] #PTC_RAS_STAT_INST_COMP  
+ }
+ 
+ CAUSE_EFFECT CHIPLETS ex {
+@@ -257,6 +259,7 @@
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,ON]  BIT=[12] #PTC_RAS_STAT_INST_COMP  
+ }
+ 
+ CAUSE_EFFECT CHIPLETS ex {
+@@ -270,6 +273,7 @@
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,ON]  BIT=[12] #PTC_RAS_STAT_INST_COMP
+ }
+ 
+ CAUSE_EFFECT CHIPLETS ex {
+@@ -283,6 +287,7 @@
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,ON]  BIT=[12] #PTC_RAS_STAT_INST_COMP
+ }
+ 
+ CAUSE_EFFECT CHIPLETS ex {
+@@ -296,6 +301,7 @@
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,ON]  BIT=[12] #PTC_RAS_STAT_INST_COMP
+ }
+ 
+ CAUSE_EFFECT CHIPLETS ex {
+@@ -309,6 +315,7 @@
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,ON]  BIT=[12] #PTC_RAS_STAT_INST_COMP  
+ }
+ 
+ CAUSE_EFFECT CHIPLETS ex {
+@@ -322,6 +329,7 @@
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,OFF] BIT=[50] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,ON]  BIT=[51] #RUN=0b0010
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,OFF] BIT=[52] #RUN=0b0010
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,ON]  BIT=[12] #PTC_RAS_STAT_INST_COMP  
+ }
+ 
+ ##### Active #####
+@@ -508,6 +516,7 @@
+   # maintmode=1, running=0
+   CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x0)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,OFF] BIT=[12] #PTC_RAS_STAT_INST_COMP
+   ELSE: TARGET=[REG(MYCHIPLET,0x013002)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
+ }
+ 
+@@ -518,6 +527,7 @@
+   # maintmode=1, running=0
+   CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x1)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,OFF] BIT=[12] #PTC_RAS_STAT_INST_COMP    
+   ELSE: TARGET=[REG(MYCHIPLET,0x013012)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
+ }
+ 
+@@ -528,6 +538,7 @@
+   # maintmode=1, running=0
+   CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x2)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,OFF] BIT=[12] #PTC_RAS_STAT_INST_COMP  
+   ELSE: TARGET=[REG(MYCHIPLET,0x013022)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
+ }
+ 
+@@ -538,6 +549,7 @@
+   # maintmode=1, running=0
+   CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x3)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,OFF] BIT=[12] #PTC_RAS_STAT_INST_COMP    
+   ELSE: TARGET=[REG(MYCHIPLET,0x013032)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
+ }
+ 
+@@ -548,6 +560,7 @@
+   # maintmode=1, running=0
+   CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x4)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,OFF] BIT=[12] #PTC_RAS_STAT_INST_COMP    
+   ELSE: TARGET=[REG(MYCHIPLET,0x013042)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
+ }
+ 
+@@ -558,6 +571,7 @@
+   # maintmode=1, running=0
+   CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x5)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,OFF] BIT=[12] #PTC_RAS_STAT_INST_COMP    
+   ELSE: TARGET=[REG(MYCHIPLET,0x013052)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
+ }
+ 
+@@ -568,6 +582,7 @@
+   # maintmode=1, running=0
+   CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x6)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,OFF] BIT=[12] #PTC_RAS_STAT_INST_COMP    
+   ELSE: TARGET=[REG(MYCHIPLET,0x013062)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
+ }
+ 
+@@ -578,6 +593,7 @@
+   # maintmode=1, running=0
+   CAUSE: TARGET=[THREADSTATE(MYCHIPLET,0x7)] OP=[EQUALTO,BUF,MASK] DATA=[LITERAL(32,10000000)] MASK=[LITERAL(32,30000000)]
+   EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,ON] BIT=[21]  #core_is_in_maintenance_mode
++  EFFECT: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,OFF] BIT=[12] #PTC_RAS_STAT_INST_COMP  
+   ELSE: TARGET=[REG(MYCHIPLET,0x013072)] OP=[BIT,OFF] BIT=[21]  #core_is_in_maintenance_mode
+ }
+ 
diff --git a/src/build/citest/etc/patches/patchlist.txt b/src/build/citest/etc/patches/patchlist.txt
index 4cdb8d248..b16f1ec2f 100644
--- a/src/build/citest/etc/patches/patchlist.txt
+++ b/src/build/citest/etc/patches/patchlist.txt
@@ -5,8 +5,8 @@ Brief description of the problem or reason for patch
 -Files: list of files		
 -Coreq: list of associated changes, e.g. workarounds.presimsetup
 
-New actions for master-winkle wakeup
+New actions for real proc_thread_control
 -RTC: Task 43959 will remove the patches
--CMVC: D846452 is integrating the changes
--Files: p8_inst.act
+-CMVC: D851143 is integrating the changes
+-Files: p8_inst.act.patch
 -Coreq: there are related changes in workarounds.postsimsetup
diff --git a/src/build/citest/etc/workarounds.postsimsetup b/src/build/citest/etc/workarounds.postsimsetup
index 2ff683e94..0fd3b3d67 100755
--- a/src/build/citest/etc/workarounds.postsimsetup
+++ b/src/build/citest/etc/workarounds.postsimsetup
@@ -1,34 +1,34 @@
 #!/bin/sh
-#  IBM_PROLOG_BEGIN_TAG
-#  This is an automatically generated prolog.
-#
-#  $Source: src/build/citest/etc/workarounds.postsimsetup $
-#
-#  IBM CONFIDENTIAL
-#
-#  COPYRIGHT International Business Machines Corp. 2011-2012
-#
-#  p1
-#
-#  Object Code Only (OCO) source materials
-#  Licensed Internal Code Source Materials
-#  IBM HostBoot Licensed Internal Code
-#
-#  The source code for this program is not published or other-
-#  wise divested of its trade secrets, irrespective of what has
-#  been deposited with the U.S. Copyright Office.
-#
-#  Origin: 30
-#
-#  IBM_PROLOG_END_TAG
+# IBM_PROLOG_BEGIN_TAG 
+# This is an automatically generated prolog. 
+#  
+# $Source: src/build/citest/etc/workarounds.postsimsetup $ 
+#  
+# IBM CONFIDENTIAL 
+#  
+# COPYRIGHT International Business Machines Corp. 2011,2012 
+#  
+# p1 
+#  
+# Object Code Only (OCO) source materials 
+# Licensed Internal Code Source Materials 
+# IBM HostBoot Licensed Internal Code 
+#  
+# The source code for this program is not published or otherwise 
+# divested of its trade secrets, irrespective of what has been 
+# deposited with the U.S. Copyright Office. 
+#  
+# Origin: 30 
+#  
+# IBM_PROLOG_END_TAG 
 ##
 ## Workarounds that are run after start_simics is executed for the first time
 ##    to setup the sandbox
 ##
 
 ### Updates to handle instruction states (Remove with RTC:43959)
-echo "+++ Update cec-chip files for master-winkle wakeup"
+echo "+++ Update cec-chip files for inst-start fix."
 mkdir -p $sb/simu/data/cec-chip/
-
-cp $HOSTBOOTROOT/src/build/citest/etc/patches/p8_inst.act $sb/simu/data/cec-chip/
+cp $bb/src/simu/data/cec-chip/p8_inst.act $sb/simu/data/cec-chip/p8_inst.act
+patch -p0 $sb/simu/data/cec-chip/p8_inst.act $HOSTBOOTROOT/src/build/citest/etc/patches/p8_inst.act.patch
 ###
diff --git a/src/kernel/start.S b/src/kernel/start.S
index e8b19b4f5..048c2411e 100644
--- a/src/kernel/start.S
+++ b/src/kernel/start.S
@@ -1,48 +1,26 @@
-# IBM_PROLOG_BEGIN_TAG 
-# This is an automatically generated prolog. 
-#  
-# $Source: src/kernel/start.S $ 
-#  
-# IBM CONFIDENTIAL 
-#  
-# COPYRIGHT International Business Machines Corp. 2010,2012 
-#  
-# p1 
-#  
-# Object Code Only (OCO) source materials 
-# Licensed Internal Code Source Materials 
-# IBM HostBoot Licensed Internal Code 
-#  
-# The source code for this program is not published or otherwise 
-# divested of its trade secrets, irrespective of what has been 
-# deposited with the U.S. Copyright Office. 
-#  
-# Origin: 30 
-#  
-# IBM_PROLOG_END_TAG 
-/*  IBM_PROLOG_BEGIN_TAG
- *  This is an automatically generated prolog.
- *
- *  $Source: src/kernel/start.S $
- *
- *  IBM CONFIDENTIAL
- *
- *  COPYRIGHT International Business Machines Corp. 2010-2012
- *
- *  p1
- *
- *  Object Code Only (OCO) source materials
- *  Licensed Internal Code Source Materials
- *  IBM HostBoot Licensed Internal Code
- *
- *  The source code for this program is not published or other-
- *  wise divested of its trade secrets, irrespective of what has
- *  been deposited with the U.S. Copyright Office.
- *
- *  Origin: 30
- *
- *  IBM_PROLOG_END_TAG
- */
+# IBM_PROLOG_BEGIN_TAG
+# This is an automatically generated prolog.
+#
+# $Source: src/kernel/start.S $
+#
+# IBM CONFIDENTIAL
+#
+# COPYRIGHT International Business Machines Corp. 2010,2012
+#
+# p1
+#
+# Object Code Only (OCO) source materials
+# Licensed Internal Code Source Materials
+# IBM HostBoot Licensed Internal Code
+#
+# The source code for this program is not published or otherwise
+# divested of its trade secrets, irrespective of what has been
+# deposited with the U.S. Copyright Office.
+#
+# Origin: 30
+#
+# IBM_PROLOG_END_TAG
+
 .include "kernel/ppcconsts.S"
 
 .section .text.intvects
@@ -52,10 +30,11 @@ _start:
     ;// Set thread priority high.
     or 2,2,2
 
-    ;// Clear MSR[TA] (bit 63).
+    ;// Clear MSR[TA] (bit 1) and MSR[ME] (bit 51).
     mfmsr r2
-    rldicl r2,r2,1,1
-    rotldi r2,r2,63
+    rldicl r2,r2,1,1    ;// Clear bit 1  - result [1-63,0]
+    rldicl r2,r2,50,1   ;// Clear bit 51 - result [51-63,0-50]
+    rldicl r2,r2,13,0   ;// Rotate around back to [0-63]
     ;// Set up SRR0 / SRR1 to enable new MSR.
     mtsrr1 r2
     li r2, _start_postmsr@l
@@ -646,8 +625,15 @@ intvect_system_reset_inactive:
 
     ;// @fn intvect_system_reset_decrementer
     ;// Handle SRESET due to decrementer wake-up.
-    ;//     This is a wake-up from 'nap'.  Clear priviledge escalation and
-    ;//     perform decrementer.
+    ;//     This is a wake-up from 'nap'.
+    ;//
+    ;//     When entering nap, all thread-state is lost (GPRs, etc).  In order
+    ;//     to execute nap the task had to first make a system call to raise
+    ;//     priviledge which has the side effect of saving state in the task
+    ;//     struct.  None of the state can be changed by the nap instruction
+    ;//     itself.  Therefore, we need to remove priviledge escalation,
+    ;//     increment the NIA (past the nap instruction), and execute the
+    ;//     post-task-save portion of the decrementer vector.
 intvect_system_reset_decrementer:
     ;// Clear MSR mask, since privilaged instruction was now executed (nap).
     mfsprg3 r1  ;// Load task structure to r1.
@@ -655,15 +641,16 @@ intvect_system_reset_decrementer:
     std r2, TASK_MSR_MASK(r1) ;// Zero msr_mask.
 
     ;// Advance saved NIA (past nap).
-    mfsrr0 r1
-    addi r1, r1, 4
-    mtsrr0 r1
+    ld r2, TASK_NIP(r1)
+    addi r2, r2, 4
+    std r2, TASK_NIP(r1)
 
-    ;// Restore save registers.
-    mfsprg0 r1
-    mfsprg1 r2
+    ;// Restore kernel stack.
+    ld r1, TASK_CPUPTR(r1)	;// Get CPU pointer
+    ld r1, CPU_KERNEL_STACK(r1)	;// Get kernel stack pointer.
 
-    b intvect_decrementer
+    ;// Jump to post-save portion of decrementer.
+    b intvect_decrementer_finish_save
 
     ;// @fn intvect_system_reset_external
     ;// Handle SRESET due to wake-up from external interrupt.
diff --git a/src/sys/prof/idletask.C b/src/sys/prof/idletask.C
index 1c38835ce..8f79b94f7 100644
--- a/src/sys/prof/idletask.C
+++ b/src/sys/prof/idletask.C
@@ -43,8 +43,7 @@ void TaskManager::idleTaskLoop(void* unused)
         setThreadPriorityLow();
 
         // Request privilege escalation for nap.
-        register uint64_t syscall = MISC_CPUNAP;
-        asm volatile("or 3, %0, %0; sc" :: "r" (syscall) : "r3", "cc");
+        asm volatile("li 3, %0; sc" :: "K" (MISC_CPUNAP) : "r3", "cc");
 
         // Execute nap.
         nap();
diff --git a/src/usr/hwpf/hwp/thread_activate/thread_activate.C b/src/usr/hwpf/hwp/thread_activate/thread_activate.C
index 72a36bbbf..c8f418f35 100644
--- a/src/usr/hwpf/hwp/thread_activate/thread_activate.C
+++ b/src/usr/hwpf/hwp/thread_activate/thread_activate.C
@@ -61,7 +61,7 @@ void activate_threads( errlHndl_t& io_rtaskRetErrl )
 {
     errlHndl_t  l_errl  =   NULL;
 
-    TRACFCOMP( g_fapiTd, 
+    TRACFCOMP( g_fapiTd,
                "activate_threads entry" );
 
     // get the master processor target
@@ -71,7 +71,7 @@ void activate_threads( errlHndl_t& io_rtaskRetErrl )
     {
         TRACFCOMP( g_fapiImpTd,
                    "Could not find master proc!!!" );
-        assert(false);        
+        assert(false);
     }
 
     // get the list of core targets for this proc chip
@@ -88,8 +88,8 @@ void activate_threads( errlHndl_t& io_rtaskRetErrl )
     task_affinity_unpin();
 
     //NNNCCCPPPPTTT
-    uint64_t l_masterCoreID = (cpuid & 0x0078)>>3; 
-    uint64_t l_masterThreadID = (cpuid & 0x0007);    
+    uint64_t l_masterCoreID = (cpuid & 0x0078)>>3;
+    uint64_t l_masterThreadID = (cpuid & 0x0007);
 
     TARGETING::Target* l_masterCore = NULL;
     for( TARGETING::TargetHandleList::iterator core_it
@@ -106,7 +106,7 @@ void activate_threads( errlHndl_t& io_rtaskRetErrl )
     }
     if( l_masterCore == NULL )
     {
-        TRACFCOMP( g_fapiImpTd, 
+        TRACFCOMP( g_fapiImpTd,
                    "Could not find a target for core %d",
                    l_masterCoreID );
         /*@
@@ -130,7 +130,7 @@ void activate_threads( errlHndl_t& io_rtaskRetErrl )
         return;
     }
 
-    TRACFCOMP( g_fapiTd, 
+    TRACFCOMP( g_fapiTd,
                "Master CPU : c%d t%d (HUID=%.8X)",
                l_masterCoreID, l_masterThreadID, TARGETING::get_huid(l_masterCore) );
 
@@ -157,7 +157,7 @@ void activate_threads( errlHndl_t& io_rtaskRetErrl )
         }
 
         // send a magic instruction for PHYP Simics to work...
-        MAGIC_INSTRUCTION(MAGIC_SIMICS_CORESTATESAVE);       
+        MAGIC_INSTRUCTION(MAGIC_SIMICS_CORESTATESAVE);
 
         //@todo - call the real proc_thread_control HWP  (RTC:42816)
 #if 0
@@ -184,7 +184,7 @@ void activate_threads( errlHndl_t& io_rtaskRetErrl )
                          l_threadState ); //o_thread_state
         if ( l_errl )
         {
-            TRACFCOMP( g_fapiImpTd, 
+            TRACFCOMP( g_fapiImpTd,
                        "ERROR: 0x%.8X :  proc_thread_control HWP( cpu %d, thread %d )",
                        l_errl->reasonCode(),
                        l_masterCoreID,
@@ -195,7 +195,7 @@ void activate_threads( errlHndl_t& io_rtaskRetErrl )
         }
         else
         {
-            TRACFCOMP( g_fapiTd, 
+            TRACFCOMP( g_fapiTd,
                        "SUCCESS: 0x%.8X :  proc_thread_control HWP( cpu %d, thread %d )",
                        l_errl->reasonCode(),
                        l_masterCoreID,
@@ -218,7 +218,7 @@ void activate_threads( errlHndl_t& io_rtaskRetErrl )
         // Make sure the thread is in maintenance mode
         if( !(statreg & 0x0000040000000000) ) //21:PTC_RAS_STAT_MAINT
         {
-            TRACFCOMP( g_fapiImpTd, 
+            TRACFCOMP( g_fapiImpTd,
                        "ERROR: Thread c%d t%d is in the wrong state : Status=%.16X",
                        l_masterCoreID,
                        thread,
@@ -258,9 +258,9 @@ void activate_threads( errlHndl_t& io_rtaskRetErrl )
                              DEVICE_SCOM_ADDRESS(rasStatAddr) );
         if( l_errl ) { break; }
 
-        if( !(statreg & 0x0000000000001000) ) //51:PTC_RAS_STAT_RUN_BIT
+        if( !(statreg & 0x0008000000000000) ) //12:PTC_RAS_STAT_INST_COMP
         {
-            TRACFCOMP( g_fapiImpTd, 
+            TRACFCOMP( g_fapiImpTd,
                        "ERROR: Thread c%d t%d did not start : Status=%.16X",
                        l_masterCoreID,
                        thread,
@@ -285,14 +285,14 @@ void activate_threads( errlHndl_t& io_rtaskRetErrl )
         }
 #endif
 
-        TRACFCOMP( g_fapiTd, 
+        TRACFCOMP( g_fapiTd,
                    "SUCCESS: Thread c%d t%d started",
                    l_masterCoreID,
                    thread );
 
     }
 
-    TRACFCOMP( g_fapiTd, 
+    TRACFCOMP( g_fapiTd,
                "activate_threads exit" );
 
     io_rtaskRetErrl = l_errl;