Running: ./testmodel.py --libraries=/home/hudson/saved_omc/libraries/.openmodelica/libraries/ --ompython_omhome=/usr Buildings_8_Buildings.Controls.OBC.CDL.Logical.Sources.Validation.PulseNegativeStartTime.conf.json
loadFile("/home/hudson/saved_omc/libraries/.openmodelica/libraries/ModelicaServices 4.0.0+maint.om/package.mo", uses=false)
loadFile("/home/hudson/saved_omc/libraries/.openmodelica/libraries/Complex 4.0.0+maint.om/package.mo", uses=false)
loadFile("/home/hudson/saved_omc/libraries/.openmodelica/libraries/Modelica 3.2.3+maint.om/package.mo", uses=false)
loadFile("/home/hudson/saved_omc/libraries/.openmodelica/libraries/Buildings 8.1.4-maint.8.1.x/package.mo", uses=false)
Using package Buildings with version 8.1.4 (/home/hudson/saved_omc/libraries/.openmodelica/libraries/Buildings 8.1.4-maint.8.1.x/package.mo)
Using package Modelica with version 3.2.3 (/home/hudson/saved_omc/libraries/.openmodelica/libraries/Modelica 3.2.3+maint.om/package.mo)
Using package Complex with version 4.0.0 (/home/hudson/saved_omc/libraries/.openmodelica/libraries/Complex 4.0.0+maint.om/package.mo)
Using package ModelicaServices with version 4.0.0 (/home/hudson/saved_omc/libraries/.openmodelica/libraries/ModelicaServices 4.0.0+maint.om/package.mo)
Running command: translateModel(Buildings.Controls.OBC.CDL.Logical.Sources.Validation.PulseNegativeStartTime,tolerance=1e-06,outputFormat="empty",numberOfIntervals=5000,variableFilter="",fileNamePrefix="Buildings_8_Buildings.Controls.OBC.CDL.Logical.Sources.Validation.PulseNegativeStartTime")
translateModel(Buildings.Controls.OBC.CDL.Logical.Sources.Validation.PulseNegativeStartTime,tolerance=1e-06,outputFormat="empty",numberOfIntervals=5000,variableFilter="",fileNamePrefix="Buildings_8_Buildings.Controls.OBC.CDL.Logical.Sources.Validation.PulseNegativeStartTime")
Notification: Performance of loadFile(/home/hudson/saved_omc/libraries/.openmodelica/libraries/ModelicaServices 4.0.0+maint.om/package.mo): time 0.00107/0.00107, allocations: 107.7 kB / 16.38 MB, free: 6.434 MB / 14.72 MB
Notification: Performance of loadFile(/home/hudson/saved_omc/libraries/.openmodelica/libraries/Complex 4.0.0+maint.om/package.mo): time 0.0011/0.0011, allocations: 192.7 kB / 17.31 MB, free: 5.777 MB / 14.72 MB
Notification: Performance of loadFile(/home/hudson/saved_omc/libraries/.openmodelica/libraries/Modelica 3.2.3+maint.om/package.mo): time 1.514/1.514, allocations: 205.1 MB / 223.2 MB, free: 12.24 MB / 190.1 MB
Notification: Performance of loadFile(/home/hudson/saved_omc/libraries/.openmodelica/libraries/Buildings 8.1.4-maint.8.1.x/package.mo): time 1.84/1.84, allocations: 292.3 MB / 0.5496 GB, free: 17.46 MB / 462.1 MB
Notification: Performance of FrontEnd - Absyn->SCode: time 2.875e-05/2.886e-05, allocations: 6.219 kB / 0.6729 GB, free: 5.879 MB / 0.545 GB
Notification: Performance of NFInst.instantiate(Buildings.Controls.OBC.CDL.Logical.Sources.Validation.PulseNegativeStartTime): time 0.002226/0.002273, allocations: 1.184 MB / 0.674 GB, free: 4.691 MB / 0.545 GB
Notification: Performance of NFInst.instExpressions: time 0.002939/0.005227, allocations: 2.17 MB / 0.6762 GB, free: 2.504 MB / 0.545 GB
Notification: Performance of NFInst.updateImplicitVariability: time 0.0001334/0.00538, allocations: 0 / 0.6762 GB, free: 2.504 MB / 0.545 GB
Notification: Performance of NFTyping.typeComponents: time 6.439e-05/0.005455, allocations: 19.69 kB / 0.6762 GB, free: 2.484 MB / 0.545 GB
Notification: Performance of NFTyping.typeBindings: time 0.0002057/0.005667, allocations: 91.2 kB / 0.6763 GB, free: 2.395 MB / 0.545 GB
Notification: Performance of NFTyping.typeClassSections: time 0.003074/0.00878, allocations: 1.395 MB / 0.6776 GB, free: 1.043 MB / 0.545 GB
Notification: Performance of NFFlatten.flatten: time 0.001322/0.01011, allocations: 1.33 MB / 0.6789 GB, free: 15.71 MB / 0.5606 GB
Notification: Performance of NFFlatten.resolveConnections: time 9.199e-05/0.01021, allocations: 24.75 kB / 0.679 GB, free: 15.69 MB / 0.5606 GB
Notification: Performance of NFEvalConstants.evaluate: time 0.0005484/0.01077, allocations: 483.2 kB / 0.6794 GB, free: 15.21 MB / 0.5606 GB
Notification: Performance of NFSimplifyModel.simplify: time 0.0004574/0.01123, allocations: 430.8 kB / 0.6798 GB, free: 14.79 MB / 0.5606 GB
Notification: Performance of NFPackage.collectConstants: time 0.0001593/0.0114, allocations: 108 kB / 0.6799 GB, free: 14.69 MB / 0.5606 GB
Notification: Performance of NFFlatten.collectFunctions: time 0.0002072/0.01161, allocations: 120 kB / 0.68 GB, free: 14.57 MB / 0.5606 GB
Notification: Performance of combineBinaries: time 0.0006685/0.01229, allocations: 0.8188 MB / 0.6808 GB, free: 13.75 MB / 0.5606 GB
Notification: Performance of replaceArrayConstructors: time 0.0001765/0.01247, allocations: 264 kB / 0.6811 GB, free: 13.48 MB / 0.5606 GB
Notification: Performance of NFVerifyModel.verify: time 0.0001554/0.01263, allocations: 95.88 kB / 0.6812 GB, free: 13.39 MB / 0.5606 GB
Notification: Performance of FrontEnd: time 5.342e-05/0.01269, allocations: 11.94 kB / 0.6812 GB, free: 13.38 MB / 0.5606 GB
Notification: Model statistics after passing the front-end and creating the data structures used by the back-end:
 * Number of equations: 15 (15)
 * Number of variables: 15 (15)
Notification: Performance of Bindings: time 0.002717/0.01542, allocations: 2.621 MB / 0.6838 GB, free: 10.65 MB / 0.5606 GB
Notification: Performance of FunctionAlias: time 0.000636/0.01607, allocations: 0.4964 MB / 0.6842 GB, free: 10.15 MB / 0.5606 GB
Notification: Performance of Early Inline: time 0.003278/0.01935, allocations: 3.065 MB / 0.6872 GB, free: 7.059 MB / 0.5606 GB
Notification: Performance of simplify1: time 3.964e-05/0.01941, allocations: 35.94 kB / 0.6873 GB, free: 7.023 MB / 0.5606 GB
Notification: Performance of Alias: time 0.0001785/0.0196, allocations: 153.4 kB / 0.6874 GB, free: 6.832 MB / 0.5606 GB
Notification: Performance of simplify2: time 2.569e-05/0.01963, allocations: 31.94 kB / 0.6874 GB, free: 6.801 MB / 0.5606 GB
Notification: Performance of Events: time 0.002829/0.02246, allocations: 2.219 MB / 0.6896 GB, free: 4.566 MB / 0.5606 GB
Notification: Performance of Detect States: time 0.002145/0.02462, allocations: 1.809 MB / 0.6914 GB, free: 2.742 MB / 0.5606 GB
Notification: Performance of Partitioning: time 0.0003537/0.02499, allocations: 317.5 kB / 0.6917 GB, free: 2.316 MB / 0.5606 GB
Notification: Performance of Causalize: time 0.001301/0.02629, allocations: 1.233 MB / 0.6929 GB, free: 0.9727 MB / 0.5606 GB
Notification: Performance of After Index Reduction Inline: time 0.002993/0.0293, allocations: 2.495 MB / 0.6953 GB, free: 14.45 MB / 0.5762 GB
Notification: Performance of Inline: time 0.003908/0.03322, allocations: 3.543 MB / 0.6988 GB, free: 10.87 MB / 0.5762 GB
Notification: Performance of Partitioning: time 9.752e-05/0.03334, allocations: 79.55 kB / 0.6989 GB, free: 10.79 MB / 0.5762 GB
Notification: Performance of Cleanup: time 7.519e-05/0.03342, allocations: 67.84 kB / 0.6989 GB, free: 10.72 MB / 0.5762 GB
Warning: NBResolveSingularities.balanceInitialization reports an overdetermined initialization!
Checking for consistency is not yet supported, following equations had to be removed:
        [ALGO] (3) ($RES_SIM_0)
[----] booPul_c5.t0 := if $FUN_15 + booPul_c5.period * integer(time / booPul_c5.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_15 + booPul_c5.period * integer(time / booPul_c5.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_15 + booPul_c5.period * integer(time / booPul_c5.period)));
[----] booPul_c5.t1 := booPul_c5.t0 + booPul_c5.width * booPul_c5.period;

[----] if time + booPul_c5.period < booPul_c5.t1 then
[----]   booPul_c5.t0 := booPul_c5.t0 - booPul_c5.period;
[----]   booPul_c5.t1 := booPul_c5.t1 - booPul_c5.period;
[----] end if;

[----] if time >= booPul_c5.t1 then
[----]   booPul_c5.t0 := booPul_c5.t0 + booPul_c5.period;
[----] elseif time < booPul_c5.t0 then
[----]   booPul_c5.t1 := booPul_c5.t1 - booPul_c5.period;
[----] end if;

[----] if booPul_c5.t0 < booPul_c5.t1 then
[----]   assert(booPul_c5.t0 <= time and time < booPul_c5.t1, "PulseNegativeStartTime.booPul_c5: Implementation error in initial time calculation: t0 = " + String(booPul_c5.t0, 6, 0, true) + ", t1 = " + String(booPul_c5.t1, 6, 0, true) + ",  period = " + String(booPul_c5.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_c5.y := time >= booPul_c5.t0 and time < booPul_c5.t1;
[----] elseif true then
[----]   assert(booPul_c5.t1 <= time and time < booPul_c5.t0, "PulseNegativeStartTime.booPul_c5: Implementation error in initial time calculation: t0 = " + String(booPul_c5.t0, 6, 0, true) + ", t1 = " + String(booPul_c5.t1, 6, 0, true) + ",  period = " + String(booPul_c5.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_c5.y := not (time >= booPul_c5.t1 and time < booPul_c5.t0);
[----] end if;

         slice: {1, 2};
        [ALGO] (3) ($RES_SIM_1)
[----] booPul_b5.t0 := if $FUN_14 + booPul_b5.period * integer(time / booPul_b5.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_14 + booPul_b5.period * integer(time / booPul_b5.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_14 + booPul_b5.period * integer(time / booPul_b5.period)));
[----] booPul_b5.t1 := booPul_b5.t0 + booPul_b5.width * booPul_b5.period;

[----] if time + booPul_b5.period < booPul_b5.t1 then
[----]   booPul_b5.t0 := booPul_b5.t0 - booPul_b5.period;
[----]   booPul_b5.t1 := booPul_b5.t1 - booPul_b5.period;
[----] end if;

[----] if time >= booPul_b5.t1 then
[----]   booPul_b5.t0 := booPul_b5.t0 + booPul_b5.period;
[----] elseif time < booPul_b5.t0 then
[----]   booPul_b5.t1 := booPul_b5.t1 - booPul_b5.period;
[----] end if;

[----] if booPul_b5.t0 < booPul_b5.t1 then
[----]   assert(booPul_b5.t0 <= time and time < booPul_b5.t1, "PulseNegativeStartTime.booPul_b5: Implementation error in initial time calculation: t0 = " + String(booPul_b5.t0, 6, 0, true) + ", t1 = " + String(booPul_b5.t1, 6, 0, true) + ",  period = " + String(booPul_b5.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_b5.y := time >= booPul_b5.t0 and time < booPul_b5.t1;
[----] elseif true then
[----]   assert(booPul_b5.t1 <= time and time < booPul_b5.t0, "PulseNegativeStartTime.booPul_b5: Implementation error in initial time calculation: t0 = " + String(booPul_b5.t0, 6, 0, true) + ", t1 = " + String(booPul_b5.t1, 6, 0, true) + ",  period = " + String(booPul_b5.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_b5.y := not (time >= booPul_b5.t1 and time < booPul_b5.t0);
[----] end if;

         slice: {1, 2};
        [ALGO] (3) ($RES_SIM_2)
[----] booPul_a5.t0 := if $FUN_13 + booPul_a5.period * integer(time / booPul_a5.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_13 + booPul_a5.period * integer(time / booPul_a5.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_13 + booPul_a5.period * integer(time / booPul_a5.period)));
[----] booPul_a5.t1 := booPul_a5.t0 + booPul_a5.width * booPul_a5.period;

[----] if time + booPul_a5.period < booPul_a5.t1 then
[----]   booPul_a5.t0 := booPul_a5.t0 - booPul_a5.period;
[----]   booPul_a5.t1 := booPul_a5.t1 - booPul_a5.period;
[----] end if;

[----] if time >= booPul_a5.t1 then
[----]   booPul_a5.t0 := booPul_a5.t0 + booPul_a5.period;
[----] elseif time < booPul_a5.t0 then
[----]   booPul_a5.t1 := booPul_a5.t1 - booPul_a5.period;
[----] end if;

[----] if booPul_a5.t0 < booPul_a5.t1 then
[----]   assert(booPul_a5.t0 <= time and time < booPul_a5.t1, "PulseNegativeStartTime.booPul_a5: Implementation error in initial time calculation: t0 = " + String(booPul_a5.t0, 6, 0, true) + ", t1 = " + String(booPul_a5.t1, 6, 0, true) + ",  period = " + String(booPul_a5.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_a5.y := time >= booPul_a5.t0 and time < booPul_a5.t1;
[----] elseif true then
[----]   assert(booPul_a5.t1 <= time and time < booPul_a5.t0, "PulseNegativeStartTime.booPul_a5: Implementation error in initial time calculation: t0 = " + String(booPul_a5.t0, 6, 0, true) + ", t1 = " + String(booPul_a5.t1, 6, 0, true) + ",  period = " + String(booPul_a5.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_a5.y := not (time >= booPul_a5.t1 and time < booPul_a5.t0);
[----] end if;

         slice: {1, 2};
        [ALGO] (3) ($RES_SIM_3)
[----] booPul_c4.t0 := if $FUN_12 + booPul_c4.period * integer(time / booPul_c4.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_12 + booPul_c4.period * integer(time / booPul_c4.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_12 + booPul_c4.period * integer(time / booPul_c4.period)));
[----] booPul_c4.t1 := booPul_c4.t0 + booPul_c4.width * booPul_c4.period;

[----] if time + booPul_c4.period < booPul_c4.t1 then
[----]   booPul_c4.t0 := booPul_c4.t0 - booPul_c4.period;
[----]   booPul_c4.t1 := booPul_c4.t1 - booPul_c4.period;
[----] end if;

[----] if time >= booPul_c4.t1 then
[----]   booPul_c4.t0 := booPul_c4.t0 + booPul_c4.period;
[----] elseif time < booPul_c4.t0 then
[----]   booPul_c4.t1 := booPul_c4.t1 - booPul_c4.period;
[----] end if;

[----] if booPul_c4.t0 < booPul_c4.t1 then
[----]   assert(booPul_c4.t0 <= time and time < booPul_c4.t1, "PulseNegativeStartTime.booPul_c4: Implementation error in initial time calculation: t0 = " + String(booPul_c4.t0, 6, 0, true) + ", t1 = " + String(booPul_c4.t1, 6, 0, true) + ",  period = " + String(booPul_c4.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_c4.y := time >= booPul_c4.t0 and time < booPul_c4.t1;
[----] elseif true then
[----]   assert(booPul_c4.t1 <= time and time < booPul_c4.t0, "PulseNegativeStartTime.booPul_c4: Implementation error in initial time calculation: t0 = " + String(booPul_c4.t0, 6, 0, true) + ", t1 = " + String(booPul_c4.t1, 6, 0, true) + ",  period = " + String(booPul_c4.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_c4.y := not (time >= booPul_c4.t1 and time < booPul_c4.t0);
[----] end if;

         slice: {1, 2};
        [ALGO] (3) ($RES_SIM_4)
[----] booPul_b4.t0 := if $FUN_11 + booPul_b4.period * integer(time / booPul_b4.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_11 + booPul_b4.period * integer(time / booPul_b4.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_11 + booPul_b4.period * integer(time / booPul_b4.period)));
[----] booPul_b4.t1 := booPul_b4.t0 + booPul_b4.width * booPul_b4.period;

[----] if time + booPul_b4.period < booPul_b4.t1 then
[----]   booPul_b4.t0 := booPul_b4.t0 - booPul_b4.period;
[----]   booPul_b4.t1 := booPul_b4.t1 - booPul_b4.period;
[----] end if;

[----] if time >= booPul_b4.t1 then
[----]   booPul_b4.t0 := booPul_b4.t0 + booPul_b4.period;
[----] elseif time < booPul_b4.t0 then
[----]   booPul_b4.t1 := booPul_b4.t1 - booPul_b4.period;
[----] end if;

[----] if booPul_b4.t0 < booPul_b4.t1 then
[----]   assert(booPul_b4.t0 <= time and time < booPul_b4.t1, "PulseNegativeStartTime.booPul_b4: Implementation error in initial time calculation: t0 = " + String(booPul_b4.t0, 6, 0, true) + ", t1 = " + String(booPul_b4.t1, 6, 0, true) + ",  period = " + String(booPul_b4.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_b4.y := time >= booPul_b4.t0 and time < booPul_b4.t1;
[----] elseif true then
[----]   assert(booPul_b4.t1 <= time and time < booPul_b4.t0, "PulseNegativeStartTime.booPul_b4: Implementation error in initial time calculation: t0 = " + String(booPul_b4.t0, 6, 0, true) + ", t1 = " + String(booPul_b4.t1, 6, 0, true) + ",  period = " + String(booPul_b4.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_b4.y := not (time >= booPul_b4.t1 and time < booPul_b4.t0);
[----] end if;

         slice: {1, 2};
        [ALGO] (3) ($RES_SIM_5)
[----] booPul_a4.t0 := if $FUN_10 + booPul_a4.period * integer(time / booPul_a4.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_10 + booPul_a4.period * integer(time / booPul_a4.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_10 + booPul_a4.period * integer(time / booPul_a4.period)));
[----] booPul_a4.t1 := booPul_a4.t0 + booPul_a4.width * booPul_a4.period;

[----] if time + booPul_a4.period < booPul_a4.t1 then
[----]   booPul_a4.t0 := booPul_a4.t0 - booPul_a4.period;
[----]   booPul_a4.t1 := booPul_a4.t1 - booPul_a4.period;
[----] end if;

[----] if time >= booPul_a4.t1 then
[----]   booPul_a4.t0 := booPul_a4.t0 + booPul_a4.period;
[----] elseif time < booPul_a4.t0 then
[----]   booPul_a4.t1 := booPul_a4.t1 - booPul_a4.period;
[----] end if;

[----] if booPul_a4.t0 < booPul_a4.t1 then
[----]   assert(booPul_a4.t0 <= time and time < booPul_a4.t1, "PulseNegativeStartTime.booPul_a4: Implementation error in initial time calculation: t0 = " + String(booPul_a4.t0, 6, 0, true) + ", t1 = " + String(booPul_a4.t1, 6, 0, true) + ",  period = " + String(booPul_a4.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_a4.y := time >= booPul_a4.t0 and time < booPul_a4.t1;
[----] elseif true then
[----]   assert(booPul_a4.t1 <= time and time < booPul_a4.t0, "PulseNegativeStartTime.booPul_a4: Implementation error in initial time calculation: t0 = " + String(booPul_a4.t0, 6, 0, true) + ", t1 = " + String(booPul_a4.t1, 6, 0, true) + ",  period = " + String(booPul_a4.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_a4.y := not (time >= booPul_a4.t1 and time < booPul_a4.t0);
[----] end if;

         slice: {1, 2};
        [ALGO] (3) ($RES_SIM_6)
[----] booPul_c3.t0 := if $FUN_9 + booPul_c3.period * integer(time / booPul_c3.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_9 + booPul_c3.period * integer(time / booPul_c3.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_9 + booPul_c3.period * integer(time / booPul_c3.period)));
[----] booPul_c3.t1 := booPul_c3.t0 + booPul_c3.width * booPul_c3.period;

[----] if time + booPul_c3.period < booPul_c3.t1 then
[----]   booPul_c3.t0 := booPul_c3.t0 - booPul_c3.period;
[----]   booPul_c3.t1 := booPul_c3.t1 - booPul_c3.period;
[----] end if;

[----] if time >= booPul_c3.t1 then
[----]   booPul_c3.t0 := booPul_c3.t0 + booPul_c3.period;
[----] elseif time < booPul_c3.t0 then
[----]   booPul_c3.t1 := booPul_c3.t1 - booPul_c3.period;
[----] end if;

[----] if booPul_c3.t0 < booPul_c3.t1 then
[----]   assert(booPul_c3.t0 <= time and time < booPul_c3.t1, "PulseNegativeStartTime.booPul_c3: Implementation error in initial time calculation: t0 = " + String(booPul_c3.t0, 6, 0, true) + ", t1 = " + String(booPul_c3.t1, 6, 0, true) + ",  period = " + String(booPul_c3.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_c3.y := time >= booPul_c3.t0 and time < booPul_c3.t1;
[----] elseif true then
[----]   assert(booPul_c3.t1 <= time and time < booPul_c3.t0, "PulseNegativeStartTime.booPul_c3: Implementation error in initial time calculation: t0 = " + String(booPul_c3.t0, 6, 0, true) + ", t1 = " + String(booPul_c3.t1, 6, 0, true) + ",  period = " + String(booPul_c3.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_c3.y := not (time >= booPul_c3.t1 and time < booPul_c3.t0);
[----] end if;

         slice: {1, 2};
        [ALGO] (3) ($RES_SIM_7)
[----] booPul_b3.t0 := if $FUN_8 + booPul_b3.period * integer(time / booPul_b3.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_8 + booPul_b3.period * integer(time / booPul_b3.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_8 + booPul_b3.period * integer(time / booPul_b3.period)));
[----] booPul_b3.t1 := booPul_b3.t0 + booPul_b3.width * booPul_b3.period;

[----] if time + booPul_b3.period < booPul_b3.t1 then
[----]   booPul_b3.t0 := booPul_b3.t0 - booPul_b3.period;
[----]   booPul_b3.t1 := booPul_b3.t1 - booPul_b3.period;
[----] end if;

[----] if time >= booPul_b3.t1 then
[----]   booPul_b3.t0 := booPul_b3.t0 + booPul_b3.period;
[----] elseif time < booPul_b3.t0 then
[----]   booPul_b3.t1 := booPul_b3.t1 - booPul_b3.period;
[----] end if;

[----] if booPul_b3.t0 < booPul_b3.t1 then
[----]   assert(booPul_b3.t0 <= time and time < booPul_b3.t1, "PulseNegativeStartTime.booPul_b3: Implementation error in initial time calculation: t0 = " + String(booPul_b3.t0, 6, 0, true) + ", t1 = " + String(booPul_b3.t1, 6, 0, true) + ",  period = " + String(booPul_b3.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_b3.y := time >= booPul_b3.t0 and time < booPul_b3.t1;
[----] elseif true then
[----]   assert(booPul_b3.t1 <= time and time < booPul_b3.t0, "PulseNegativeStartTime.booPul_b3: Implementation error in initial time calculation: t0 = " + String(booPul_b3.t0, 6, 0, true) + ", t1 = " + String(booPul_b3.t1, 6, 0, true) + ",  period = " + String(booPul_b3.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_b3.y := not (time >= booPul_b3.t1 and time < booPul_b3.t0);
[----] end if;

         slice: {1, 2};
        [ALGO] (3) ($RES_SIM_8)
[----] booPul_a3.t0 := if $FUN_7 + booPul_a3.period * integer(time / booPul_a3.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_7 + booPul_a3.period * integer(time / booPul_a3.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_7 + booPul_a3.period * integer(time / booPul_a3.period)));
[----] booPul_a3.t1 := booPul_a3.t0 + booPul_a3.width * booPul_a3.period;

[----] if time + booPul_a3.period < booPul_a3.t1 then
[----]   booPul_a3.t0 := booPul_a3.t0 - booPul_a3.period;
[----]   booPul_a3.t1 := booPul_a3.t1 - booPul_a3.period;
[----] end if;

[----] if time >= booPul_a3.t1 then
[----]   booPul_a3.t0 := booPul_a3.t0 + booPul_a3.period;
[----] elseif time < booPul_a3.t0 then
[----]   booPul_a3.t1 := booPul_a3.t1 - booPul_a3.period;
[----] end if;

[----] if booPul_a3.t0 < booPul_a3.t1 then
[----]   assert(booPul_a3.t0 <= time and time < booPul_a3.t1, "PulseNegativeStartTime.booPul_a3: Implementation error in initial time calculation: t0 = " + String(booPul_a3.t0, 6, 0, true) + ", t1 = " + String(booPul_a3.t1, 6, 0, true) + ",  period = " + String(booPul_a3.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_a3.y := time >= booPul_a3.t0 and time < booPul_a3.t1;
[----] elseif true then
[----]   assert(booPul_a3.t1 <= time and time < booPul_a3.t0, "PulseNegativeStartTime.booPul_a3: Implementation error in initial time calculation: t0 = " + String(booPul_a3.t0, 6, 0, true) + ", t1 = " + String(booPul_a3.t1, 6, 0, true) + ",  period = " + String(booPul_a3.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_a3.y := not (time >= booPul_a3.t1 and time < booPul_a3.t0);
[----] end if;

         slice: {1, 2};
        [ALGO] (3) ($RES_SIM_9)
[----] booPul_c2.t0 := if $FUN_6 + booPul_c2.period * integer(time / booPul_c2.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_6 + booPul_c2.period * integer(time / booPul_c2.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_6 + booPul_c2.period * integer(time / booPul_c2.period)));
[----] booPul_c2.t1 := booPul_c2.t0 + booPul_c2.width * booPul_c2.period;

[----] if time + booPul_c2.period < booPul_c2.t1 then
[----]   booPul_c2.t0 := booPul_c2.t0 - booPul_c2.period;
[----]   booPul_c2.t1 := booPul_c2.t1 - booPul_c2.period;
[----] end if;

[----] if time >= booPul_c2.t1 then
[----]   booPul_c2.t0 := booPul_c2.t0 + booPul_c2.period;
[----] elseif time < booPul_c2.t0 then
[----]   booPul_c2.t1 := booPul_c2.t1 - booPul_c2.period;
[----] end if;

[----] if booPul_c2.t0 < booPul_c2.t1 then
[----]   assert(booPul_c2.t0 <= time and time < booPul_c2.t1, "PulseNegativeStartTime.booPul_c2: Implementation error in initial time calculation: t0 = " + String(booPul_c2.t0, 6, 0, true) + ", t1 = " + String(booPul_c2.t1, 6, 0, true) + ",  period = " + String(booPul_c2.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_c2.y := time >= booPul_c2.t0 and time < booPul_c2.t1;
[----] elseif true then
[----]   assert(booPul_c2.t1 <= time and time < booPul_c2.t0, "PulseNegativeStartTime.booPul_c2: Implementation error in initial time calculation: t0 = " + String(booPul_c2.t0, 6, 0, true) + ", t1 = " + String(booPul_c2.t1, 6, 0, true) + ",  period = " + String(booPul_c2.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_c2.y := not (time >= booPul_c2.t1 and time < booPul_c2.t0);
[----] end if;

         slice: {1, 2};
        [ALGO] (3) ($RES_SIM_10)
[----] booPul_b2.t0 := if $FUN_5 + booPul_b2.period * integer(time / booPul_b2.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_5 + booPul_b2.period * integer(time / booPul_b2.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_5 + booPul_b2.period * integer(time / booPul_b2.period)));
[----] booPul_b2.t1 := booPul_b2.t0 + booPul_b2.width * booPul_b2.period;

[----] if time + booPul_b2.period < booPul_b2.t1 then
[----]   booPul_b2.t0 := booPul_b2.t0 - booPul_b2.period;
[----]   booPul_b2.t1 := booPul_b2.t1 - booPul_b2.period;
[----] end if;

[----] if time >= booPul_b2.t1 then
[----]   booPul_b2.t0 := booPul_b2.t0 + booPul_b2.period;
[----] elseif time < booPul_b2.t0 then
[----]   booPul_b2.t1 := booPul_b2.t1 - booPul_b2.period;
[----] end if;

[----] if booPul_b2.t0 < booPul_b2.t1 then
[----]   assert(booPul_b2.t0 <= time and time < booPul_b2.t1, "PulseNegativeStartTime.booPul_b2: Implementation error in initial time calculation: t0 = " + String(booPul_b2.t0, 6, 0, true) + ", t1 = " + String(booPul_b2.t1, 6, 0, true) + ",  period = " + String(booPul_b2.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_b2.y := time >= booPul_b2.t0 and time < booPul_b2.t1;
[----] elseif true then
[----]   assert(booPul_b2.t1 <= time and time < booPul_b2.t0, "PulseNegativeStartTime.booPul_b2: Implementation error in initial time calculation: t0 = " + String(booPul_b2.t0, 6, 0, true) + ", t1 = " + String(booPul_b2.t1, 6, 0, true) + ",  period = " + String(booPul_b2.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_b2.y := not (time >= booPul_b2.t1 and time < booPul_b2.t0);
[----] end if;

         slice: {1, 2};
        [ALGO] (3) ($RES_SIM_11)
[----] booPul_a2.t0 := if $FUN_4 + booPul_a2.period * integer(time / booPul_a2.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_4 + booPul_a2.period * integer(time / booPul_a2.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_4 + booPul_a2.period * integer(time / booPul_a2.period)));
[----] booPul_a2.t1 := booPul_a2.t0 + booPul_a2.width * booPul_a2.period;

[----] if time + booPul_a2.period < booPul_a2.t1 then
[----]   booPul_a2.t0 := booPul_a2.t0 - booPul_a2.period;
[----]   booPul_a2.t1 := booPul_a2.t1 - booPul_a2.period;
[----] end if;

[----] if time >= booPul_a2.t1 then
[----]   booPul_a2.t0 := booPul_a2.t0 + booPul_a2.period;
[----] elseif time < booPul_a2.t0 then
[----]   booPul_a2.t1 := booPul_a2.t1 - booPul_a2.period;
[----] end if;

[----] if booPul_a2.t0 < booPul_a2.t1 then
[----]   assert(booPul_a2.t0 <= time and time < booPul_a2.t1, "PulseNegativeStartTime.booPul_a2: Implementation error in initial time calculation: t0 = " + String(booPul_a2.t0, 6, 0, true) + ", t1 = " + String(booPul_a2.t1, 6, 0, true) + ",  period = " + String(booPul_a2.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_a2.y := time >= booPul_a2.t0 and time < booPul_a2.t1;
[----] elseif true then
[----]   assert(booPul_a2.t1 <= time and time < booPul_a2.t0, "PulseNegativeStartTime.booPul_a2: Implementation error in initial time calculation: t0 = " + String(booPul_a2.t0, 6, 0, true) + ", t1 = " + String(booPul_a2.t1, 6, 0, true) + ",  period = " + String(booPul_a2.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_a2.y := not (time >= booPul_a2.t1 and time < booPul_a2.t0);
[----] end if;

         slice: {1, 2};
        [ALGO] (3) ($RES_SIM_12)
[----] booPul_c1.t0 := if $FUN_3 + booPul_c1.period * integer(time / booPul_c1.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_3 + booPul_c1.period * integer(time / booPul_c1.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_3 + booPul_c1.period * integer(time / booPul_c1.period)));
[----] booPul_c1.t1 := booPul_c1.t0 + booPul_c1.width * booPul_c1.period;

[----] if time + booPul_c1.period < booPul_c1.t1 then
[----]   booPul_c1.t0 := booPul_c1.t0 - booPul_c1.period;
[----]   booPul_c1.t1 := booPul_c1.t1 - booPul_c1.period;
[----] end if;

[----] if time >= booPul_c1.t1 then
[----]   booPul_c1.t0 := booPul_c1.t0 + booPul_c1.period;
[----] elseif time < booPul_c1.t0 then
[----]   booPul_c1.t1 := booPul_c1.t1 - booPul_c1.period;
[----] end if;

[----] if booPul_c1.t0 < booPul_c1.t1 then
[----]   assert(booPul_c1.t0 <= time and time < booPul_c1.t1, "PulseNegativeStartTime.booPul_c1: Implementation error in initial time calculation: t0 = " + String(booPul_c1.t0, 6, 0, true) + ", t1 = " + String(booPul_c1.t1, 6, 0, true) + ",  period = " + String(booPul_c1.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_c1.y := time >= booPul_c1.t0 and time < booPul_c1.t1;
[----] elseif true then
[----]   assert(booPul_c1.t1 <= time and time < booPul_c1.t0, "PulseNegativeStartTime.booPul_c1: Implementation error in initial time calculation: t0 = " + String(booPul_c1.t0, 6, 0, true) + ", t1 = " + String(booPul_c1.t1, 6, 0, true) + ",  period = " + String(booPul_c1.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_c1.y := not (time >= booPul_c1.t1 and time < booPul_c1.t0);
[----] end if;

         slice: {1, 2};
        [ALGO] (3) ($RES_SIM_13)
[----] booPul_b1.t0 := if $FUN_2 + booPul_b1.period * integer(time / booPul_b1.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_2 + booPul_b1.period * integer(time / booPul_b1.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_2 + booPul_b1.period * integer(time / booPul_b1.period)));
[----] booPul_b1.t1 := booPul_b1.t0 + booPul_b1.width * booPul_b1.period;

[----] if time + booPul_b1.period < booPul_b1.t1 then
[----]   booPul_b1.t0 := booPul_b1.t0 - booPul_b1.period;
[----]   booPul_b1.t1 := booPul_b1.t1 - booPul_b1.period;
[----] end if;

[----] if time >= booPul_b1.t1 then
[----]   booPul_b1.t0 := booPul_b1.t0 + booPul_b1.period;
[----] elseif time < booPul_b1.t0 then
[----]   booPul_b1.t1 := booPul_b1.t1 - booPul_b1.period;
[----] end if;

[----] if booPul_b1.t0 < booPul_b1.t1 then
[----]   assert(booPul_b1.t0 <= time and time < booPul_b1.t1, "PulseNegativeStartTime.booPul_b1: Implementation error in initial time calculation: t0 = " + String(booPul_b1.t0, 6, 0, true) + ", t1 = " + String(booPul_b1.t1, 6, 0, true) + ",  period = " + String(booPul_b1.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_b1.y := time >= booPul_b1.t0 and time < booPul_b1.t1;
[----] elseif true then
[----]   assert(booPul_b1.t1 <= time and time < booPul_b1.t0, "PulseNegativeStartTime.booPul_b1: Implementation error in initial time calculation: t0 = " + String(booPul_b1.t0, 6, 0, true) + ", t1 = " + String(booPul_b1.t1, 6, 0, true) + ",  period = " + String(booPul_b1.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_b1.y := not (time >= booPul_b1.t1 and time < booPul_b1.t0);
[----] end if;

         slice: {1, 2};
        [ALGO] (3) ($RES_SIM_14)
[----] booPul_a1.t0 := if $FUN_1 + booPul_a1.period * integer(time / booPul_a1.period) > 0.0 then 1e-6 * floor(0.5 + 1e6 * ($FUN_1 + booPul_a1.period * integer(time / booPul_a1.period))) else 1e-6 * ceil((-0.5) + 1e6 * ($FUN_1 + booPul_a1.period * integer(time / booPul_a1.period)));
[----] booPul_a1.t1 := booPul_a1.t0 + booPul_a1.width * booPul_a1.period;

[----] if time + booPul_a1.period < booPul_a1.t1 then
[----]   booPul_a1.t0 := booPul_a1.t0 - booPul_a1.period;
[----]   booPul_a1.t1 := booPul_a1.t1 - booPul_a1.period;
[----] end if;

[----] if time >= booPul_a1.t1 then
[----]   booPul_a1.t0 := booPul_a1.t0 + booPul_a1.period;
[----] elseif time < booPul_a1.t0 then
[----]   booPul_a1.t1 := booPul_a1.t1 - booPul_a1.period;
[----] end if;

[----] if booPul_a1.t0 < booPul_a1.t1 then
[----]   assert(booPul_a1.t0 <= time and time < booPul_a1.t1, "PulseNegativeStartTime.booPul_a1: Implementation error in initial time calculation: t0 = " + String(booPul_a1.t0, 6, 0, true) + ", t1 = " + String(booPul_a1.t1, 6, 0, true) + ",  period = " + String(booPul_a1.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_a1.y := time >= booPul_a1.t0 and time < booPul_a1.t1;
[----] elseif true then
[----]   assert(booPul_a1.t1 <= time and time < booPul_a1.t0, "PulseNegativeStartTime.booPul_a1: Implementation error in initial time calculation: t0 = " + String(booPul_a1.t0, 6, 0, true) + ", t1 = " + String(booPul_a1.t1, 6, 0, true) + ",  period = " + String(booPul_a1.period, 6, 0, true) + ", time = " + String(time, 6, 0, true), AssertionLevel.error);
[----]   booPul_a1.y := not (time >= booPul_a1.t1 and time < booPul_a1.t0);
[----] end if;

         slice: {1, 2};
Notification: Performance of Causalize: time 0.009185/0.04261, allocations: 8.556 MB / 0.7073 GB, free: 2.387 MB / 0.5762 GB
Notification: Performance of Tearing: time 1.462e-05/0.04266, allocations: 3.984 kB / 0.7073 GB, free: 2.383 MB / 0.5762 GB
Notification: Performance of Initialization: time 1.613e-06/0.04266, allocations: 0 / 0.7073 GB, free: 2.383 MB / 0.5762 GB
Notification: Performance of Tearing: time 1.811e-05/0.04269, allocations: 4 kB / 0.7073 GB, free: 2.379 MB / 0.5762 GB
Notification: Performance of Categorize: time 3.288e-05/0.04273, allocations: 3.938 kB / 0.7073 GB, free: 2.375 MB / 0.5762 GB
Notification: Performance of Solve: time 0.0006076/0.04334, allocations: 410.2 kB / 0.7077 GB, free: 1.965 MB / 0.5762 GB
Notification: Performance of Jacobian: time 3.908e-06/0.04335, allocations: 3.938 kB / 0.7077 GB, free: 1.961 MB / 0.5762 GB
Notification: Partition statistics after passing the back-end:
 * Number of ODE partitions: ..................... 0
 * Number of algebraic partitions: ............... 0
 * Number of ODE event partitions: ............... 0
 * Number of algebraic event partitions: ......... 15
 * Number of clocked partitions: ................. 0
 * Number of initial partitions: ................. 1
 * Number of initial(lambda=0) partitions: ....... 0
Notification: Variable statistics after passing the back-end:
 * Number of states: ............................. 0 (0) {}
 * Number of discrete states: .................... 15 (15) {booPul_c5.y, booPul_b5.y, booPul_a5.y, booPul_c4.y, booPul_b4.y, booPul_a4.y, booPul_c3.y, booPul_b3.y, booPul_a3.y, booPul_c2.y, booPul_b2.y, booPul_a2.y, booPul_c1.y, booPul_b1.y, booPul_a1.y}
 * Number of clocked states: ..................... 0 (0) {NOT YET AVAILABLE}
 * Number of discrete variables: ................. 30 (30) {$TEV_209, $TEV_208, $TEV_207, $TEV_206, $TEV_205, $TEV_204, $TEV_203, $TEV_202, $TEV_201, $TEV_200, $TEV_199, $TEV_198, $TEV_197, $TEV_196, $TEV_195, $TEV_194, $TEV_193, $TEV_192, $TEV_191, $TEV_190, $TEV_189, $TEV_188, $TEV_187, $TEV_186, $TEV_185, $TEV_184, $TEV_183, $TEV_182, $TEV_181, $TEV_180}
 * Number of top-level inputs: ................... 0 (0) {}
Notification: [Simulation] Strong Component statistics after passing the back-end:
 * Number of single strong components: ........... 30 (scalar:30, array:0, record:0)
 * Number of multi strong components: ............ 15 (algorithm:0, when:15, if:0, tuple:0)
 * Number of for-loop strong components: ......... 0 (generic: 0, entwined:0)
 * Number of algebraic-loop strong components: ... 0 (linear: 0, nonlinear:0)
Notification: [Initialization] Strong Component statistics after passing the back-end:
 * Number of single strong components: ........... 105 (scalar:105, array:0, record:0)
 * Number of multi strong components: ............ 0 (algorithm:0, when:0, if:0, tuple:0)
 * Number of for-loop strong components: ......... 0 (generic: 0, entwined:0)
 * Number of algebraic-loop strong components: ... 0 (linear: 0, nonlinear:0)
Notification: Performance of backend: time 6.127e-05/0.04342, allocations: 44.34 kB / 0.7077 GB, free: 1.93 MB / 0.5762 GB
[/var/lib/jenkins/ws/OpenModelicaLibraryTestingWork/OpenModelica/OMCompiler/Compiler/NBackEnd/Modules/2_Pre/NBEvents.mo:685:7-685:120:writable] Error: Internal error UnorderedMap.getSafe failed because the key did not exist.