record( bo, "$(IOC):dummyNonExistantTag" ) 
{
  field(ASG , "CRYO") 
  field(SCAN, "Passive" ) 
} 
 
 
# record for PLC tag <C1_ActivePump> of type <BOOL>
record( bo, "$(IOC):C1_ActivePump" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) C1_ActivePump S 1" ) 
} 
 
 
# record for PLC tag <C1_VacValve> of type <BIT>
record( bo, "$(IOC):C1_VacValve" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) C1_VacValve S 1" ) 
} 
 
 
# record for PLC tag <C2_ActivePump> of type <BOOL>
record( bo, "$(IOC):C2_ActivePump" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) C2_ActivePump S 1" ) 
} 
 
 
# record for PLC tag <C2_VacValve> of type <BIT>
record( bo, "$(IOC):C2_VacValve" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) C2_VacValve S 1" ) 
} 
 
 
# record for PLC tag <C3_ActivePump> of type <BOOL>
record( bo, "$(IOC):C3_ActivePump" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) C3_ActivePump S 1" ) 
} 
 
 
# record for PLC tag <C3_PumpSpeed> of type <INT>
record( ao, "$(IOC):C3_PumpSpeed" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) C3_PumpSpeed S 1" ) 
} 
 
 
# record for PLC tag <C3_VacValve> of type <BIT>
record( bo, "$(IOC):C3_VacValve" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) C3_VacValve S 1" ) 
} 
 
 
# record for PLC tag <C4_ActivePump> of type <BOOL>
record( bo, "$(IOC):C4_ActivePump" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) C4_ActivePump S 1" ) 
} 
 
 
# record for PLC tag <C4_VacValve> of type <BIT>
record( bo, "$(IOC):C4_VacValve" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) C4_VacValve S 1" ) 
} 
 
 
# record for PLC tag <Coil1.TCR1> of type <REAL>
record( ao, "$(IOC):Coil1-TCR1" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.TCR1 S 1" ) 
} 
 
 
# record for PLC tag <Coil1.TCR2> of type <REAL>
record( ao, "$(IOC):Coil1-TCR2" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.TCR2 S 1" ) 
} 
 
 
# record for PLC tag <Coil1.TCR3> of type <REAL>
record( ao, "$(IOC):Coil1-TCR3" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.TCR3 S 1" ) 
} 
 
 
# record for PLC tag <Coil1.TCR4> of type <REAL>
record( ao, "$(IOC):Coil1-TCR4" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.TCR4 S 1" ) 
} 
 
 
# record for PLC tag <Coil1.TCR5> of type <REAL>
record( ao, "$(IOC):Coil1-TCR5" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.TCR5 S 1" ) 
} 
 
 
# record for PLC tag <Coil1.TCR6> of type <REAL>
record( ao, "$(IOC):Coil1-TCR6" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.TCR6 S 1" ) 
} 
 
 
# record for PLC tag <Coil1.TP1> of type <REAL>
record( ao, "$(IOC):Coil1-TP1" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.TP1 S 1" ) 
} 
 
 
# record for PLC tag <Coil1.TP2> of type <REAL>
record( ao, "$(IOC):Coil1-TP2" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.TP2 S 1" ) 
} 
 
 
# record for PLC tag <Coil1.TP3> of type <REAL>
record( ao, "$(IOC):Coil1-TP3" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.TP3 S 1" ) 
} 
 
 
# record for PLC tag <Coil1.TP4> of type <REAL>
record( ao, "$(IOC):Coil1-TP4" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.TP4 S 1" ) 
} 
 
 
# record for PLC tag <Coil1.TP5> of type <REAL>
record( ao, "$(IOC):Coil1-TP5" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.TP5 S 1" ) 
} 
 
 
# record for PLC tag <Coil1.TP6> of type <REAL>
record( ao, "$(IOC):Coil1-TP6" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.TP6 S 1" ) 
} 
 
 
# record for PLC tag <Coil1.TP7> of type <REAL>
record( ao, "$(IOC):Coil1-TP7" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.TP7 S 1" ) 
} 
 
 
# record for PLC tag <Coil1.TP8> of type <REAL>
record( ao, "$(IOC):Coil1-TP8" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.TP8 S 1" ) 
} 
 
 
# record for PLC tag <Coil1.DT> of type <REAL>
record( ao, "$(IOC):Coil1-DT" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.DT S 1" ) 
} 
 
 
# record for PLC tag <Coil1.NR> of type <REAL>
record( ao, "$(IOC):Coil1-NR" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.NR S 1" ) 
} 
 
 
# record for PLC tag <Coil1.HR> of type <REAL>
record( ao, "$(IOC):Coil1-HR" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.HR S 1" ) 
} 
 
 
# record for PLC tag <Coil1.FB> of type <REAL>
record( ao, "$(IOC):Coil1-FB" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.FB S 1" ) 
} 
 
 
# record for PLC tag <Coil1.FT> of type <REAL>
record( ao, "$(IOC):Coil1-FT" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.FT S 1" ) 
} 
 
 
# record for PLC tag <Coil1.VAC> of type <REAL>
record( ao, "$(IOC):Coil1-VAC" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil1.VAC S 1" ) 
} 


# record for PLC tag <Coil1_VAC_Reset> of type <BOOL>
record( bo, "$(IOC):Coil1_VAC_Reset" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Coil1_VAC_Reset S 1" ) 
} 


# record for PLC tag <Coil2.TCR1> of type <REAL>
record( ao, "$(IOC):Coil2-TCR1" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.TCR1 S 1" ) 
} 
 
 
# record for PLC tag <Coil2.TCR2> of type <REAL>
record( ao, "$(IOC):Coil2-TCR2" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.TCR2 S 1" ) 
} 
 
 
# record for PLC tag <Coil2.TCR3> of type <REAL>
record( ao, "$(IOC):Coil2-TCR3" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.TCR3 S 1" ) 
} 
 
 
# record for PLC tag <Coil2.TCR4> of type <REAL>
record( ao, "$(IOC):Coil2-TCR4" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.TCR4 S 1" ) 
} 
 
 
# record for PLC tag <Coil2.TCR5> of type <REAL>
record( ao, "$(IOC):Coil2-TCR5" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.TCR5 S 1" ) 
} 
 
 
# record for PLC tag <Coil2.TCR6> of type <REAL>
record( ao, "$(IOC):Coil2-TCR6" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.TCR6 S 1" ) 
} 
 
 
# record for PLC tag <Coil2.TP1> of type <REAL>
record( ao, "$(IOC):Coil2-TP1" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.TP1 S 1" ) 
} 
 
 
# record for PLC tag <Coil2.TP2> of type <REAL>
record( ao, "$(IOC):Coil2-TP2" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.TP2 S 1" ) 
} 
 
 
# record for PLC tag <Coil2.TP3> of type <REAL>
record( ao, "$(IOC):Coil2-TP3" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.TP3 S 1" ) 
} 
 
 
# record for PLC tag <Coil2.TP4> of type <REAL>
record( ao, "$(IOC):Coil2-TP4" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.TP4 S 1" ) 
} 
 
 
# record for PLC tag <Coil2.TP5> of type <REAL>
record( ao, "$(IOC):Coil2-TP5" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.TP5 S 1" ) 
} 
 
 
# record for PLC tag <Coil2.TP6> of type <REAL>
record( ao, "$(IOC):Coil2-TP6" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.TP6 S 1" ) 
} 
 
 
# record for PLC tag <Coil2.TP7> of type <REAL>
record( ao, "$(IOC):Coil2-TP7" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.TP7 S 1" ) 
} 
 
 
# record for PLC tag <Coil2.TP8> of type <REAL>
record( ao, "$(IOC):Coil2-TP8" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.TP8 S 1" ) 
} 
 
 
# record for PLC tag <Coil2.DT> of type <REAL>
record( ao, "$(IOC):Coil2-DT" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.DT S 1" ) 
} 
 
 
# record for PLC tag <Coil2.NR> of type <REAL>
record( ao, "$(IOC):Coil2-NR" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.NR S 1" ) 
} 
 
 
# record for PLC tag <Coil2.HR> of type <REAL>
record( ao, "$(IOC):Coil2-HR" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.HR S 1" ) 
} 
 
 
# record for PLC tag <Coil2.FB> of type <REAL>
record( ao, "$(IOC):Coil2-FB" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.FB S 1" ) 
} 
 
 
# record for PLC tag <Coil2.FT> of type <REAL>
record( ao, "$(IOC):Coil2-FT" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.FT S 1" ) 
} 
 
 
# record for PLC tag <Coil2.VAC> of type <REAL>
record( ao, "$(IOC):Coil2-VAC" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil2.VAC S 1" ) 
} 
 
# record for PLC tag <Coil2_VAC_Reset> of type <BOOL>
record( bo, "$(IOC):Coil2_VAC_Reset" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Coil2_VAC_Reset S 1" ) 
} 
 
# record for PLC tag <Coil3.TCR1> of type <REAL>
record( ao, "$(IOC):Coil3-TCR1" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.TCR1 S 1" ) 
} 
 
 
# record for PLC tag <Coil3.TCR2> of type <REAL>
record( ao, "$(IOC):Coil3-TCR2" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.TCR2 S 1" ) 
} 
 
 
# record for PLC tag <Coil3.TCR3> of type <REAL>
record( ao, "$(IOC):Coil3-TCR3" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.TCR3 S 1" ) 
} 
 
 
# record for PLC tag <Coil3.TCR4> of type <REAL>
record( ao, "$(IOC):Coil3-TCR4" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.TCR4 S 1" ) 
} 
 
 
# record for PLC tag <Coil3.TCR5> of type <REAL>
record( ao, "$(IOC):Coil3-TCR5" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.TCR5 S 1" ) 
} 
 
 
# record for PLC tag <Coil3.TCR6> of type <REAL>
record( ao, "$(IOC):Coil3-TCR6" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.TCR6 S 1" ) 
} 
 
 
# record for PLC tag <Coil3.TP1> of type <REAL>
record( ao, "$(IOC):Coil3-TP1" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.TP1 S 1" ) 
} 
 
 
# record for PLC tag <Coil3.TP2> of type <REAL>
record( ao, "$(IOC):Coil3-TP2" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.TP2 S 1" ) 
} 
 
 
# record for PLC tag <Coil3.TP3> of type <REAL>
record( ao, "$(IOC):Coil3-TP3" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.TP3 S 1" ) 
} 
 
 
# record for PLC tag <Coil3.TP4> of type <REAL>
record( ao, "$(IOC):Coil3-TP4" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.TP4 S 1" ) 
} 
 
 
# record for PLC tag <Coil3.TP5> of type <REAL>
record( ao, "$(IOC):Coil3-TP5" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.TP5 S 1" ) 
} 
 
 
# record for PLC tag <Coil3.TP6> of type <REAL>
record( ao, "$(IOC):Coil3-TP6" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.TP6 S 1" ) 
} 
 
 
# record for PLC tag <Coil3.TP7> of type <REAL>
record( ao, "$(IOC):Coil3-TP7" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.TP7 S 1" ) 
} 
 
 
# record for PLC tag <Coil3.TP8> of type <REAL>
record( ao, "$(IOC):Coil3-TP8" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.TP8 S 1" ) 
} 
 
 
# record for PLC tag <Coil3.DT> of type <REAL>
record( ao, "$(IOC):Coil3-DT" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.DT S 1" ) 
} 
 
 
# record for PLC tag <Coil3.NR> of type <REAL>
record( ao, "$(IOC):Coil3-NR" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.NR S 1" ) 
} 
 
 
# record for PLC tag <Coil3.HR> of type <REAL>
record( ao, "$(IOC):Coil3-HR" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.HR S 1" ) 
} 
 
 
# record for PLC tag <Coil3.FB> of type <REAL>
record( ao, "$(IOC):Coil3-FB" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.FB S 1" ) 
} 
 
 
# record for PLC tag <Coil3.FT> of type <REAL>
record( ao, "$(IOC):Coil3-FT" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.FT S 1" ) 
} 
 
 
# record for PLC tag <Coil3.VAC> of type <REAL>
record( ao, "$(IOC):Coil3-VAC" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil3.VAC S 1" ) 
} 
 

# record for PLC tag <Coil3_VAC_Reset> of type <BOOL>
record( bo, "$(IOC):Coil3_VAC_Reset" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Coil3_VAC_Reset S 1" ) 
} 

# record for PLC tag <Coil4.TCR1> of type <REAL>
record( ao, "$(IOC):Coil4-TCR1" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.TCR1 S 1" ) 
} 
 
 
# record for PLC tag <Coil4.TCR2> of type <REAL>
record( ao, "$(IOC):Coil4-TCR2" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.TCR2 S 1" ) 
} 
 
 
# record for PLC tag <Coil4.TCR3> of type <REAL>
record( ao, "$(IOC):Coil4-TCR3" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.TCR3 S 1" ) 
} 
 
 
# record for PLC tag <Coil4.TCR4> of type <REAL>
record( ao, "$(IOC):Coil4-TCR4" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.TCR4 S 1" ) 
} 
 
 
# record for PLC tag <Coil4.TCR5> of type <REAL>
record( ao, "$(IOC):Coil4-TCR5" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.TCR5 S 1" ) 
} 
 
 
# record for PLC tag <Coil4.TCR6> of type <REAL>
record( ao, "$(IOC):Coil4-TCR6" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.TCR6 S 1" ) 
} 
 
 
# record for PLC tag <Coil4.TP1> of type <REAL>
record( ao, "$(IOC):Coil4-TP1" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.TP1 S 1" ) 
} 
 
 
# record for PLC tag <Coil4.TP2> of type <REAL>
record( ao, "$(IOC):Coil4-TP2" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.TP2 S 1" ) 
} 
 
 
# record for PLC tag <Coil4.TP3> of type <REAL>
record( ao, "$(IOC):Coil4-TP3" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.TP3 S 1" ) 
} 
 
 
# record for PLC tag <Coil4.TP4> of type <REAL>
record( ao, "$(IOC):Coil4-TP4" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.TP4 S 1" ) 
} 
 
 
# record for PLC tag <Coil4.TP5> of type <REAL>
record( ao, "$(IOC):Coil4-TP5" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.TP5 S 1" ) 
} 
 
 
# record for PLC tag <Coil4.TP6> of type <REAL>
record( ao, "$(IOC):Coil4-TP6" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.TP6 S 1" ) 
} 
 
 
# record for PLC tag <Coil4.TP7> of type <REAL>
record( ao, "$(IOC):Coil4-TP7" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.TP7 S 1" ) 
} 
 
 
# record for PLC tag <Coil4.TP8> of type <REAL>
record( ao, "$(IOC):Coil4-TP8" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.TP8 S 1" ) 
} 
 
 
# record for PLC tag <Coil4.DT> of type <REAL>
record( ao, "$(IOC):Coil4-DT" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.DT S 1" ) 
} 
 
 
# record for PLC tag <Coil4.NR> of type <REAL>
record( ao, "$(IOC):Coil4-NR" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.NR S 1" ) 
} 
 
 
# record for PLC tag <Coil4.HR> of type <REAL>
record( ao, "$(IOC):Coil4-HR" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.HR S 1" ) 
} 
 
 
# record for PLC tag <Coil4.FB> of type <REAL>
record( ao, "$(IOC):Coil4-FB" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.FB S 1" ) 
} 
 
 
# record for PLC tag <Coil4.FT> of type <REAL>
record( ao, "$(IOC):Coil4-FT" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.FT S 1" ) 
} 
 
 
# record for PLC tag <Coil4.VAC> of type <REAL>
record( ao, "$(IOC):Coil4-VAC" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Coil4.VAC S 1" ) 
} 
 

# record for PLC tag <Coil4_VAC_Reset> of type <BOOL>
record( bo, "$(IOC):Coil4_VAC_Reset" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Coil4_VAC_Reset S 1" ) 
} 

 
# record for PLC tag <Coil_dT_Alm_Sum> of type <BOOL>
record( bo, "$(IOC):Coil_dT_Alm_Sum" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Coil_dT_Alm_Sum S 1" ) 
} 
 
 
# record for PLC tag <DBox.TD_HS> of type <REAL>
record( ao, "$(IOC):DBox-TD_HS" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.TD_HS S 1" ) 
} 
 
 
# record for PLC tag <DBox.PT_HS> of type <REAL>
record( ao, "$(IOC):DBox-PT_HS" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.PT_HS S 1" ) 
} 
 
 
# record for PLC tag <DBox.TD_HR> of type <REAL>
record( ao, "$(IOC):DBox-TD_HR" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.TD_HR S 1" ) 
} 
 
 
# record for PLC tag <DBox.PT_NS> of type <REAL>
record( ao, "$(IOC):DBox-PT_NS" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.PT_NS S 1" ) 
} 
 
 
# record for PLC tag <DBox.TP_NSB> of type <REAL>
record( ao, "$(IOC):DBox-TP_NSB" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.TP_NSB S 1" ) 
} 
 
 
# record for PLC tag <DBox.TD_USCL> of type <REAL>
record( ao, "$(IOC):DBox-TD_USCL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.TD_USCL S 1" ) 
} 
 
 
# record for PLC tag <DBox.TD_DSCL> of type <REAL>
record( ao, "$(IOC):DBox-TD_DSCL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.TD_DSCL S 1" ) 
} 
 
 
# record for PLC tag <DBox.LLH> of type <REAL>
record( ao, "$(IOC):DBox-LLH" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.LLH S 1" ) 
} 
 
 
# record for PLC tag <DBox.LLN> of type <REAL>
record( ao, "$(IOC):DBox-LLN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.LLN S 1" ) 
} 
 
 
# record for PLC tag <DBox.TD_WH> of type <REAL>
record( ao, "$(IOC):DBox-TD_WH" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.TD_WH S 1" ) 
} 
 
 
# record for PLC tag <DBox.PT_HT> of type <REAL>
record( ao, "$(IOC):DBox-PT_HT" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.PT_HT S 1" ) 
} 
 
 
# record for PLC tag <DBox.DP_LLH> of type <REAL>
record( ao, "$(IOC):DBox-DP_LLH" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.DP_LLH S 1" ) 
} 
 
 
# record for PLC tag <DBox.DP_LLN> of type <REAL>
record( ao, "$(IOC):DBox-DP_LLN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.DP_LLN S 1" ) 
} 
 
 
# record for PLC tag <DBox.PT_NT> of type <REAL>
record( ao, "$(IOC):DBox-PT_NT" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.PT_NT S 1" ) 
} 
 
 
# record for PLC tag <DBox.TP_NR> of type <REAL>
record( ao, "$(IOC):DBox-TP_NR" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.TP_NR S 1" ) 
} 
 
 
# record for PLC tag <DBox.TP_NS> of type <REAL>
record( ao, "$(IOC):DBox-TP_NS" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.TP_NS S 1" ) 
} 
 
 
# record for PLC tag <DBox.TP_USCLW> of type <REAL>
record( ao, "$(IOC):DBox-TP_USCLW" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.TP_USCLW S 1" ) 
} 
 
 
# record for PLC tag <DBox.TP_DSCLW> of type <REAL>
record( ao, "$(IOC):DBox-TP_DSCLW" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.TP_DSCLW S 1" ) 
} 
 
 
# record for PLC tag <DBox.FI_USCL> of type <REAL>
record( ao, "$(IOC):DBox-FI_USCL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.FI_USCL S 1" ) 
} 
 
 
# record for PLC tag <DBox.FI_DSCL> of type <REAL>
record( ao, "$(IOC):DBox-FI_DSCL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.FI_DSCL S 1" ) 
} 
 
 
# record for PLC tag <DBox.TC_DBX> of type <REAL>
record( ao, "$(IOC):DBox-TC_DBX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.TC_DBX S 1" ) 
} 
 
 
# record for PLC tag <DBox.TP_HHX> of type <REAL>
record( ao, "$(IOC):DBox-TP_HHX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.TP_HHX S 1" ) 
} 
 
 
# record for PLC tag <DBox.TP_NHX> of type <REAL>
record( ao, "$(IOC):DBox-TP_NHX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox.TP_NHX S 1" ) 
} 
 
# record for PLC tag <DBX_VAC_Reset> of type <BOOL>
record( bo, "$(IOC):DBX_VAC_Reset" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) DBX_VAC_Reset S 1" ) 
} 

# record for PLC tag <DBox_ActivePump> of type <BOOL>
record( bo, "$(IOC):DBox_ActivePump" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) DBox_ActivePump S 1" ) 
} 
 
 
# record for PLC tag <DBox_PumpSpeed> of type <INT>
record( ao, "$(IOC):DBox_PumpSpeed" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DBox_PumpSpeed S 1" ) 
} 
 
 
# record for PLC tag <DBox_VacValve> of type <BIT>
record( bo, "$(IOC):DBox_VacValve" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) DBox_VacValve S 1" ) 
} 
 
 
# record for PLC tag <DSL_V> of type <REAL>
record( ao, "$(IOC):DSL_V" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DSL_V S 1" ) 
} 
 
 
# record for PLC tag <HMI_MPSset_I_sw> of type <BOOL>
record( bo, "$(IOC):HMI_MPSset_I_sw" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) HMI_MPSset_I_sw S 1" ) 
} 
 
 
# record for PLC tag <HMI_Rst_Intlck_Sw> of type <BOOL>
record( bo, "$(IOC):HMI_Rst_Intlck_Sw" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) HMI_Rst_Intlck_Sw S 1" ) 
} 
 
 
# record for PLC tag <JTV1.CVAL> of type <REAL>
record( ao, "$(IOC):JTV1-CVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.CVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV1.ORBV> of type <REAL>
record( ao, "$(IOC):JTV1-ORBV" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.ORBV S 1" ) 
} 
 
 
# record for PLC tag <JTV1.OVAL> of type <REAL>
record( ao, "$(IOC):JTV1-OVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.OVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV1.MIN> of type <REAL>
record( ao, "$(IOC):JTV1-MIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.MIN S 1" ) 
} 
 
 
# record for PLC tag <JTV1.MAX> of type <REAL>
record( ao, "$(IOC):JTV1-MAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.MAX S 1" ) 
} 
 
 
# record for PLC tag <JTV1.DMIN> of type <REAL>
record( ao, "$(IOC):JTV1-DMIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.DMIN S 1" ) 
} 
 
 
# record for PLC tag <JTV1.DMAX> of type <REAL>
record( ao, "$(IOC):JTV1-DMAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.DMAX S 1" ) 
} 
 
 
# record for PLC tag <JTV1.VAL> of type <REAL>
record( ao, "$(IOC):JTV1-VAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.VAL S 1" ) 
} 
 
 
# record for PLC tag <JTV1.SVAL> of type <REAL>
record( ao, "$(IOC):JTV1-SVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.SVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV1.MVAL> of type <REAL>
record( ao, "$(IOC):JTV1-MVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.MVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV1.KP> of type <REAL>
record( ao, "$(IOC):JTV1-KP" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.KP S 1" ) 
} 
 
 
# record for PLC tag <JTV1.KI> of type <REAL>
record( ao, "$(IOC):JTV1-KI" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.KI S 1" ) 
} 
 
 
# record for PLC tag <JTV1.KD> of type <REAL>
record( ao, "$(IOC):JTV1-KD" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.KD S 1" ) 
} 
 
 
# record for PLC tag <JTV1.MDt> of type <REAL>
record( ao, "$(IOC):JTV1-MDt" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.MDt S 1" ) 
} 
 
 
# record for PLC tag <JTV1.MODE> of type <INT>
record( ao, "$(IOC):JTV1-MODE" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.MODE S 1" ) 
} 
 
 
# record for PLC tag <JTV1.PV_Select> of type <INT>
record( ao, "$(IOC):JTV1-PV_Select" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV1.PV_Select S 1" ) 
} 
 
 
# record for PLC tag <JTV1.mmod> of type <BOOL>
record( bo, "$(IOC):JTV1-mmod" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) JTV1.mmod S 1" ) 
} 
 
 
# record for PLC tag <JTV10.CVAL> of type <REAL>
record( ao, "$(IOC):JTV10-CVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.CVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV10.ORBV> of type <REAL>
record( ao, "$(IOC):JTV10-ORBV" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.ORBV S 1" ) 
} 
 
 
# record for PLC tag <JTV10.OVAL> of type <REAL>
record( ao, "$(IOC):JTV10-OVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.OVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV10.MIN> of type <REAL>
record( ao, "$(IOC):JTV10-MIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.MIN S 1" ) 
} 
 
 
# record for PLC tag <JTV10.MAX> of type <REAL>
record( ao, "$(IOC):JTV10-MAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.MAX S 1" ) 
} 
 
 
# record for PLC tag <JTV10.DMIN> of type <REAL>
record( ao, "$(IOC):JTV10-DMIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.DMIN S 1" ) 
} 
 
 
# record for PLC tag <JTV10.DMAX> of type <REAL>
record( ao, "$(IOC):JTV10-DMAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.DMAX S 1" ) 
} 
 
 
# record for PLC tag <JTV10.VAL> of type <REAL>
record( ao, "$(IOC):JTV10-VAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.VAL S 1" ) 
} 
 
 
# record for PLC tag <JTV10.SVAL> of type <REAL>
record( ao, "$(IOC):JTV10-SVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.SVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV10.MVAL> of type <REAL>
record( ao, "$(IOC):JTV10-MVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.MVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV10.KP> of type <REAL>
record( ao, "$(IOC):JTV10-KP" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.KP S 1" ) 
} 
 
 
# record for PLC tag <JTV10.KI> of type <REAL>
record( ao, "$(IOC):JTV10-KI" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.KI S 1" ) 
} 
 
 
# record for PLC tag <JTV10.KD> of type <REAL>
record( ao, "$(IOC):JTV10-KD" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.KD S 1" ) 
} 
 
 
# record for PLC tag <JTV10.MDt> of type <REAL>
record( ao, "$(IOC):JTV10-MDt" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.MDt S 1" ) 
} 


# record for PLC tag <Program:Solenoid_Cryo.JTV1_DriveScale> of type <REAL>
# Manually added
record( ao, "$(IOC)::Solenoid_Cryo-JTV1_DriveScale" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "1 second" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV1_DriveScale S 1" ) 
  field(PREC, "2" ) 
} 

# record for PLC tag <Program:Solenoid_Cryo.JTV2_DriveScale> of type <REAL>
# Manually added
record( ao, "$(IOC)::Solenoid_Cryo-JTV2_DriveScale" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "1 second" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV2_DriveScale S 1" ) 
  field(PREC, "2" ) 
} 

# record for PLC tag <Program:Solenoid_Cryo.JTV3_DriveScale> of type <REAL>
# Manually added
record( ao, "$(IOC)::Solenoid_Cryo-JTV3_DriveScale" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "1 second" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV3_DriveScale S 1" ) 
  field(PREC, "2" ) 
} 

# record for PLC tag <Program:Solenoid_Cryo.JTV4_DriveScale_Usethis> of type <REAL>
# Manually added
record( ao, "$(IOC)::Solenoid_Cryo-JTV4_DriveScale" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "1 second" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV4_DriveScale_Usethis S 1" ) 
  field(PREC, "2" ) 
} 
# record for PLC tag <Program:Solenoid_Cryo.JTV5_DriveScale> of type <REAL>
# Manually added
record( ao, "$(IOC)::Solenoid_Cryo-JTV5_DriveScale" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "1 second" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV5_DriveScale S 1" ) 
  field(PREC, "2" ) 
} 

# record for PLC tag <Program:Solenoid_Cryo.JTV7_DriveScale> of type <REAL>
# Manually added
record( ao, "$(IOC)::Solenoid_Cryo-JTV7_DriveScale" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "1 second" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV7_DriveScale S 1" ) 
  field(PREC, "2" ) 
} 

# record for PLC tag <Program:Solenoid_Cryo.JTV8_DriveScale> of type <REAL>
# Manually added
record( ao, "$(IOC)::Solenoid_Cryo-JTV8_DriveScale" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "1 second" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV8_DriveScale S 1" ) 
  field(PREC, "2" ) 
} 

# record for PLC tag <Program:Solenoid_Cryo.JTV9_DriveScale> of type <REAL>
# Manually added
record( ao, "$(IOC)::Solenoid_Cryo-JTV9_DriveScale" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "1 second" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV9_DriveScale S 1" ) 
  field(PREC, "2" ) 
} 

# record for PLC tag <Program:Solenoid_Cryo.JTV10_DriveScale> of type <REAL>
# Manually added
record( ao, "$(IOC)::Solenoid_Cryo-JTV10_DriveScale" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "1 second" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV10_DriveScale S 1" ) 
  field(PREC, "2" ) 
} 
 

# record for PLC tag <JTV10.MODE> of type <INT>
record( ao, "$(IOC):JTV10-MODE" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.MODE S 1" ) 
} 
 
 
# record for PLC tag <JTV10.PV_Select> of type <INT>
record( ao, "$(IOC):JTV10-PV_Select" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV10.PV_Select S 1" ) 
} 
 
 
# record for PLC tag <JTV10.mmod> of type <BOOL>
record( bo, "$(IOC):JTV10-mmod" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) JTV10.mmod S 1" ) 
} 
 
 
# record for PLC tag <JTV2.CVAL> of type <REAL>
record( ao, "$(IOC):JTV2-CVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.CVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV2.ORBV> of type <REAL>
record( ao, "$(IOC):JTV2-ORBV" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.ORBV S 1" ) 
} 
 
 
# record for PLC tag <JTV2.OVAL> of type <REAL>
record( ao, "$(IOC):JTV2-OVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.OVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV2.MIN> of type <REAL>
record( ao, "$(IOC):JTV2-MIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.MIN S 1" ) 
} 
 
 
# record for PLC tag <JTV2.MAX> of type <REAL>
record( ao, "$(IOC):JTV2-MAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.MAX S 1" ) 
} 
 
 
# record for PLC tag <JTV2.DMIN> of type <REAL>
record( ao, "$(IOC):JTV2-DMIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.DMIN S 1" ) 
} 
 
 
# record for PLC tag <JTV2.DMAX> of type <REAL>
record( ao, "$(IOC):JTV2-DMAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.DMAX S 1" ) 
} 
 
 
# record for PLC tag <JTV2.VAL> of type <REAL>
record( ao, "$(IOC):JTV2-VAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.VAL S 1" ) 
} 
 
 
# record for PLC tag <JTV2.SVAL> of type <REAL>
record( ao, "$(IOC):JTV2-SVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.SVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV2.MVAL> of type <REAL>
record( ao, "$(IOC):JTV2-MVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.MVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV2.KP> of type <REAL>
record( ao, "$(IOC):JTV2-KP" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.KP S 1" ) 
} 
 
 
# record for PLC tag <JTV2.KI> of type <REAL>
record( ao, "$(IOC):JTV2-KI" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.KI S 1" ) 
} 
 
 
# record for PLC tag <JTV2.KD> of type <REAL>
record( ao, "$(IOC):JTV2-KD" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.KD S 1" ) 
} 
 
 
# record for PLC tag <JTV2.MDt> of type <REAL>
record( ao, "$(IOC):JTV2-MDt" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.MDt S 1" ) 
} 
 
 
# record for PLC tag <JTV2.MODE> of type <INT>
record( ao, "$(IOC):JTV2-MODE" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.MODE S 1" ) 
} 
 
 
# record for PLC tag <JTV2.PV_Select> of type <INT>
record( ao, "$(IOC):JTV2-PV_Select" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV2.PV_Select S 1" ) 
} 
 
 
# record for PLC tag <JTV2.mmod> of type <BOOL>
record( bo, "$(IOC):JTV2-mmod" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) JTV2.mmod S 1" ) 
} 
 
 
# record for PLC tag <JTV3.CVAL> of type <REAL>
record( ao, "$(IOC):JTV3-CVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.CVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV3.ORBV> of type <REAL>
record( ao, "$(IOC):JTV3-ORBV" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.ORBV S 1" ) 
} 
 
 
# record for PLC tag <JTV3.OVAL> of type <REAL>
record( ao, "$(IOC):JTV3-OVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.OVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV3.MIN> of type <REAL>
record( ao, "$(IOC):JTV3-MIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.MIN S 1" ) 
} 
 
 
# record for PLC tag <JTV3.MAX> of type <REAL>
record( ao, "$(IOC):JTV3-MAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.MAX S 1" ) 
} 
 
 
# record for PLC tag <JTV3.DMIN> of type <REAL>
record( ao, "$(IOC):JTV3-DMIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.DMIN S 1" ) 
} 
 
 
# record for PLC tag <JTV3.DMAX> of type <REAL>
record( ao, "$(IOC):JTV3-DMAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.DMAX S 1" ) 
} 
 
 
# record for PLC tag <JTV3.VAL> of type <REAL>
record( ao, "$(IOC):JTV3-VAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.VAL S 1" ) 
} 
 
 
# record for PLC tag <JTV3.SVAL> of type <REAL>
record( ao, "$(IOC):JTV3-SVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.SVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV3.MVAL> of type <REAL>
record( ao, "$(IOC):JTV3-MVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.MVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV3.KP> of type <REAL>
record( ao, "$(IOC):JTV3-KP" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.KP S 1" ) 
} 
 
 
# record for PLC tag <JTV3.KI> of type <REAL>
record( ao, "$(IOC):JTV3-KI" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.KI S 1" ) 
} 
 
 
# record for PLC tag <JTV3.KD> of type <REAL>
record( ao, "$(IOC):JTV3-KD" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.KD S 1" ) 
} 
 
 
# record for PLC tag <JTV3.MDt> of type <REAL>
record( ao, "$(IOC):JTV3-MDt" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.MDt S 1" ) 
} 
 
 
# record for PLC tag <JTV3.MODE> of type <INT>
record( ao, "$(IOC):JTV3-MODE" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.MODE S 1" ) 
} 
 
 
# record for PLC tag <JTV3.PV_Select> of type <INT>
record( ao, "$(IOC):JTV3-PV_Select" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV3.PV_Select S 1" ) 
} 
 
 
# record for PLC tag <JTV3.mmod> of type <BOOL>
record( bo, "$(IOC):JTV3-mmod" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) JTV3.mmod S 1" ) 
} 
 
 
# record for PLC tag <JTV4.CVAL> of type <REAL>
record( ao, "$(IOC):JTV4-CVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.CVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV4.ORBV> of type <REAL>
record( ao, "$(IOC):JTV4-ORBV" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.ORBV S 1" ) 
} 
 
 
# record for PLC tag <JTV4.OVAL> of type <REAL>
record( ao, "$(IOC):JTV4-OVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.OVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV4.MIN> of type <REAL>
record( ao, "$(IOC):JTV4-MIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.MIN S 1" ) 
} 
 
 
# record for PLC tag <JTV4.MAX> of type <REAL>
record( ao, "$(IOC):JTV4-MAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.MAX S 1" ) 
} 
 
 
# record for PLC tag <JTV4.DMIN> of type <REAL>
record( ao, "$(IOC):JTV4-DMIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.DMIN S 1" ) 
} 
 
 
# record for PLC tag <JTV4.DMAX> of type <REAL>
record( ao, "$(IOC):JTV4-DMAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.DMAX S 1" ) 
} 
 
 
# record for PLC tag <JTV4.VAL> of type <REAL>
record( ao, "$(IOC):JTV4-VAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.VAL S 1" ) 
} 
 
 
# record for PLC tag <JTV4.SVAL> of type <REAL>
record( ao, "$(IOC):JTV4-SVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.SVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV4.MVAL> of type <REAL>
record( ao, "$(IOC):JTV4-MVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.MVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV4.KP> of type <REAL>
record( ao, "$(IOC):JTV4-KP" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.KP S 1" ) 
} 
 
 
# record for PLC tag <JTV4.KI> of type <REAL>
record( ao, "$(IOC):JTV4-KI" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.KI S 1" ) 
} 
 
 
# record for PLC tag <JTV4.KD> of type <REAL>
record( ao, "$(IOC):JTV4-KD" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.KD S 1" ) 
} 
 
 
# record for PLC tag <JTV4.MDt> of type <REAL>
record( ao, "$(IOC):JTV4-MDt" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.MDt S 1" ) 
} 
 
 
# record for PLC tag <JTV4.MODE> of type <INT>
record( ao, "$(IOC):JTV4-MODE" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.MODE S 1" ) 
} 
 
 
# record for PLC tag <JTV4.PV_Select> of type <INT>
record( ao, "$(IOC):JTV4-PV_Select" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV4.PV_Select S 1" ) 
} 
 
 
# record for PLC tag <JTV4.mmod> of type <BOOL>
record( bo, "$(IOC):JTV4-mmod" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) JTV4.mmod S 1" ) 
} 
 
 
# record for PLC tag <JTV5.CVAL> of type <REAL>
record( ao, "$(IOC):JTV5-CVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.CVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV5.ORBV> of type <REAL>
record( ao, "$(IOC):JTV5-ORBV" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.ORBV S 1" ) 
} 
 
 
# record for PLC tag <JTV5.OVAL> of type <REAL>
record( ao, "$(IOC):JTV5-OVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.OVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV5.MIN> of type <REAL>
record( ao, "$(IOC):JTV5-MIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.MIN S 1" ) 
} 
 
 
# record for PLC tag <JTV5.MAX> of type <REAL>
record( ao, "$(IOC):JTV5-MAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.MAX S 1" ) 
} 
 
 
# record for PLC tag <JTV5.DMIN> of type <REAL>
record( ao, "$(IOC):JTV5-DMIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.DMIN S 1" ) 
} 
 
 
# record for PLC tag <JTV5.DMAX> of type <REAL>
record( ao, "$(IOC):JTV5-DMAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.DMAX S 1" ) 
} 
 
 
# record for PLC tag <JTV5.VAL> of type <REAL>
record( ao, "$(IOC):JTV5-VAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.VAL S 1" ) 
} 
 
 
# record for PLC tag <JTV5.SVAL> of type <REAL>
record( ao, "$(IOC):JTV5-SVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.SVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV5.MVAL> of type <REAL>
record( ao, "$(IOC):JTV5-MVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.MVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV5.KP> of type <REAL>
record( ao, "$(IOC):JTV5-KP" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.KP S 1" ) 
} 
 
 
# record for PLC tag <JTV5.KI> of type <REAL>
record( ao, "$(IOC):JTV5-KI" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.KI S 1" ) 
} 
 
 
# record for PLC tag <JTV5.KD> of type <REAL>
record( ao, "$(IOC):JTV5-KD" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.KD S 1" ) 
} 
 
 
# record for PLC tag <JTV5.MDt> of type <REAL>
record( ao, "$(IOC):JTV5-MDt" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.MDt S 1" ) 
} 
 
 
# record for PLC tag <JTV5.MODE> of type <INT>
record( ao, "$(IOC):JTV5-MODE" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.MODE S 1" ) 
} 
 
 
# record for PLC tag <JTV5.PV_Select> of type <INT>
record( ao, "$(IOC):JTV5-PV_Select" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV5.PV_Select S 1" ) 
} 
 
 
# record for PLC tag <JTV5.mmod> of type <BOOL>
record( bo, "$(IOC):JTV5-mmod" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) JTV5.mmod S 1" ) 
} 
 
 
# record for PLC tag <JTV6.CVAL> of type <REAL>
record( ao, "$(IOC):JTV6-CVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.CVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV6.ORBV> of type <REAL>
record( ao, "$(IOC):JTV6-ORBV" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.ORBV S 1" ) 
} 
 
 
# record for PLC tag <JTV6.OVAL> of type <REAL>
record( ao, "$(IOC):JTV6-OVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.OVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV6.MIN> of type <REAL>
record( ao, "$(IOC):JTV6-MIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.MIN S 1" ) 
} 
 
 
# record for PLC tag <JTV6.MAX> of type <REAL>
record( ao, "$(IOC):JTV6-MAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.MAX S 1" ) 
} 
 
 
# record for PLC tag <JTV6.DMIN> of type <REAL>
record( ao, "$(IOC):JTV6-DMIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.DMIN S 1" ) 
} 
 
 
# record for PLC tag <JTV6.DMAX> of type <REAL>
record( ao, "$(IOC):JTV6-DMAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.DMAX S 1" ) 
} 
 
 
# record for PLC tag <JTV6.VAL> of type <REAL>
record( ao, "$(IOC):JTV6-VAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.VAL S 1" ) 
} 
 
 
# record for PLC tag <JTV6.SVAL> of type <REAL>
record( ao, "$(IOC):JTV6-SVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.SVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV6.MVAL> of type <REAL>
record( ao, "$(IOC):JTV6-MVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.MVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV6.KP> of type <REAL>
record( ao, "$(IOC):JTV6-KP" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.KP S 1" ) 
} 
 
 
# record for PLC tag <JTV6.KI> of type <REAL>
record( ao, "$(IOC):JTV6-KI" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.KI S 1" ) 
} 
 
 
# record for PLC tag <JTV6.KD> of type <REAL>
record( ao, "$(IOC):JTV6-KD" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.KD S 1" ) 
} 
 
 
# record for PLC tag <JTV6.MDt> of type <REAL>
record( ao, "$(IOC):JTV6-MDt" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.MDt S 1" ) 
} 
 
 
# record for PLC tag <JTV6.MODE> of type <INT>
record( ao, "$(IOC):JTV6-MODE" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.MODE S 1" ) 
} 
 
 
# record for PLC tag <JTV6.PV_Select> of type <INT>
record( ao, "$(IOC):JTV6-PV_Select" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV6.PV_Select S 1" ) 
} 
 
 
# record for PLC tag <JTV6.mmod> of type <BOOL>
record( bo, "$(IOC):JTV6-mmod" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) JTV6.mmod S 1" ) 
} 
 
 
# record for PLC tag <JTV7.CVAL> of type <REAL>
record( ao, "$(IOC):JTV7-CVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.CVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV7.ORBV> of type <REAL>
record( ao, "$(IOC):JTV7-ORBV" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.ORBV S 1" ) 
} 
 
 
# record for PLC tag <JTV7.OVAL> of type <REAL>
record( ao, "$(IOC):JTV7-OVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.OVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV7.MIN> of type <REAL>
record( ao, "$(IOC):JTV7-MIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.MIN S 1" ) 
} 
 
 
# record for PLC tag <JTV7.MAX> of type <REAL>
record( ao, "$(IOC):JTV7-MAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.MAX S 1" ) 
} 
 
 
# record for PLC tag <JTV7.DMIN> of type <REAL>
record( ao, "$(IOC):JTV7-DMIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.DMIN S 1" ) 
} 
 
 
# record for PLC tag <JTV7.DMAX> of type <REAL>
record( ao, "$(IOC):JTV7-DMAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.DMAX S 1" ) 
} 
 
 
# record for PLC tag <JTV7.VAL> of type <REAL>
record( ao, "$(IOC):JTV7-VAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.VAL S 1" ) 
} 
 
 
# record for PLC tag <JTV7.SVAL> of type <REAL>
record( ao, "$(IOC):JTV7-SVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.SVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV7.MVAL> of type <REAL>
record( ao, "$(IOC):JTV7-MVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.MVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV7.KP> of type <REAL>
record( ao, "$(IOC):JTV7-KP" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.KP S 1" ) 
} 
 
 
# record for PLC tag <JTV7.KI> of type <REAL>
record( ao, "$(IOC):JTV7-KI" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.KI S 1" ) 
} 
 
 
# record for PLC tag <JTV7.KD> of type <REAL>
record( ao, "$(IOC):JTV7-KD" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.KD S 1" ) 
} 
 
 
# record for PLC tag <JTV7.MDt> of type <REAL>
record( ao, "$(IOC):JTV7-MDt" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.MDt S 1" ) 
} 
 
 
# record for PLC tag <JTV7.MODE> of type <INT>
record( ao, "$(IOC):JTV7-MODE" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.MODE S 1" ) 
} 
 
 
# record for PLC tag <JTV7.PV_Select> of type <INT>
record( ao, "$(IOC):JTV7-PV_Select" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV7.PV_Select S 1" ) 
} 
 
 
# record for PLC tag <JTV7.mmod> of type <BOOL>
record( bo, "$(IOC):JTV7-mmod" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) JTV7.mmod S 1" ) 
} 
 
 
# record for PLC tag <JTV8.CVAL> of type <REAL>
record( ao, "$(IOC):JTV8-CVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.CVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV8.ORBV> of type <REAL>
record( ao, "$(IOC):JTV8-ORBV" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.ORBV S 1" ) 
} 
 
 
# record for PLC tag <JTV8.OVAL> of type <REAL>
record( ao, "$(IOC):JTV8-OVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.OVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV8.MIN> of type <REAL>
record( ao, "$(IOC):JTV8-MIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.MIN S 1" ) 
} 
 
 
# record for PLC tag <JTV8.MAX> of type <REAL>
record( ao, "$(IOC):JTV8-MAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.MAX S 1" ) 
} 
 
 
# record for PLC tag <JTV8.DMIN> of type <REAL>
record( ao, "$(IOC):JTV8-DMIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.DMIN S 1" ) 
} 
 
 
# record for PLC tag <JTV8.DMAX> of type <REAL>
record( ao, "$(IOC):JTV8-DMAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.DMAX S 1" ) 
} 
 
 
# record for PLC tag <JTV8.VAL> of type <REAL>
record( ao, "$(IOC):JTV8-VAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.VAL S 1" ) 
} 
 
 
# record for PLC tag <JTV8.SVAL> of type <REAL>
record( ao, "$(IOC):JTV8-SVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.SVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV8.MVAL> of type <REAL>
record( ao, "$(IOC):JTV8-MVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.MVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV8.KP> of type <REAL>
record( ao, "$(IOC):JTV8-KP" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.KP S 1" ) 
} 
 
 
# record for PLC tag <JTV8.KI> of type <REAL>
record( ao, "$(IOC):JTV8-KI" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.KI S 1" ) 
} 
 
 
# record for PLC tag <JTV8.KD> of type <REAL>
record( ao, "$(IOC):JTV8-KD" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.KD S 1" ) 
} 
 
 
# record for PLC tag <JTV8.MDt> of type <REAL>
record( ao, "$(IOC):JTV8-MDt" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.MDt S 1" ) 
} 
 
 
# record for PLC tag <JTV8.MODE> of type <INT>
record( ao, "$(IOC):JTV8-MODE" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.MODE S 1" ) 
} 
 
 
# record for PLC tag <JTV8.PV_Select> of type <INT>
record( ao, "$(IOC):JTV8-PV_Select" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV8.PV_Select S 1" ) 
} 
 
 
# record for PLC tag <JTV8.mmod> of type <BOOL>
record( bo, "$(IOC):JTV8-mmod" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) JTV8.mmod S 1" ) 
} 
 
 
# record for PLC tag <JTV9.CVAL> of type <REAL>
record( ao, "$(IOC):JTV9-CVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.CVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV9.ORBV> of type <REAL>
record( ao, "$(IOC):JTV9-ORBV" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.ORBV S 1" ) 
} 
 
 
# record for PLC tag <JTV9.OVAL> of type <REAL>
record( ao, "$(IOC):JTV9-OVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.OVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV9.MIN> of type <REAL>
record( ao, "$(IOC):JTV9-MIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.MIN S 1" ) 
} 
 
 
# record for PLC tag <JTV9.MAX> of type <REAL>
record( ao, "$(IOC):JTV9-MAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.MAX S 1" ) 
} 
 
 
# record for PLC tag <JTV9.DMIN> of type <REAL>
record( ao, "$(IOC):JTV9-DMIN" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.DMIN S 1" ) 
} 
 
 
# record for PLC tag <JTV9.DMAX> of type <REAL>
record( ao, "$(IOC):JTV9-DMAX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.DMAX S 1" ) 
} 
 
 
# record for PLC tag <JTV9.VAL> of type <REAL>
record( ao, "$(IOC):JTV9-VAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.VAL S 1" ) 
} 
 
 
# record for PLC tag <JTV9.SVAL> of type <REAL>
record( ao, "$(IOC):JTV9-SVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.SVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV9.MVAL> of type <REAL>
record( ao, "$(IOC):JTV9-MVAL" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.MVAL S 1" ) 
} 
 
 
# record for PLC tag <JTV9.KP> of type <REAL>
record( ao, "$(IOC):JTV9-KP" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.KP S 1" ) 
} 
 
 
# record for PLC tag <JTV9.KI> of type <REAL>
record( ao, "$(IOC):JTV9-KI" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.KI S 1" ) 
} 
 
 
# record for PLC tag <JTV9.KD> of type <REAL>
record( ao, "$(IOC):JTV9-KD" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.KD S 1" ) 
} 
 
 
# record for PLC tag <JTV9.MDt> of type <REAL>
record( ao, "$(IOC):JTV9-MDt" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.MDt S 1" ) 
} 
 
 
# record for PLC tag <JTV9.MODE> of type <INT>
record( ao, "$(IOC):JTV9-MODE" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.MODE S 1" ) 
} 
 
 
# record for PLC tag <JTV9.PV_Select> of type <INT>
record( ao, "$(IOC):JTV9-PV_Select" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) JTV9.PV_Select S 1" ) 
} 
 
 
# record for PLC tag <JTV9.mmod> of type <BOOL>
record( bo, "$(IOC):JTV9-mmod" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) JTV9.mmod S 1" ) 
} 
 
 
# record for PLC tag <JTV_Remote_SW> of type <BIT>
record( bo, "$(IOC):JTV_Remote_SW" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) JTV_Remote_SW S 1" ) 
} 
 
 
# record for PLC tag <LHe_Level_Intlck> of type <BOOL>
record( bo, "$(IOC):LHe_Level_Intlck" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) LHe_Level_Intlck S 1" ) 
} 
 
 
# record for PLC tag <LN2_Level_Intlck> of type <BOOL>
record( bo, "$(IOC):LN2_Level_Intlck" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) LN2_Level_Intlck S 1" ) 
} 
 
 
# record for PLC tag <MassFlow_Intlck> of type <BOOL>
record( bo, "$(IOC):MassFlow_Intlck" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) MassFlow_Intlck S 1" ) 
} 
 
 
# record for PLC tag <PWR_Loss_Intlck> of type <BOOL>
record( bo, "$(IOC):PWR_Loss_Intlck" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) PWR_Loss_Intlck S 1" ) 
} 
 
 
# record for PLC tag <P_He_Intlck_Fast> of type <BOOL>
record( bo, "$(IOC):P_He_Intlck_Fast" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) P_He_Intlck_Fast S 1" ) 
} 
 
 
# record for PLC tag <P_He_Intlck_Slw> of type <BOOL>
record( bo, "$(IOC):P_He_Intlck_Slw" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) P_He_Intlck_Slw S 1" ) 
} 
 
 
# record for PLC tag <P_N2_Intlck> of type <BOOL>
record( bo, "$(IOC):P_N2_Intlck" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) P_N2_Intlck S 1" ) 
} 
 
 
# record for PLC tag <P_Vac_Intlck> of type <BOOL>
record( bo, "$(IOC):P_Vac_Intlck" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) P_Vac_Intlck S 1" ) 
} 
 
 
# record for PLC tag <Reset_Comms> of type <BOOL>
record( bo, "$(IOC):Reset_Comms" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Reset_Comms S 1" ) 
} 
 
 
# record for PLC tag <SCC_TP_NS> of type <REAL>
record( ao, "$(IOC):SCC_TP_NS" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) SCC_TP_NS S 1" ) 
} 
 
 
# record for PLC tag <SCC_VP_EV6> of type <REAL>
record( ao, "$(IOC):SCC_VP_EV6" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) SCC_VP_EV6 S 1" ) 
} 
 
 
# record for PLC tag <TapCoil_QD_INTLCK> of type <BOOL>
record( bo, "$(IOC):TapCoil_QD_INTLCK" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) TapCoil_QD_INTLCK S 1" ) 
} 
 
 
# record for PLC tag <Turbo_Intlck> of type <BOOL>
record( bo, "$(IOC):Turbo_Intlck" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Turbo_Intlck S 1" ) 
} 
 
 
# record for PLC tag <USL_V> of type <REAL>
record( ao, "$(IOC):USL_V" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) USL_V S 1" ) 
} 
 
 
# record for PLC tag <Program:MPS_Control.MPS_Halt> of type <BOOL>
record( bo, "$(IOC)::MPS_Control-MPS_Halt" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:MPS_Control.MPS_Halt S 1" ) 
} 
 
 
# record for PLC tag <Program:MPS_Control.MPS_Local> of type <BOOL>
record( bo, "$(IOC)::MPS_Control-MPS_Local" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:MPS_Control.MPS_Local S 1" ) 
} 
 
 
# record for PLC tag <Program:MPS_Control.MPS_PowerOff> of type <BOOL>
record( bo, "$(IOC)::MPS_Control-MPS_PowerOff" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:MPS_Control.MPS_PowerOff S 1" ) 
} 
 
 
# record for PLC tag <Program:MPS_Control.MPS_PowerOn> of type <BOOL>
record( bo, "$(IOC)::MPS_Control-MPS_PowerOn" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:MPS_Control.MPS_PowerOn S 1" ) 
} 
 
 
# record for PLC tag <Program:MPS_Control.MPS_Rem> of type <BOOL>
record( bo, "$(IOC)::MPS_Control-MPS_Rem" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:MPS_Control.MPS_Rem S 1" ) 
} 
 
 
# record for PLC tag <Program:MPS_Control.MPS_Reset_Intlcks> of type <BOOL>
record( bo, "$(IOC)::MPS_Control-MPS_Reset_Intlcks" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:MPS_Control.MPS_Reset_Intlcks S 1" ) 
} 


# record for PLC tag <Program:MPS_Control.Ramp_Start of type <BOOL>
record( bo, "$(IOC)::MPS_Control-Ramp_Start" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:MPS_Control.Ramp_Start S 1" ) 
} 


# record for PLC tag <Program:MPS_Control.MPS_State> of type <DINT>
record( ao, "$(IOC)::MPS_Control-MPS_State" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "0" ) 
  field(OUT, "@$(PLCID) Program:MPS_Control.MPS_State S 1" ) 
} 
 
 
# record for PLC tag <Program:MPS_Control.MPS_Wa_Value> of type <REAL>
record( ao, "$(IOC)::MPS_Control-MPS_Wa_Value" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:MPS_Control.MPS_Wa_Value S 1" ) 
} 
 
 
# record for PLC tag <Program:MPS_Control.Slew_Rate> of type <REAL>
record( ao, "$(IOC)::MPS_Control-Slew_Rate" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:MPS_Control.Slew_Rate S 1" ) 
} 

# record for PLC tag <Program:MPS_Control.CurrentSet> of type <REAL>
record( ao, "$(IOC)::MPS_Control-CurrentSet" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:MPS_Control.CurrentSet S 1" ) 
} 
 
# record for PLC tag <Program:Solenoid_Cryo.Coil1_dT_High> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-Coil1_dT_High" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.Coil1_dT_High S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.Coil1_dT_limit> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-Coil1_dT_limit" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.Coil1_dT_limit S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.Coil2_dT_High> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-Coil2_dT_High" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.Coil2_dT_High S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.Coil2_dT_limit> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-Coil2_dT_limit" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.Coil2_dT_limit S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.Coil3_dT_High> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-Coil3_dT_High" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.Coil3_dT_High S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.Coil3_dT_limit> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-Coil3_dT_limit" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.Coil3_dT_limit S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.Coil4_dT_High> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-Coil4_dT_High" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.Coil4_dT_High S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.Coil4_dT_limit> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-Coil4_dT_limit" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.Coil4_dT_limit S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.DBox_DP_IWH> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-DBox_DP_IWH" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.DBox_DP_IWH S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.FI_CL_Buffer> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-FI_CL_Buffer" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.FI_CL_Buffer S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.I_MPS> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-I_MPS" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.I_MPS S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.I_Sol> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-I_Sol" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.I_Sol S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.JTV10_Interlock> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-JTV10_Interlock" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV10_Interlock S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.JTV1_Interlock> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-JTV1_Interlock" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV1_Interlock S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.JTV2_Interlock> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-JTV2_Interlock" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV2_Interlock S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.JTV3_Interlock> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-JTV3_Interlock" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV3_Interlock S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.JTV4_Interlock> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-JTV4_Interlock" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV4_Interlock S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.JTV5_Interlock> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-JTV5_Interlock" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV5_Interlock S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.JTV6_Interlock> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-JTV6_Interlock" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV6_Interlock S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.JTV7_Interlock> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-JTV7_Interlock" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV7_Interlock S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.JTV8_Interlock> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-JTV8_Interlock" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV8_Interlock S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.JTV9_Interlock> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-JTV9_Interlock" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.JTV9_Interlock S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.LL_LHe_Max> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-LL_LHe_Max" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.LL_LHe_Max S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.LL_LHe_Min> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-LL_LHe_Min" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.LL_LHe_Min S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.LL_LN2_Max> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-LL_LN2_Max" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.LL_LN2_Max S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.LL_LN2_Min> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-LL_LN2_Min" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.LL_LN2_Min S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.LS_CommReset> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-LS_CommReset" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.LS_CommReset S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.Manifold_VAC> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-Manifold_VAC" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.Manifold_VAC S 1" ) 
} 
 
# record for PLC tag <Manifold_VAC_Reset> of type <BOOL>
record( bo, "$(IOC):Manifold_VAC_Reset" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Manifold_VAC_Reset S 1" ) 
} 
 
# record for PLC tag <Program:Solenoid_Cryo.MF_Base_Flow> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-MF_Base_Flow" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.MF_Base_Flow S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.MF_Comm_Reset> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-MF_Comm_Reset" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.MF_Comm_Reset S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.MF_Comm_Warning> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-MF_Comm_Warning" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.MF_Comm_Warning S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.MF_Intlck_Preset> of type <DINT>
record( ao, "$(IOC)::Solenoid_Cryo-MF_Intlck_Preset" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.MF_Intlck_Preset S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.PT28012> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-PT28012" ) 
{
  field(ASG , "CRYO") 
  field(DESC, "Pressure at suction of compressors")
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OMSL, "closed_loop")
  field(DOL, "CPI28012 CPP")
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.PT28012 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.PT28017> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-PT28017" ) 
{
  field(ASG , "CRYO") 
  field(DESC, "Pressure before cryo ambient vaporizer")
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OMSL, "closed_loop")
  field(DOL, "CPI28017 CPP")
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.PT28017 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.PWR_Loss_10min> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-PWR_Loss_10min" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.PWR_Loss_10min S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.PWR_Loss_1min> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-PWR_Loss_1min" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.PWR_Loss_1min S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.PWR_Loss_5min> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-PWR_Loss_5min" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.PWR_Loss_5min S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.P_HeTank_Intlck_Fast> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-P_HeTank_Intlck_Fast" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.P_HeTank_Intlck_Fast S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.P_HeTank_Intlck_Slw> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-P_HeTank_Intlck_Slw" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.P_HeTank_Intlck_Slw S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.P_He_Return_Intlck> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-P_He_Return_Intlck" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.P_He_Return_Intlck S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.P_He_Supply_Intlck> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-P_He_Supply_Intlck" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.P_He_Supply_Intlck S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.P_N2Tank_Intlck> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-P_N2Tank_Intlck" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.P_N2Tank_Intlck S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.P_N2_Supply_Intlck> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Cryo-P_N2_Supply_Intlck" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.P_N2_Supply_Intlck S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.SCC_PI_HS_Max> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-SCC_PI_HS_Max" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.SCC_PI_HS_Max S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.SCC_PI_HT_LimFast> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-SCC_PI_HT_LimFast" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.SCC_PI_HT_LimFast S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.SCC_PI_HT_Max> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-SCC_PI_HT_Max" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.SCC_PI_HT_Max S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.SCC_PI_NS_Max> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-SCC_PI_NS_Max" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.SCC_PI_NS_Max S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.SCC_PI_NT_Max> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-SCC_PI_NT_Max" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.SCC_PI_NT_Max S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.SCC_TSD_HHX> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-SCC_TSD_HHX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.SCC_TSD_HHX S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.SCC_TSD_NHX> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-SCC_TSD_NHX" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.SCC_TSD_NHX S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.Turbo_MinSpeed> of type <DINT>
record( ao, "$(IOC)::Solenoid_Cryo-Turbo_MinSpeed" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.Turbo_MinSpeed S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Cryo.VacuumLimit> of type <REAL>
record( ao, "$(IOC)::Solenoid_Cryo-VacuumLimit" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.VacuumLimit S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil1.SG1> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil1-SG1" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil1.SG1 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil1.SG2> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil1-SG2" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil1.SG2 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil1.SG3> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil1-SG3" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil1.SG3 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil1.SG4> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil1-SG4" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil1.SG4 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil1.SG5> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil1-SG5" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil1.SG5 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil1.SG6> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil1-SG6" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil1.SG6 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil1_VTT_Max> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil1_VTT_Max" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil1_VTT_Max S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil2.SG1> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil2-SG1" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil2.SG1 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil2.SG2> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil2-SG2" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil2.SG2 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil2.SG3> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil2-SG3" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil2.SG3 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil2.SG4> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil2-SG4" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil2.SG4 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil2.SG5> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil2-SG5" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil2.SG5 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil2.SG6> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil2-SG6" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil2.SG6 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil2_VTT_Max> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil2_VTT_Max" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil2_VTT_Max S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil3.SG1> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil3-SG1" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil3.SG1 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil3.SG2> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil3-SG2" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil3.SG2 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil3.SG3> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil3-SG3" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil3.SG3 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil3.SG4> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil3-SG4" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil3.SG4 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil3.SG5> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil3-SG5" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil3.SG5 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil3.SG6> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil3-SG6" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil3.SG6 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil3_VTT_Max> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil3_VTT_Max" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil3_VTT_Max S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil4.SG1> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil4-SG1" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil4.SG1 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil4.SG2> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil4-SG2" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil4.SG2 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil4.SG3> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil4-SG3" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil4.SG3 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil4.SG4> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil4-SG4" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil4.SG4 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil4.SG5> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil4-SG5" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil4.SG5 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil4.SG6> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil4-SG6" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil4.SG6 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Coil4_VTT_Max> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Coil4_VTT_Max" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Coil4_VTT_Max S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.DumpDiodeRst_Time> of type <DINT>
record( ao, "$(IOC)::Solenoid_Magnet-DumpDiodeRst_Time" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.DumpDiodeRst_Time S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Dump_Diode_Reset> of type <BIT>
record( bo, "$(IOC)::Solenoid_Magnet-Dump_Diode_Reset" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Dump_Diode_Reset S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.FastQD_Volts> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-FastQD_Volts" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.FastQD_Volts S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.FastQD_V_Lim_Max> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-FastQD_V_Lim_Max" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.FastQD_V_Lim_Max S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Fast_QD_INTLCK> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-Fast_QD_INTLCK" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Fast_QD_INTLCK S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.HMI_DumpDiodeRst> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-HMI_DumpDiodeRst" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.HMI_DumpDiodeRst S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.HMI_FastDump_SW> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-HMI_FastDump_SW" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.HMI_FastDump_SW S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.HMI_SG_Rst> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-HMI_SG_Rst" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.HMI_SG_Rst S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.HMI_SlowDump_Sw> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-HMI_SlowDump_Sw" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.HMI_SlowDump_Sw S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.I_Hi_INTLCK> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-I_Hi_INTLCK" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.I_Hi_INTLCK S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.I_Hi_Threshold> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-I_Hi_Threshold" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.I_Hi_Threshold S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.I_Hi_TimerPRE> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-I_Hi_TimerPRE" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.I_Hi_TimerPRE S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.I_vs_Pressure> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-I_vs_Pressure" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.I_vs_Pressure S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.MPS_COM> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-MPS_COM" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(ZNAM, "0" )
  field(ONAM, "1" )
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.MPS_COM S 1" ) 
} 
 
# record for PLC tag <Program:Solenoid_Magnet.Normal_Current> of type <DINT>
record( ao, "$(IOC)::Solenoid_Magnet-Normal_Current" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Normal_Current S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Pressure_Dump> of type <DINT>
record( ao, "$(IOC)::Solenoid_Magnet-Pressure_Dump" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Pressure_Dump S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Pressure_Warning> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Pressure_Warning" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Pressure_Warning S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.PXI_Error_1> of type <BIT>
record( bo, "$(IOC)::Solenoid_Magnet-PXI_Error_1" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.PXI_Error_1 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.PXI_Error_Bit> of type <DINT>
record( ao, "$(IOC)::Solenoid_Magnet-PXI_Error_Bit" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.PXI_Error_Bit S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.PXI_Run_Bit> of type <BIT>
record( bo, "$(IOC)::Solenoid_Magnet-PXI_Run_Bit" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.PXI_Run_Bit S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.PXI_WatchDog_Intlck> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-PXI_WatchDog_Intlck" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.PXI_WatchDog_Intlck S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.QD_L3> of type <BIT>
record( bo, "$(IOC)::Solenoid_Magnet-QD_L3" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.QD_L3 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.QD_SUM> of type <BIT>
record( bo, "$(IOC)::Solenoid_Magnet-QD_SUM" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.QD_SUM S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.QD_U3> of type <BIT>
record( bo, "$(IOC)::Solenoid_Magnet-QD_U3" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.QD_U3 S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Quench_Current> of type <DINT>
record( ao, "$(IOC)::Solenoid_Magnet-Quench_Current" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Quench_Current S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.SG_Axial_Lim> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-SG_Axial_Lim" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.SG_Axial_Lim S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.SG_INTLCK> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-SG_INTLCK" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.SG_INTLCK S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.SG_Radial_Lim> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-SG_Radial_Lim" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.SG_Radial_Lim S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.Solenoid_VTT_Max> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-Solenoid_VTT_Max" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.Solenoid_VTT_Max S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.TTT_SHORT> of type <BIT>
record( bo, "$(IOC)::Solenoid_Magnet-TTT_SHORT" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.TTT_SHORT S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT10_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT10_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT10_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT10_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT10_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT10_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT11_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT11_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT11_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT11_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT11_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT11_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT12_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT12_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT12_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT12_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT12_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT12_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT13_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT13_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT13_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT13_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT13_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT13_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT14_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT14_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT14_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT14_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT14_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT14_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT15_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT15_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT15_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT15_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT15_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT15_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT16_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT16_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT16_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT16_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT16_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT16_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT17_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT17_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT17_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT17_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT17_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT17_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT18_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT18_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT18_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT18_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT18_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT18_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT19_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT19_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT19_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT19_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT19_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT19_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT20_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT20_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT20_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT21_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT21_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT21_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT3_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT3_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT3_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT4_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT4_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT4_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT4_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT4_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT4_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT5_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT5_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT5_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT5_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT5_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT5_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT6_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT6_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT6_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT6_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT6_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT6_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT7_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT7_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT7_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT7_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT7_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT7_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT8_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT8_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT8_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT8_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT8_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT8_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT9_1st> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT9_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT9_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.VTT9_Trip> of type <BOOL>
record( bo, "$(IOC)::Solenoid_Magnet-VTT9_Trip" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.VTT9_Trip S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_Magnet.V_QD_Max> of type <REAL>
record( ao, "$(IOC)::Solenoid_Magnet-V_QD_Max" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_Magnet.V_QD_Max S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.AC_Overcurrent> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-AC_Overcurrent" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.AC_Overcurrent S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.AC_Overcurrent_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-AC_Overcurrent_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.AC_Overcurrent_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.Array_Size> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-Array_Size" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.Array_Size S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.CableInterlock> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-CableInterlock" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.CableInterlock S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.CableInterlock_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-CableInterlock_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.CableInterlock_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.CEBAF_Overcurrent> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-CEBAF_Overcurrent" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.CEBAF_Overcurrent S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.CEBAF_Overcurrent_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-CEBAF_Overcurrent_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.CEBAF_Overcurrent_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.ESTOP_DoorSwitch> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-ESTOP_DoorSwitch" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.ESTOP_DoorSwitch S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.ESTOP_DoorSwitch_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-ESTOP_DoorSwitch_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.ESTOP_DoorSwitch_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.EventPoint> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-EventPoint" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.EventPoint S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.Extract_ArraySize> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-Extract_ArraySize" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.Extract_ArraySize S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.FastDumpSUM> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-FastDumpSUM" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.FastDumpSUM S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.FastDumpSUM_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-FastDumpSUM_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.FastDumpSUM_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.GroundFault> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-GroundFault" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.GroundFault S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.GroundFault_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-GroundFault_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.GroundFault_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.HeLiquidLevel> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-HeLiquidLevel" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.HeLiquidLevel S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.HeLiquidLevel_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-HeLiquidLevel_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.HeLiquidLevel_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.I> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-I" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.I S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.J> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-J" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.J S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.K> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-K" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.K S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.L> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-L" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.L S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadFlowDS> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-LeadFlowDS" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadFlowDS S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadFlowDS_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-LeadFlowDS_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadFlowDS_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadFlowUS> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-LeadFlowUS" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadFlowUS S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadFlowUS_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-LeadFlowUS_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadFlowUS_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadTempDS> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-LeadTempDS" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadTempDS S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadTempDSr> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-LeadTempDSr" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadTempDSr S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadTempDSr_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-LeadTempDSr_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadTempDSr_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadTempDS_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-LeadTempDS_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadTempDS_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadTempUS> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-LeadTempUS" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadTempUS S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadTempUSr> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-LeadTempUSr" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadTempUSr S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadTempUSr_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-LeadTempUSr_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadTempUSr_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadTempUS_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-LeadTempUS_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadTempUS_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadVoltageDS> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-LeadVoltageDS" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadVoltageDS S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadVoltageDS_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-LeadVoltageDS_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadVoltageDS_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadVoltageUS> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-LeadVoltageUS" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadVoltageUS S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.LeadVoltageUS_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-LeadVoltageUS_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.LeadVoltageUS_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.M> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-M" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.M S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.MainContactor> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-MainContactor" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.MainContactor S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.MainContactor_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-MainContactor_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.MainContactor_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.ModuleNumber> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-ModuleNumber" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.ModuleNumber S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.MPS_Voltage_PXI> of type <REAL>
record( ao, "$(IOC)::Solenoid_SOE-MPS_Voltage_PXI" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.MPS_Voltage_PXI S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.NextJ> of type <BOOL>
record( bo, "$(IOC)::Solenoid_SOE-NextJ" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.NextJ S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.OvertempString> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-OvertempString" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.OvertempString S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.OvertempString_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-OvertempString_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.OvertempString_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.PhaseDetect> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-PhaseDetect" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.PhaseDetect S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.PhaseDetect_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-PhaseDetect_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.PhaseDetect_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.PLCFastDump> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-PLCFastDump" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.PLCFastDump S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.PLCFastDump_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-PLCFastDump_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.PLCFastDump_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.PLCSlowDump> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-PLCSlowDump" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.PLCSlowDump S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.PLCSlowDump_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-PLCSlowDump_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.PLCSlowDump_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.PLCWatchdog> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-PLCWatchdog" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.PLCWatchdog S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.PLCWatchDog_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-PLCWatchDog_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.PLCWatchDog_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.QuenchDetector> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-QuenchDetector" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.QuenchDetector S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.QuenchDetector_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-QuenchDetector_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.QuenchDetector_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.Refrigerator_Monitor> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-Refrigerator_Monitor" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.Refrigerator_Monitor S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.Refrigerator_Monitor_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-Refrigerator_Monitor_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.Refrigerator_Monitor_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.SlowDumpSUM> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-SlowDumpSUM" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.SlowDumpSUM S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.SlowDumpSUM_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-SlowDumpSUM_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.SlowDumpSUM_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.SOE_ClearHistory> of type <BOOL>
record( bo, "$(IOC)::Solenoid_SOE-SOE_ClearHistory" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.SOE_ClearHistory S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.Vacuum_Sum> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-Vacuum_Sum" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.Vacuum_Sum S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.Vacuum_Sum_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-Vacuum_Sum_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.Vacuum_Sum_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.VTCableInterlock> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-VTCableInterlock" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.VTCableInterlock S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.VTCableInterlock_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-VTCableInterlock_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.VTCableInterlock_1st S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.WaterFlow> of type <BIT>
record( bo, "$(IOC)::Solenoid_SOE-WaterFlow" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.WaterFlow S 1" ) 
} 
 
 
# record for PLC tag <Program:Solenoid_SOE.WaterFlow_1st> of type <DINT>
record( ao, "$(IOC)::Solenoid_SOE-WaterFlow_1st" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Program:Solenoid_SOE.WaterFlow_1st S 1" ) 
} 


# record for PLC tag <DwellTime_Acc> of type <DINT>
record( ao, "$(IOC):DwellTime_Acc" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DwellTime_Acc S 1" ) 
} 
 
# record for PLC tag <DwellTime_Pre> of type <DINT>
record( ao, "$(IOC):DwellTime_Pre" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) DwellTime_Pre S 1" ) 
} 
 
# record for PLC tag <Ramp_State> of type <DINT>
record( ao, "$(IOC):Ramp_State" ) 
{
  field(ASG , "CRYO") 
  field(DTYP, "EtherIP" ) 
  field(SCAN, "Passive" ) 
  field(PREC, "2" ) 
  field(OUT, "@$(PLCID) Ramp_State S 1" ) 
} 
 



## record for PLC tag <Program:Solenoid_Cryo.LS_CommError> of type <BOOL>
#record( mbboDirect, "$(IOC)::Solenoid_Cryo-LS_CommError_1" ) 
#{
#  field(ASG , "CRYO") 
#  field(DTYP, "EtherIP" ) 
#  field(SCAN, "Passive" ) 
#  field(NOBT, "16" ) 
#  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.LS_CommError[0] S 1" ) 
#} 
# 
# 
# record for PLC tag <Program:Solenoid_Cryo.LS_CommError> of type <BOOL>
#record( mbboDirect, "$(IOC)::Solenoid_Cryo-LS_CommError_2" ) 
#{
#  field(ASG , "CRYO") 
#  field(DTYP, "EtherIP" ) 
#  field(SCAN, "Passive" ) 
#  field(NOBT, "16" ) 
#  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.LS_CommError[1] S 1" ) 
#} 
# 
# 
## record for PLC tag <Program:Solenoid_Cryo.LS_CommError> of type <BOOL>
#record( mbboDirect, "$(IOC)::Solenoid_Cryo-LS_CommError_3" ) 
#{
#  field(ASG , "CRYO") 
#  field(DTYP, "EtherIP" ) 
#  field(SCAN, "Passive" ) 
#  field(NOBT, "16" ) 
#  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.LS_CommError[2] S 1" ) 
#} 
# 
# 
## record for PLC tag <Program:Solenoid_Cryo.LS_Reset> of type <BOOL>
#record( mbboDirect, "$(IOC)::Solenoid_Cryo-LS_Reset_1" ) 
#{
#  field(ASG , "CRYO") 
#  field(DTYP, "EtherIP" ) 
#  field(SCAN, "Passive" ) 
#  field(NOBT, "16" ) 
#  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.LS_Reset[0] S 1" ) 
#} 
# 
# 
## record for PLC tag <Program:Solenoid_Cryo.LS_Reset> of type <BOOL>
#record( mbboDirect, "$(IOC)::Solenoid_Cryo-LS_Reset_2" ) 
#{
#  field(ASG , "CRYO") 
#  field(DTYP, "EtherIP" ) 
#  field(SCAN, "Passive" ) 
#  field(NOBT, "16" ) 
#  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.LS_Reset[1] S 1" ) 
#} 
# 
# 
## record for PLC tag <Program:Solenoid_Cryo.LS_Reset> of type <BOOL>
#record( mbboDirect, "$(IOC)::Solenoid_Cryo-LS_Reset_3" ) 
#{
#  field(ASG , "CRYO") 
#  field(DTYP, "EtherIP" ) 
#  field(SCAN, "Passive" ) 
#  field(NOBT, "16" ) 
#  field(OUT, "@$(PLCID) Program:Solenoid_Cryo.LS_Reset[2] S 1" ) 
#}
#