#######################################################################
# 201: SC1 LASER
record(stringin, "LMM:SYS0:201:NAME") {
    field(DESC, "201 mode name")
    field(VAL,  "201: SC1 LASER")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:201:CMD") {
    field(DESC, "201 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:201:YCMD_CALC") {
    field(DESC, "201 mode cmd yes calc")
    field(INPA, "LMM:SYS0:201:CMD CP MSS") 
    field(INPB, "LMM:SYS0:201:DES NPP MSS")
    field(INPC, "LMM:SYS0:201:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:201:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:201:NCMD_CALC") {
    field(DESC, "201 mode cmd no calc")
    field(INPA, "LMM:SYS0:201:CMD CP MSS")
    field(INPB, "LMM:SYS0:201:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:201:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:201:ACT") {
    field(DESC, "201 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:201:DES") {
    field(DESC, "201 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:201:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:201:PERMITTED") {
    field(DESC, "201 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:201:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:201:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:201:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:201:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:201:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:201:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:201:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "B||C||D||E||F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:201:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:201:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:201:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:201:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:201:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:201:RATE PP")
#}

#######################################################################
# 202: YAG01B
record(stringin, "LMM:SYS0:202:NAME") {
    field(DESC, "202 mode name")
    field(VAL,  "202: YAG01B")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:202:CMD") {
    field(DESC, "202 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:202:YCMD_CALC") {
    field(DESC, "202 mode cmd yes calc")
    field(INPA, "LMM:SYS0:202:CMD CP MSS") 
    field(INPB, "LMM:SYS0:202:DES NPP MSS")
    field(INPC, "LMM:SYS0:202:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:202:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:202:NCMD_CALC") {
    field(DESC, "202 mode cmd no calc")
    field(INPA, "LMM:SYS0:202:CMD CP MSS")
    field(INPB, "LMM:SYS0:202:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:202:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:202:ACT") {
    field(DESC, "202 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:202:DES") {
    field(DESC, "202 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:202:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:202:PERMITTED") {
    field(DESC, "202 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:202:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:202:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:202:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:202:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:202:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:202:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:202:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:202:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:202:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "A||C||D||E||F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:202:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:202:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:202:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:202:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:202:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:202:RATE PP")
#}

#######################################################################
# 203: SC1 TDINJ
record(stringin, "LMM:SYS0:203:NAME") {
    field(DESC, "203 mode name")
    field(VAL,  "203: SC1 TDINJ")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:203:CMD") {
    field(DESC, "203 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:203:YCMD_CALC") {
    field(DESC, "203 mode cmd yes calc")
    field(INPA, "LMM:SYS0:203:CMD CP MSS") 
    field(INPB, "LMM:SYS0:203:DES NPP MSS")
    field(INPC, "LMM:SYS0:203:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:203:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:203:NCMD_CALC") {
    field(DESC, "203 mode cmd no calc")
    field(INPA, "LMM:SYS0:203:CMD CP MSS")
    field(INPB, "LMM:SYS0:203:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:203:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:203:ACT") {
    field(DESC, "203 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:203:DES") {
    field(DESC, "203 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:203:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:203:PERMITTED") {
    field(DESC, "203 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:203:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:203:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:203:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:203:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:203:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:203:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:203:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:203:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:203:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "A||B||D||E||F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:203:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:203:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:203:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:203:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:203:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:203:RATE PP")
#}

#######################################################################
# 204: SC1 DIAG0
record(stringin, "LMM:SYS0:204:NAME") {
    field(DESC, "204 mode name")
    field(VAL,  "204: SC1 DIAG0")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:204:CMD") {
    field(DESC, "204 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:204:YCMD_CALC") {
    field(DESC, "204 mode cmd yes calc")
    field(INPA, "LMM:SYS0:204:CMD CP MSS") 
    field(INPB, "LMM:SYS0:204:DES NPP MSS")
    field(INPC, "LMM:SYS0:204:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:204:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:204:NCMD_CALC") {
    field(DESC, "204 mode cmd no calc")
    field(INPA, "LMM:SYS0:204:CMD CP MSS")
    field(INPB, "LMM:SYS0:204:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:204:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:204:ACT") {
    field(DESC, "204 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:204:DES") {
    field(DESC, "204 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:204:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:204:PERMITTED") {
    field(DESC, "204 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:204:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:204:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:204:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:204:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:204:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:204:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:204:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:204:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:204:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "A||B||C?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:204:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:204:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:204:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:204:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:204:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:204:RATE PP")
#}

#######################################################################
# 205: SC1 DUMPBSY
record(stringin, "LMM:SYS0:205:NAME") {
    field(DESC, "205 mode name")
    field(VAL,  "205: SC1 DUMPBSY")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:205:CMD") {
    field(DESC, "205 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:205:YCMD_CALC") {
    field(DESC, "205 mode cmd yes calc")
    field(INPA, "LMM:SYS0:205:CMD CP MSS") 
    field(INPB, "LMM:SYS0:205:DES NPP MSS")
    field(INPC, "LMM:SYS0:205:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:205:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:205:NCMD_CALC") {
    field(DESC, "205 mode cmd no calc")
    field(INPA, "LMM:SYS0:205:CMD CP MSS")
    field(INPB, "LMM:SYS0:205:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:205:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:205:ACT") {
    field(DESC, "205 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:205:DES") {
    field(DESC, "205 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:205:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:205:PERMITTED") {
    field(DESC, "205 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:205:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:205:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:205:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:205:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:205:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:205:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:205:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:205:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:205:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "A||B||C?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:205:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:205:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:205:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:205:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:205:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:205:RATE PP")
#}

#######################################################################
# 211: SC1 TDUNDHXR
record(stringin, "LMM:SYS0:211:NAME") {
    field(DESC, "211 mode name")
    field(VAL,  "211: SC1 TDUNDHXR")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:211:CMD") {
    field(DESC, "211 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:211:YCMD_CALC") {
    field(DESC, "211 mode cmd yes calc")
    field(INPA, "LMM:SYS0:211:CMD CP MSS") 
    field(INPB, "LMM:SYS0:211:DES NPP MSS")
    field(INPC, "LMM:SYS0:211:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:211:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:211:NCMD_CALC") {
    field(DESC, "211 mode cmd no calc")
    field(INPA, "LMM:SYS0:211:CMD CP MSS")
    field(INPB, "LMM:SYS0:211:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:211:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:211:ACT") {
    field(DESC, "211 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:211:DES") {
    field(DESC, "211 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:211:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:211:PERMITTED") {
    field(DESC, "211 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:211:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:211:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:211:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:211:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:211:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:211:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:211:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:211:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:211:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "A||B||C?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:211:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:211:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:211:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:211:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:211:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:211:RATE PP")
#}

#######################################################################
# 221: SC1 TDUNDSXR
record(stringin, "LMM:SYS0:221:NAME") {
    field(DESC, "221 mode name")
    field(VAL,  "221: SC1 TDUNDSXR")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:221:CMD") {
    field(DESC, "221 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:221:YCMD_CALC") {
    field(DESC, "221 mode cmd yes calc")
    field(INPA, "LMM:SYS0:221:CMD CP MSS") 
    field(INPB, "LMM:SYS0:221:DES NPP MSS")
    field(INPC, "LMM:SYS0:221:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:221:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:221:NCMD_CALC") {
    field(DESC, "221 mode cmd no calc")
    field(INPA, "LMM:SYS0:221:CMD CP MSS")
    field(INPB, "LMM:SYS0:221:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:221:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:221:ACT") {
    field(DESC, "221 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:221:DES") {
    field(DESC, "221 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:221:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:221:PERMITTED") {
    field(DESC, "221 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:221:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:221:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:221:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:221:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:221:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:221:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:221:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:221:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:221:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "A||B||C?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:221:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:221:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:221:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:221:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:221:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:221:RATE PP")
#}

#######################################################################
# 212: SC1 DUMPHXR
record(stringin, "LMM:SYS0:212:NAME") {
    field(DESC, "212 mode name")
    field(VAL,  "212: SC1 DUMPHXR")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:212:CMD") {
    field(DESC, "212 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:212:YCMD_CALC") {
    field(DESC, "212 mode cmd yes calc")
    field(INPA, "LMM:SYS0:212:CMD CP MSS") 
    field(INPB, "LMM:SYS0:212:DES NPP MSS")
    field(INPC, "LMM:SYS0:212:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:212:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:212:NCMD_CALC") {
    field(DESC, "212 mode cmd no calc")
    field(INPA, "LMM:SYS0:212:CMD CP MSS")
    field(INPB, "LMM:SYS0:212:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:212:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:212:ACT") {
    field(DESC, "212 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:212:DES") {
    field(DESC, "212 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:212:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:212:PERMITTED") {
    field(DESC, "212 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:212:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:212:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:212:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:212:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:212:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:212:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:212:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:212:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:212:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "A||B||C?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:212:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:212:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:212:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:212:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:212:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:212:RATE PP")
#}

#######################################################################
# 222: SC1 DUMPSXR
record(stringin, "LMM:SYS0:222:NAME") {
    field(DESC, "222 mode name")
    field(VAL,  "222: SC1 DUMPSXR")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:222:CMD") {
    field(DESC, "222 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:222:YCMD_CALC") {
    field(DESC, "222 mode cmd yes calc")
    field(INPA, "LMM:SYS0:222:CMD CP MSS") 
    field(INPB, "LMM:SYS0:222:DES NPP MSS")
    field(INPC, "LMM:SYS0:222:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:222:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:222:NCMD_CALC") {
    field(DESC, "222 mode cmd no calc")
    field(INPA, "LMM:SYS0:222:CMD CP MSS")
    field(INPB, "LMM:SYS0:222:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:222:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:222:ACT") {
    field(DESC, "222 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:222:DES") {
    field(DESC, "222 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:222:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:222:PERMITTED") {
    field(DESC, "222 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:222:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:222:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:222:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:222:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:222:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:222:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:222:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:222:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:222:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "A||B||C?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:222:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:222:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:222:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:222:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:222:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:222:RATE PP")
#}

#######################################################################
# 213: SC1 S30XL
record(stringin, "LMM:SYS0:213:NAME") {
    field(DESC, "213 mode name")
    field(VAL,  "213: SC1 S30XL")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:213:CMD") {
    field(DESC, "213 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:213:YCMD_CALC") {
    field(DESC, "213 mode cmd yes calc")
    field(INPA, "LMM:SYS0:213:CMD CP MSS") 
    field(INPB, "LMM:SYS0:213:DES NPP MSS")
    field(INPC, "LMM:SYS0:213:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:213:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:213:NCMD_CALC") {
    field(DESC, "213 mode cmd no calc")
    field(INPA, "LMM:SYS0:213:CMD CP MSS")
    field(INPB, "LMM:SYS0:213:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:213:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:213:ACT") {
    field(DESC, "213 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:213:DES") {
    field(DESC, "213 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:213:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:213:PERMITTED") {
    field(DESC, "213 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:213:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:213:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:213:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:213:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:213:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:213:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:213:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:213:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:213:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "A||B||C?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:213:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:213:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:213:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:213:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:213:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:213:RATE PP")
#}

#######################################################################
# 101: LASER
record(stringin, "LMM:SYS0:101:NAME") {
    field(DESC, "101 mode name")
    field(VAL,  "101: LASER")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:101:CMD") {
    field(DESC, "101 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:101:YCMD_CALC") {
    field(DESC, "101 mode cmd yes calc")
    field(INPA, "LMM:SYS0:101:CMD CP MSS") 
    field(INPB, "LMM:SYS0:101:DES NPP MSS")
    field(INPC, "LMM:SYS0:101:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:101:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:101:NCMD_CALC") {
    field(DESC, "101 mode cmd no calc")
    field(INPA, "LMM:SYS0:101:CMD CP MSS")
    field(INPB, "LMM:SYS0:101:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:101:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:101:ACT") {
    field(DESC, "101 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:101:DES") {
    field(DESC, "101 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:101:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:101:PERMITTED") {
    field(DESC, "101 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:101:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:101:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:101:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:101:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:101:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:101:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:101:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:101:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "B||C||D||E||F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:101:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:101:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:101:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:101:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:101:RATE PP")
#}

#######################################################################
# 102: YAG02
record(stringin, "LMM:SYS0:102:NAME") {
    field(DESC, "102 mode name")
    field(VAL,  "102: YAG02")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:102:CMD") {
    field(DESC, "102 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:102:YCMD_CALC") {
    field(DESC, "102 mode cmd yes calc")
    field(INPA, "LMM:SYS0:102:CMD CP MSS") 
    field(INPB, "LMM:SYS0:102:DES NPP MSS")
    field(INPC, "LMM:SYS0:102:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:102:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:102:NCMD_CALC") {
    field(DESC, "102 mode cmd no calc")
    field(INPA, "LMM:SYS0:102:CMD CP MSS")
    field(INPB, "LMM:SYS0:102:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:102:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:102:ACT") {
    field(DESC, "102 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:102:DES") {
    field(DESC, "102 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:102:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:102:PERMITTED") {
    field(DESC, "102 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:102:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:102:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:102:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:102:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:102:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:102:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:102:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:102:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:102:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:102:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||C||D||E||F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:102:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:102:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:102:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:102:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:102:RATE PP")
#}

#######################################################################
# 103: GUNSPEC
record(stringin, "LMM:SYS0:103:NAME") {
    field(DESC, "103 mode name")
    field(VAL,  "103: GUNSPEC")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:103:CMD") {
    field(DESC, "103 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:103:YCMD_CALC") {
    field(DESC, "103 mode cmd yes calc")
    field(INPA, "LMM:SYS0:103:CMD CP MSS") 
    field(INPB, "LMM:SYS0:103:DES NPP MSS")
    field(INPC, "LMM:SYS0:103:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:103:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:103:NCMD_CALC") {
    field(DESC, "103 mode cmd no calc")
    field(INPA, "LMM:SYS0:103:CMD CP MSS")
    field(INPB, "LMM:SYS0:103:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:103:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:103:ACT") {
    field(DESC, "103 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:103:DES") {
    field(DESC, "103 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:103:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:103:PERMITTED") {
    field(DESC, "103 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:103:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:103:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:103:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:103:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:103:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:103:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:103:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:103:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:103:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:103:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||D||E||F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:103:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:103:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:103:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:103:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:103:RATE PP")
#}

#######################################################################
# 104: SPEC1
record(stringin, "LMM:SYS0:104:NAME") {
    field(DESC, "104 mode name")
    field(VAL,  "104: SPEC1")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:104:CMD") {
    field(DESC, "104 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:104:YCMD_CALC") {
    field(DESC, "104 mode cmd yes calc")
    field(INPA, "LMM:SYS0:104:CMD CP MSS") 
    field(INPB, "LMM:SYS0:104:DES NPP MSS")
    field(INPC, "LMM:SYS0:104:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:104:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:104:NCMD_CALC") {
    field(DESC, "104 mode cmd no calc")
    field(INPA, "LMM:SYS0:104:CMD CP MSS")
    field(INPB, "LMM:SYS0:104:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:104:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:104:ACT") {
    field(DESC, "104 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:104:DES") {
    field(DESC, "104 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:104:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:104:PERMITTED") {
    field(DESC, "104 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:104:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:104:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:104:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:104:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:104:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:104:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:104:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:104:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:104:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:104:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||E||F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:104:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:104:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:104:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:104:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:104:RATE PP")
#}

#######################################################################
# 105: TD11
record(stringin, "LMM:SYS0:105:NAME") {
    field(DESC, "105 mode name")
    field(VAL,  "105: TD11")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:105:CMD") {
    field(DESC, "105 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:105:YCMD_CALC") {
    field(DESC, "105 mode cmd yes calc")
    field(INPA, "LMM:SYS0:105:CMD CP MSS") 
    field(INPB, "LMM:SYS0:105:DES NPP MSS")
    field(INPC, "LMM:SYS0:105:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:105:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:105:NCMD_CALC") {
    field(DESC, "105 mode cmd no calc")
    field(INPA, "LMM:SYS0:105:CMD CP MSS")
    field(INPB, "LMM:SYS0:105:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:105:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:105:ACT") {
    field(DESC, "105 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:105:DES") {
    field(DESC, "105 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:105:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:105:PERMITTED") {
    field(DESC, "105 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:105:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:105:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:105:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:105:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:105:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:105:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:105:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:105:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:105:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:105:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:105:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:105:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:105:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:105:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:105:RATE PP")
#}

#######################################################################
# 111: D2
record(stringin, "LMM:SYS0:111:NAME") {
    field(DESC, "111 mode name")
    field(VAL,  "111: D2")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:111:CMD") {
    field(DESC, "111 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:111:YCMD_CALC") {
    field(DESC, "111 mode cmd yes calc")
    field(INPA, "LMM:SYS0:111:CMD CP MSS") 
    field(INPB, "LMM:SYS0:111:DES NPP MSS")
    field(INPC, "LMM:SYS0:111:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:111:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:111:NCMD_CALC") {
    field(DESC, "111 mode cmd no calc")
    field(INPA, "LMM:SYS0:111:CMD CP MSS")
    field(INPB, "LMM:SYS0:111:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:111:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:111:ACT") {
    field(DESC, "111 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:111:DES") {
    field(DESC, "111 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:111:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:111:PERMITTED") {
    field(DESC, "111 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:111:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:111:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:111:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:111:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:111:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:111:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:111:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:111:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:111:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "F||H?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:111:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||G||H||I?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:111:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "D||E||F||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:111:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:111:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:111:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:111:RATE PP")
#}

#######################################################################
# 112: BYKIK
record(stringin, "LMM:SYS0:112:NAME") {
    field(DESC, "112 mode name")
    field(VAL,  "112: BYKIK")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:112:CMD") {
    field(DESC, "112 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:112:YCMD_CALC") {
    field(DESC, "112 mode cmd yes calc")
    field(INPA, "LMM:SYS0:112:CMD CP MSS") 
    field(INPB, "LMM:SYS0:112:DES NPP MSS")
    field(INPC, "LMM:SYS0:112:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:112:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:112:NCMD_CALC") {
    field(DESC, "112 mode cmd no calc")
    field(INPA, "LMM:SYS0:112:CMD CP MSS")
    field(INPB, "LMM:SYS0:112:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:112:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:112:ACT") {
    field(DESC, "112 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:112:DES") {
    field(DESC, "112 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:112:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:112:PERMITTED") {
    field(DESC, "112 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:112:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:112:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:112:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:112:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:112:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:112:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:112:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:112:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:112:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "F||H?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:112:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:112:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "D||E||F||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:112:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:112:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:112:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:112:RATE PP")
#}

#######################################################################
# 113: TDUNDHXR
record(stringin, "LMM:SYS0:113:NAME") {
    field(DESC, "113 mode name")
    field(VAL,  "113: TDUNDHXR")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:113:CMD") {
    field(DESC, "113 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:113:YCMD_CALC") {
    field(DESC, "113 mode cmd yes calc")
    field(INPA, "LMM:SYS0:113:CMD CP MSS") 
    field(INPB, "LMM:SYS0:113:DES NPP MSS")
    field(INPC, "LMM:SYS0:113:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:113:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:113:NCMD_CALC") {
    field(DESC, "113 mode cmd no calc")
    field(INPA, "LMM:SYS0:113:CMD CP MSS")
    field(INPB, "LMM:SYS0:113:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:113:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:113:ACT") {
    field(DESC, "113 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:113:DES") {
    field(DESC, "113 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:113:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:113:PERMITTED") {
    field(DESC, "113 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:113:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:113:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:113:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:113:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:113:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:113:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:113:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:113:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:113:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "F||H?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:113:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F||I?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:113:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "D||E||F||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:113:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:113:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:113:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:113:RATE PP")
#}

#######################################################################
# 114: DUMPHXR
record(stringin, "LMM:SYS0:114:NAME") {
    field(DESC, "114 mode name")
    field(VAL,  "114: DUMPHXR")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:114:CMD") {
    field(DESC, "114 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:114:YCMD_CALC") {
    field(DESC, "114 mode cmd yes calc")
    field(INPA, "LMM:SYS0:114:CMD CP MSS") 
    field(INPB, "LMM:SYS0:114:DES NPP MSS")
    field(INPC, "LMM:SYS0:114:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:114:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:114:NCMD_CALC") {
    field(DESC, "114 mode cmd no calc")
    field(INPA, "LMM:SYS0:114:CMD CP MSS")
    field(INPB, "LMM:SYS0:114:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:114:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:114:ACT") {
    field(DESC, "114 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:114:DES") {
    field(DESC, "114 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:114:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:114:PERMITTED") {
    field(DESC, "114 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:114:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:114:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:114:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:114:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:114:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:114:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:114:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:114:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:114:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "F||H?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:114:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F||H||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:114:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:114:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:114:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:114:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:114:RATE PP")
#}

#######################################################################
# 121: STCLTS
record(stringin, "LMM:SYS0:121:NAME") {
    field(DESC, "121 mode name")
    field(VAL,  "121: STCLTS")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:121:CMD") {
    field(DESC, "121 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:121:YCMD_CALC") {
    field(DESC, "121 mode cmd yes calc")
    field(INPA, "LMM:SYS0:121:CMD CP MSS") 
    field(INPB, "LMM:SYS0:121:DES NPP MSS")
    field(INPC, "LMM:SYS0:121:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:121:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:121:NCMD_CALC") {
    field(DESC, "121 mode cmd no calc")
    field(INPA, "LMM:SYS0:121:CMD CP MSS")
    field(INPB, "LMM:SYS0:121:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:121:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:121:ACT") {
    field(DESC, "121 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:121:DES") {
    field(DESC, "121 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:121:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:121:PERMITTED") {
    field(DESC, "121 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:121:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:121:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:121:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:121:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:121:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:121:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:121:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:121:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:121:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "F||H?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:121:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||I?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:121:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:121:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:121:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:121:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:121:RATE PP")
#}

#######################################################################
# 122: BYKIKS
record(stringin, "LMM:SYS0:122:NAME") {
    field(DESC, "122 mode name")
    field(VAL,  "122: BYKIKS")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:122:CMD") {
    field(DESC, "122 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:122:YCMD_CALC") {
    field(DESC, "122 mode cmd yes calc")
    field(INPA, "LMM:SYS0:122:CMD CP MSS") 
    field(INPB, "LMM:SYS0:122:DES NPP MSS")
    field(INPC, "LMM:SYS0:122:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:122:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:122:NCMD_CALC") {
    field(DESC, "122 mode cmd no calc")
    field(INPA, "LMM:SYS0:122:CMD CP MSS")
    field(INPB, "LMM:SYS0:122:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:122:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:122:ACT") {
    field(DESC, "122 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:122:DES") {
    field(DESC, "122 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:122:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:122:PERMITTED") {
    field(DESC, "122 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:122:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:122:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:122:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:122:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:122:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:122:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:122:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:122:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:122:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "D||E||F||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:122:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:122:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:122:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:122:RATE PP")
#}

#######################################################################
# 123: TDUNDSXR
record(stringin, "LMM:SYS0:123:NAME") {
    field(DESC, "123 mode name")
    field(VAL,  "123: TDUNDSXR")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:123:CMD") {
    field(DESC, "123 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:123:YCMD_CALC") {
    field(DESC, "123 mode cmd yes calc")
    field(INPA, "LMM:SYS0:123:CMD CP MSS") 
    field(INPB, "LMM:SYS0:123:DES NPP MSS")
    field(INPC, "LMM:SYS0:123:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:123:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:123:NCMD_CALC") {
    field(DESC, "123 mode cmd no calc")
    field(INPA, "LMM:SYS0:123:CMD CP MSS")
    field(INPB, "LMM:SYS0:123:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:123:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:123:ACT") {
    field(DESC, "123 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:123:DES") {
    field(DESC, "123 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:123:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:123:PERMITTED") {
    field(DESC, "123 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:123:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:123:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:123:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:123:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:123:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:123:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:123:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:123:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:123:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:123:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:123:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "C||D||E||F||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:123:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:123:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:123:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:123:RATE PP")
#}

#######################################################################
# 124: DUMPSXR
record(stringin, "LMM:SYS0:124:NAME") {
    field(DESC, "124 mode name")
    field(VAL,  "124: DUMPSXR")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:124:CMD") {
    field(DESC, "124 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:124:YCMD_CALC") {
    field(DESC, "124 mode cmd yes calc")
    field(INPA, "LMM:SYS0:124:CMD CP MSS") 
    field(INPB, "LMM:SYS0:124:DES NPP MSS")
    field(INPC, "LMM:SYS0:124:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:124:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:124:NCMD_CALC") {
    field(DESC, "124 mode cmd no calc")
    field(INPA, "LMM:SYS0:124:CMD CP MSS")
    field(INPB, "LMM:SYS0:124:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:124:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:124:ACT") {
    field(DESC, "124 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:124:DES") {
    field(DESC, "124 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:124:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:124:PERMITTED") {
    field(DESC, "124 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:124:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:124:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:124:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:124:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:124:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:124:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:124:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:124:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:124:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:124:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:124:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "B||D||E||F||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:124:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:124:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:124:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:124:RATE PP")
#}

#######################################################################
# 125: TDUNDSXRDC
record(stringin, "LMM:SYS0:125:NAME") {
    field(DESC, "125 mode name")
    field(VAL,  "125: TDUNDSXRDC")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:125:CMD") {
    field(DESC, "125 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:125:YCMD_CALC") {
    field(DESC, "125 mode cmd yes calc")
    field(INPA, "LMM:SYS0:125:CMD CP MSS") 
    field(INPB, "LMM:SYS0:125:DES NPP MSS")
    field(INPC, "LMM:SYS0:125:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:125:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:125:NCMD_CALC") {
    field(DESC, "125 mode cmd no calc")
    field(INPA, "LMM:SYS0:125:CMD CP MSS")
    field(INPB, "LMM:SYS0:125:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:125:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:125:ACT") {
    field(DESC, "125 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:125:DES") {
    field(DESC, "125 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:125:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:125:PERMITTED") {
    field(DESC, "125 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:125:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:125:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:125:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:125:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:125:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:125:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:125:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:125:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:125:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "G||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:125:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:125:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||E||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:125:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:125:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:125:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:125:RATE PP")
#}

#######################################################################
# 126: DUMPSXRDC
record(stringin, "LMM:SYS0:126:NAME") {
    field(DESC, "126 mode name")
    field(VAL,  "126: DUMPSXRDC")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:126:CMD") {
    field(DESC, "126 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:126:YCMD_CALC") {
    field(DESC, "126 mode cmd yes calc")
    field(INPA, "LMM:SYS0:126:CMD CP MSS") 
    field(INPB, "LMM:SYS0:126:DES NPP MSS")
    field(INPC, "LMM:SYS0:126:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:126:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:126:NCMD_CALC") {
    field(DESC, "126 mode cmd no calc")
    field(INPA, "LMM:SYS0:126:CMD CP MSS")
    field(INPB, "LMM:SYS0:126:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:126:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:126:ACT") {
    field(DESC, "126 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:126:DES") {
    field(DESC, "126 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:126:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:126:PERMITTED") {
    field(DESC, "126 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:126:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:126:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:126:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:126:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:126:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:126:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:126:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:126:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:126:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "G||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:126:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:126:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:126:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:126:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:126:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:126:RATE PP")
#}

#######################################################################
# 127: BYKIKSXRDC
record(stringin, "LMM:SYS0:127:NAME") {
    field(DESC, "127 mode name")
    field(VAL,  "127: BYKIKSXRDC")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:127:CMD") {
    field(DESC, "127 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:127:YCMD_CALC") {
    field(DESC, "127 mode cmd yes calc")
    field(INPA, "LMM:SYS0:127:CMD CP MSS") 
    field(INPB, "LMM:SYS0:127:DES NPP MSS")
    field(INPC, "LMM:SYS0:127:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:127:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:127:NCMD_CALC") {
    field(DESC, "127 mode cmd no calc")
    field(INPA, "LMM:SYS0:127:CMD CP MSS")
    field(INPB, "LMM:SYS0:127:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:127:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:127:ACT") {
    field(DESC, "127 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:127:DES") {
    field(DESC, "127 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:127:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:127:PERMITTED") {
    field(DESC, "127 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:127:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:127:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:127:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:127:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:127:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:127:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:127:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:127:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:127:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "G||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:127:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:127:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||G?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:127:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:127:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:127:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:127:RATE PP")
#}

#######################################################################
# 128: STCLTSDC
record(stringin, "LMM:SYS0:128:NAME") {
    field(DESC, "128 mode name")
    field(VAL,  "128: STCLTSDC")
    field(PINI, "YES")
    #info(autosaveFields, "VAL")
}

# Change mode command and sequence
record(bo, "LMM:SYS0:128:CMD") {
    field(DESC, "128 mode command")
    # maybe NSEQ and YSEQ should set this CMD back to 0 as the last step?
    # the YCMD/NCMD_CALCs will only act if the value is 1
    #field(HIGH, "1") # won't need if do what's noted above
    #field(ONAM, "Apply")
}
record(calcout, "LMM:SYS0:128:YCMD_CALC") {
    field(DESC, "128 mode cmd yes calc")
    field(INPA, "LMM:SYS0:128:CMD CP MSS") 
    field(INPB, "LMM:SYS0:128:DES NPP MSS")
    field(INPC, "LMM:SYS0:128:PERMITTED NPP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:128:YSEQ.PROC PP MSS")
    # YSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:128:NCMD_CALC") {
    field(DESC, "128 mode cmd no calc")
    field(INPA, "LMM:SYS0:128:CMD CP MSS")
    field(INPB, "LMM:SYS0:128:DES NPP MSS") 
    field(CALC, "A&&!B")
    field(IVOA, "Don't drive outputs")
    field(OOPT, "When Non-zero")
    field(OUT,  "LMM:SYS0:128:NSEQ.PROC PP MSS")
    # NSEQ is in ModeSwitchLogic.db
    #field(ASG,  "Internal")
}

# Actual mode 
record(bi, "LMM:SYS0:128:ACT") {
    field(DESC, "128 mode actual")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
    # ACT_CALC0 PVs are in ModeSwitchLogic.db 
}

# Desired mode
record(bo, "LMM:SYS0:128:DES") {
    field(DESC, "128 mode desired")
    field(VAL,  "0")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(OUT,  "LMM:SYS0:128:PERMIT_CALC.PROC PP")
    field(ASG, "MCC")
    #info(autosaveFields, "VAL")
}

# Permitted mode S
record(bi, "LMM:SYS0:128:PERMITTED") {
    field(DESC, "128 mode permitted")
    field(VAL,  "1")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:128:PERMIT_DISPCALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:128:PERMITTED CP MSS")
    # If not permitted, disable DES selection 
    field(CALC, "!A") 
    field(OOPT, "Every Time")
    field(OVAL, "1")
    # LEAVE ALWAYS ENABLED FOR NOW!!!
    # field(CALC, "0") 
    field(OUT,  "LMM:SYS0:128:DES.DISP PP")
    field(ASG,  "Internal")
}
record(calcout, "LMM:SYS0:128:PERMIT_CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:128:PERMIT_SC1CALC CP MSS")
    field(INPB, "LMM:SYS0:128:PERMIT_NCCALC1 CP MSS")
    field(INPC, "LMM:SYS0:128:PERMIT_NCCALC2 CP MSS")
    field(CALC, "A&&B&&C")
    field(IVOA, "Don't drive outputs")
    field(OUT,  "LMM:SYS0:128:PERMITTED PP")
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:128:PERMIT_SC1CALC") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:201:DES CP MSS")
    field(INPB, "LMM:SYS0:202:DES CP MSS")
    field(INPC, "LMM:SYS0:203:DES CP MSS")
    field(INPD, "LMM:SYS0:204:DES CP MSS")
    field(INPE, "LMM:SYS0:205:DES CP MSS")
    field(INPF, "LMM:SYS0:211:DES CP MSS")
    field(INPG, "LMM:SYS0:221:DES CP MSS")
    field(INPH, "LMM:SYS0:212:DES CP MSS")
    field(INPI, "LMM:SYS0:222:DES CP MSS")
    field(INPJ, "LMM:SYS0:213:DES CP MSS")
    # If any are Yes, then incompatible (sc1_calc from sub. file)
    field(CALC, "0?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:128:PERMIT_NCCALC1") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:101:DES CP MSS")
    field(INPB, "LMM:SYS0:102:DES CP MSS")
    field(INPC, "LMM:SYS0:103:DES CP MSS")
    field(INPD, "LMM:SYS0:104:DES CP MSS")
    field(INPE, "LMM:SYS0:105:DES CP MSS")
    field(INPF, "LMM:SYS0:111:DES CP MSS")
    field(INPG, "LMM:SYS0:112:DES CP MSS")
    field(INPH, "LMM:SYS0:113:DES CP MSS")
    field(INPI, "LMM:SYS0:114:DES CP MSS")
    field(INPJ, "LMM:SYS0:121:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F||G||H||I||J?0:1") 
    field(ASG,  "Internal")
}
record(calc, "LMM:SYS0:128:PERMIT_NCCALC2") {
    field(DESC, "")
    field(INPA, "LMM:SYS0:122:DES CP MSS")
    field(INPB, "LMM:SYS0:123:DES CP MSS")
    field(INPC, "LMM:SYS0:124:DES CP MSS")
    field(INPD, "LMM:SYS0:125:DES CP MSS")
    field(INPE, "LMM:SYS0:126:DES CP MSS")
    field(INPF, "LMM:SYS0:127:DES CP MSS")
    field(INPG, "LMM:SYS0:128:DES CP MSS")
    # If any are Yes, then incompatible (nc_calc from sub. file)
    field(CALC, "A||B||C||D||E||F?0:1") 
    field(ASG,  "Internal")
}
#record(ai, "LMM:SYS0:128:RATE"){
#    field(DESC, "Rate delivered to this destination")
#    field(EGU, "Hz")
#}
#record(calcout,"LMM:SYS0:128:RATE_CALC"){
#    field(SCAN, "1 second")
#    field(INPA, "LMM:SYS0:128:ACT CP MSS")
#    field(INPB, "???")
#    field(CALC, "A?B:0")
#    field(OUT, "LMM:SYS0:128:RATE PP")
#}

