erreur max (non dynamique) en pourcents

Go!

dt = 0.013 (slider from 0 to 0.5, step 0.001)
f(x) = If[0 ≤ x ≤ 15, (9 * ℯ^(((-0.12) * x))) + 11]
er = 0.018526603387508618 (slider from -5 to 5, step 0.001)
ChampTexte1 = Textfield(er)
P0 = (0, 20)
P1: (dt, y(P0) + ((0.12 * (11 - y(P0))) * dt))
s1 = Segment(P0, P1)
P2: ((2 * dt), y(P1) + ((0.12 * (11 - y(P1))) * dt))
s2 = Segment(P1, P2)
P3: ((3 * dt), y(P2) + ((0.12 * (11 - y(P2))) * dt))
s3 = Segment(P2, P3)
P4: ((4 * dt), y(P3) + ((0.12 * (11 - y(P3))) * dt))
s4 = Segment(P3, P4)
P5: ((5 * dt), y(P4) + ((0.12 * (11 - y(P4))) * dt))
s5 = Segment(P4, P5)
P6: ((6 * dt), y(P5) + ((0.12 * (11 - y(P5))) * dt))
s6 = Segment(P5, P6)
P7: ((7 * dt), y(P6) + ((0.12 * (11 - y(P6))) * dt))
s7 = Segment(P6, P7)
P8: ((8 * dt), y(P7) + ((0.12 * (11 - y(P7))) * dt))
s8 = Segment(P7, P8)
P9: ((9 * dt), y(P8) + ((0.12 * (11 - y(P8))) * dt))
s9 = Segment(P8, P9)
P10: ((10 * dt), y(P9) + ((0.12 * (11 - y(P9))) * dt))
s10 = Segment(P9, P10)
P11: ((11 * dt), y(P10) + ((0.12 * (11 - y(P10))) * dt))
s11 = Segment(P10, P11)
P12: ((12 * dt), y(P11) + ((0.12 * (11 - y(P11))) * dt))
s12 = Segment(P11, P12)
P13: ((13 * dt), y(P12) + ((0.12 * (11 - y(P12))) * dt))
s13 = Segment(P12, P13)
P14: ((14 * dt), y(P13) + ((0.12 * (11 - y(P13))) * dt))
s14 = Segment(P13, P14)
P15: ((15 * dt), y(P14) + ((0.12 * (11 - y(P14))) * dt))
s15 = Segment(P14, P15)
P16: ((16 * dt), y(P15) + ((0.12 * (11 - y(P15))) * dt))
s16 = Segment(P15, P16)
P17: ((17 * dt), y(P16) + ((0.12 * (11 - y(P16))) * dt))
s17 = Segment(P16, P17)
P18: ((18 * dt), y(P17) + ((0.12 * (11 - y(P17))) * dt))
s18 = Segment(P17, P18)
P19: ((19 * dt), y(P18) + ((0.12 * (11 - y(P18))) * dt))
s19 = Segment(P18, P19)
P20: ((20 * dt), y(P19) + ((0.12 * (11 - y(P19))) * dt))
s20 = Segment(P19, P20)
P21: ((21 * dt), y(P20) + ((0.12 * (11 - y(P20))) * dt))
s21 = Segment(P20, P21)
P22: ((22 * dt), y(P21) + ((0.12 * (11 - y(P21))) * dt))
s22 = Segment(P21, P22)
P23: ((23 * dt), y(P22) + ((0.12 * (11 - y(P22))) * dt))
s23 = Segment(P22, P23)
P24: ((24 * dt), y(P23) + ((0.12 * (11 - y(P23))) * dt))
s24 = Segment(P23, P24)
P25: ((25 * dt), y(P24) + ((0.12 * (11 - y(P24))) * dt))
s25 = Segment(P24, P25)
P26: ((26 * dt), y(P25) + ((0.12 * (11 - y(P25))) * dt))
s26 = Segment(P25, P26)
P27: ((27 * dt), y(P26) + ((0.12 * (11 - y(P26))) * dt))
s27 = Segment(P26, P27)
P28: ((28 * dt), y(P27) + ((0.12 * (11 - y(P27))) * dt))
s28 = Segment(P27, P28)
P29: ((29 * dt), y(P28) + ((0.12 * (11 - y(P28))) * dt))
s29 = Segment(P28, P29)
P30: ((30 * dt), y(P29) + ((0.12 * (11 - y(P29))) * dt))
s30 = Segment(P29, P30)
P31: ((31 * dt), y(P30) + ((0.12 * (11 - y(P30))) * dt))
s31 = Segment(P30, P31)
P32: ((32 * dt), y(P31) + ((0.12 * (11 - y(P31))) * dt))
s32 = Segment(P31, P32)
P33: ((33 * dt), y(P32) + ((0.12 * (11 - y(P32))) * dt))
s33 = Segment(P32, P33)
P34: ((34 * dt), y(P33) + ((0.12 * (11 - y(P33))) * dt))
s34 = Segment(P33, P34)
P35: ((35 * dt), y(P34) + ((0.12 * (11 - y(P34))) * dt))
s35 = Segment(P34, P35)
P36: ((36 * dt), y(P35) + ((0.12 * (11 - y(P35))) * dt))
s36 = Segment(P35, P36)
P37: ((37 * dt), y(P36) + ((0.12 * (11 - y(P36))) * dt))
s37 = Segment(P36, P37)
P38: ((38 * dt), y(P37) + ((0.12 * (11 - y(P37))) * dt))
s38 = Segment(P37, P38)
P39: ((39 * dt), y(P38) + ((0.12 * (11 - y(P38))) * dt))
s39 = Segment(P38, P39)
P40: ((40 * dt), y(P39) + ((0.12 * (11 - y(P39))) * dt))
s40 = Segment(P39, P40)
P41: ((41 * dt), y(P40) + ((0.12 * (11 - y(P40))) * dt))
s41 = Segment(P40, P41)
P42: ((42 * dt), y(P41) + ((0.12 * (11 - y(P41))) * dt))
s42 = Segment(P41, P42)
P43: ((43 * dt), y(P42) + ((0.12 * (11 - y(P42))) * dt))
s43 = Segment(P42, P43)
P44: ((44 * dt), y(P43) + ((0.12 * (11 - y(P43))) * dt))
s44 = Segment(P43, P44)
P45: ((45 * dt), y(P44) + ((0.12 * (11 - y(P44))) * dt))
s45 = Segment(P44, P45)
P46: ((46 * dt), y(P45) + ((0.12 * (11 - y(P45))) * dt))
s46 = Segment(P45, P46)
P47: ((47 * dt), y(P46) + ((0.12 * (11 - y(P46))) * dt))
s47 = Segment(P46, P47)
P48: ((48 * dt), y(P47) + ((0.12 * (11 - y(P47))) * dt))
s48 = Segment(P47, P48)
P49: ((49 * dt), y(P48) + ((0.12 * (11 - y(P48))) * dt))
s49 = Segment(P48, P49)
P50: ((50 * dt), y(P49) + ((0.12 * (11 - y(P49))) * dt))
s50 = Segment(P49, P50)
P51: ((51 * dt), y(P50) + ((0.12 * (11 - y(P50))) * dt))
s51 = Segment(P50, P51)
P52: ((52 * dt), y(P51) + ((0.12 * (11 - y(P51))) * dt))
s52 = Segment(P51, P52)
P53: ((53 * dt), y(P52) + ((0.12 * (11 - y(P52))) * dt))
s53 = Segment(P52, P53)
P54: ((54 * dt), y(P53) + ((0.12 * (11 - y(P53))) * dt))
s54 = Segment(P53, P54)
P55: ((55 * dt), y(P54) + ((0.12 * (11 - y(P54))) * dt))
s55 = Segment(P54, P55)
P56: ((56 * dt), y(P55) + ((0.12 * (11 - y(P55))) * dt))
s56 = Segment(P55, P56)
P57: ((57 * dt), y(P56) + ((0.12 * (11 - y(P56))) * dt))
s57 = Segment(P56, P57)
P58: ((58 * dt), y(P57) + ((0.12 * (11 - y(P57))) * dt))
s58 = Segment(P57, P58)
P59: ((59 * dt), y(P58) + ((0.12 * (11 - y(P58))) * dt))
s59 = Segment(P58, P59)
P60: ((60 * dt), y(P59) + ((0.12 * (11 - y(P59))) * dt))
s60 = Segment(P59, P60)
P61: ((61 * dt), y(P60) + ((0.12 * (11 - y(P60))) * dt))
s61 = Segment(P60, P61)
P62: ((62 * dt), y(P61) + ((0.12 * (11 - y(P61))) * dt))
s62 = Segment(P61, P62)
P63: ((63 * dt), y(P62) + ((0.12 * (11 - y(P62))) * dt))
s63 = Segment(P62, P63)
P64: ((64 * dt), y(P63) + ((0.12 * (11 - y(P63))) * dt))
s64 = Segment(P63, P64)
P65: ((65 * dt), y(P64) + ((0.12 * (11 - y(P64))) * dt))
s65 = Segment(P64, P65)
P66: ((66 * dt), y(P65) + ((0.12 * (11 - y(P65))) * dt))
s66 = Segment(P65, P66)
P67: ((67 * dt), y(P66) + ((0.12 * (11 - y(P66))) * dt))
s67 = Segment(P66, P67)
P68: ((68 * dt), y(P67) + ((0.12 * (11 - y(P67))) * dt))
s68 = Segment(P67, P68)
P69: ((69 * dt), y(P68) + ((0.12 * (11 - y(P68))) * dt))
s69 = Segment(P68, P69)
P70: ((70 * dt), y(P69) + ((0.12 * (11 - y(P69))) * dt))
s70 = Segment(P69, P70)
P71: ((71 * dt), y(P70) + ((0.12 * (11 - y(P70))) * dt))
s71 = Segment(P70, P71)
P72: ((72 * dt), y(P71) + ((0.12 * (11 - y(P71))) * dt))
s72 = Segment(P71, P72)
P73: ((73 * dt), y(P72) + ((0.12 * (11 - y(P72))) * dt))
s73 = Segment(P72, P73)
P74: ((74 * dt), y(P73) + ((0.12 * (11 - y(P73))) * dt))
s74 = Segment(P73, P74)
P75: ((75 * dt), y(P74) + ((0.12 * (11 - y(P74))) * dt))
s75 = Segment(P74, P75)
P76: ((76 * dt), y(P75) + ((0.12 * (11 - y(P75))) * dt))
s76 = Segment(P75, P76)
P77: ((77 * dt), y(P76) + ((0.12 * (11 - y(P76))) * dt))
s77 = Segment(P76, P77)
P78: ((78 * dt), y(P77) + ((0.12 * (11 - y(P77))) * dt))
s78 = Segment(P77, P78)
P79: ((79 * dt), y(P78) + ((0.12 * (11 - y(P78))) * dt))
s79 = Segment(P78, P79)
P80: ((80 * dt), y(P79) + ((0.12 * (11 - y(P79))) * dt))
s80 = Segment(P79, P80)
P81: ((81 * dt), y(P80) + ((0.12 * (11 - y(P80))) * dt))
s81 = Segment(P80, P81)
P82: ((82 * dt), y(P81) + ((0.12 * (11 - y(P81))) * dt))
s82 = Segment(P81, P82)
P83: ((83 * dt), y(P82) + ((0.12 * (11 - y(P82))) * dt))
s83 = Segment(P82, P83)
P84: ((84 * dt), y(P83) + ((0.12 * (11 - y(P83))) * dt))
s84 = Segment(P83, P84)
P85: ((85 * dt), y(P84) + ((0.12 * (11 - y(P84))) * dt))
s85 = Segment(P84, P85)
P86: ((86 * dt), y(P85) + ((0.12 * (11 - y(P85))) * dt))
s86 = Segment(P85, P86)
P87: ((87 * dt), y(P86) + ((0.12 * (11 - y(P86))) * dt))
s87 = Segment(P86, P87)
P88: ((88 * dt), y(P87) + ((0.12 * (11 - y(P87))) * dt))
s88 = Segment(P87, P88)
P89: ((89 * dt), y(P88) + ((0.12 * (11 - y(P88))) * dt))
s89 = Segment(P88, P89)
P90: ((90 * dt), y(P89) + ((0.12 * (11 - y(P89))) * dt))
s90 = Segment(P89, P90)
P91: ((91 * dt), y(P90) + ((0.12 * (11 - y(P90))) * dt))
s91 = Segment(P90, P91)
P92: ((92 * dt), y(P91) + ((0.12 * (11 - y(P91))) * dt))
s92 = Segment(P91, P92)
P93: ((93 * dt), y(P92) + ((0.12 * (11 - y(P92))) * dt))
s93 = Segment(P92, P93)
P94: ((94 * dt), y(P93) + ((0.12 * (11 - y(P93))) * dt))
s94 = Segment(P93, P94)
P95: ((95 * dt), y(P94) + ((0.12 * (11 - y(P94))) * dt))
s95 = Segment(P94, P95)
P96: ((96 * dt), y(P95) + ((0.12 * (11 - y(P95))) * dt))
s96 = Segment(P95, P96)
P97: ((97 * dt), y(P96) + ((0.12 * (11 - y(P96))) * dt))
s97 = Segment(P96, P97)
P98: ((98 * dt), y(P97) + ((0.12 * (11 - y(P97))) * dt))
s98 = Segment(P97, P98)
P99: ((99 * dt), y(P98) + ((0.12 * (11 - y(P98))) * dt))
s99 = Segment(P98, P99)
P100: ((100 * dt), y(P99) + ((0.12 * (11 - y(P99))) * dt))
s100 = Segment(P99, P100)
P101: ((101 * dt), y(P100) + ((0.12 * (11 - y(P100))) * dt))
s101 = Segment(P100, P101)
P102: ((102 * dt), y(P101) + ((0.12 * (11 - y(P101))) * dt))
s102 = Segment(P101, P102)
P103: ((103 * dt), y(P102) + ((0.12 * (11 - y(P102))) * dt))
s103 = Segment(P102, P103)
P104: ((104 * dt), y(P103) + ((0.12 * (11 - y(P103))) * dt))
s104 = Segment(P103, P104)
P105: ((105 * dt), y(P104) + ((0.12 * (11 - y(P104))) * dt))
s105 = Segment(P104, P105)
P106: ((106 * dt), y(P105) + ((0.12 * (11 - y(P105))) * dt))
s106 = Segment(P105, P106)
P107: ((107 * dt), y(P106) + ((0.12 * (11 - y(P106))) * dt))
s107 = Segment(P106, P107)
P108: ((108 * dt), y(P107) + ((0.12 * (11 - y(P107))) * dt))
s108 = Segment(P107, P108)
P109: ((109 * dt), y(P108) + ((0.12 * (11 - y(P108))) * dt))
s109 = Segment(P108, P109)
P110: ((110 * dt), y(P109) + ((0.12 * (11 - y(P109))) * dt))
s110 = Segment(P109, P110)
P111: ((111 * dt), y(P110) + ((0.12 * (11 - y(P110))) * dt))
s111 = Segment(P110, P111)
P112: ((112 * dt), y(P111) + ((0.12 * (11 - y(P111))) * dt))
s112 = Segment(P111, P112)
P113: ((113 * dt), y(P112) + ((0.12 * (11 - y(P112))) * dt))
s113 = Segment(P112, P113)
P114: ((114 * dt), y(P113) + ((0.12 * (11 - y(P113))) * dt))
s114 = Segment(P113, P114)
P115: ((115 * dt), y(P114) + ((0.12 * (11 - y(P114))) * dt))
s115 = Segment(P114, P115)
P116: ((116 * dt), y(P115) + ((0.12 * (11 - y(P115))) * dt))
s116 = Segment(P115, P116)
P117: ((117 * dt), y(P116) + ((0.12 * (11 - y(P116))) * dt))
s117 = Segment(P116, P117)
P118: ((118 * dt), y(P117) + ((0.12 * (11 - y(P117))) * dt))
s118 = Segment(P117, P118)
P119: ((119 * dt), y(P118) + ((0.12 * (11 - y(P118))) * dt))
s119 = Segment(P118, P119)
P120: ((120 * dt), y(P119) + ((0.12 * (11 - y(P119))) * dt))
s120 = Segment(P119, P120)
P121: ((121 * dt), y(P120) + ((0.12 * (11 - y(P120))) * dt))
s121 = Segment(P120, P121)
P122: ((122 * dt), y(P121) + ((0.12 * (11 - y(P121))) * dt))
s122 = Segment(P121, P122)
P123: ((123 * dt), y(P122) + ((0.12 * (11 - y(P122))) * dt))
s123 = Segment(P122, P123)
P124: ((124 * dt), y(P123) + ((0.12 * (11 - y(P123))) * dt))
s124 = Segment(P123, P124)
P125: ((125 * dt), y(P124) + ((0.12 * (11 - y(P124))) * dt))
s125 = Segment(P124, P125)
P126: ((126 * dt), y(P125) + ((0.12 * (11 - y(P125))) * dt))
s126 = Segment(P125, P126)
P127: ((127 * dt), y(P126) + ((0.12 * (11 - y(P126))) * dt))
s127 = Segment(P126, P127)
P128: ((128 * dt), y(P127) + ((0.12 * (11 - y(P127))) * dt))
s128 = Segment(P127, P128)
P129: ((129 * dt), y(P128) + ((0.12 * (11 - y(P128))) * dt))
s129 = Segment(P128, P129)
P130: ((130 * dt), y(P129) + ((0.12 * (11 - y(P129))) * dt))
s130 = Segment(P129, P130)
P131: ((131 * dt), y(P130) + ((0.12 * (11 - y(P130))) * dt))
s131 = Segment(P130, P131)
P132: ((132 * dt), y(P131) + ((0.12 * (11 - y(P131))) * dt))
s132 = Segment(P131, P132)
P133: ((133 * dt), y(P132) + ((0.12 * (11 - y(P132))) * dt))
s133 = Segment(P132, P133)
P134: ((134 * dt), y(P133) + ((0.12 * (11 - y(P133))) * dt))
s134 = Segment(P133, P134)
P135: ((135 * dt), y(P134) + ((0.12 * (11 - y(P134))) * dt))
s135 = Segment(P134, P135)
P136: ((136 * dt), y(P135) + ((0.12 * (11 - y(P135))) * dt))
s136 = Segment(P135, P136)
P137: ((137 * dt), y(P136) + ((0.12 * (11 - y(P136))) * dt))
s137 = Segment(P136, P137)
P138: ((138 * dt), y(P137) + ((0.12 * (11 - y(P137))) * dt))
s138 = Segment(P137, P138)
P139: ((139 * dt), y(P138) + ((0.12 * (11 - y(P138))) * dt))
s139 = Segment(P138, P139)
P140: ((140 * dt), y(P139) + ((0.12 * (11 - y(P139))) * dt))
s140 = Segment(P139, P140)
P141: ((141 * dt), y(P140) + ((0.12 * (11 - y(P140))) * dt))
s141 = Segment(P140, P141)
P142: ((142 * dt), y(P141) + ((0.12 * (11 - y(P141))) * dt))
s142 = Segment(P141, P142)
P143: ((143 * dt), y(P142) + ((0.12 * (11 - y(P142))) * dt))
s143 = Segment(P142, P143)
P144: ((144 * dt), y(P143) + ((0.12 * (11 - y(P143))) * dt))
s144 = Segment(P143, P144)
P145: ((145 * dt), y(P144) + ((0.12 * (11 - y(P144))) * dt))
s145 = Segment(P144, P145)
P146: ((146 * dt), y(P145) + ((0.12 * (11 - y(P145))) * dt))
s146 = Segment(P145, P146)
P147: ((147 * dt), y(P146) + ((0.12 * (11 - y(P146))) * dt))
s147 = Segment(P146, P147)
P148: ((148 * dt), y(P147) + ((0.12 * (11 - y(P147))) * dt))
s148 = Segment(P147, P148)
P149: ((149 * dt), y(P148) + ((0.12 * (11 - y(P148))) * dt))
s149 = Segment(P148, P149)
P150: ((150 * dt), y(P149) + ((0.12 * (11 - y(P149))) * dt))
s150 = Segment(P149, P150)
P151: ((151 * dt), y(P150) + ((0.12 * (11 - y(P150))) * dt))
s151 = Segment(P150, P151)
P152: ((152 * dt), y(P151) + ((0.12 * (11 - y(P151))) * dt))
s152 = Segment(P151, P152)
P153: ((153 * dt), y(P152) + ((0.12 * (11 - y(P152))) * dt))
s153 = Segment(P152, P153)
P154: ((154 * dt), y(P153) + ((0.12 * (11 - y(P153))) * dt))
s154 = Segment(P153, P154)
P155: ((155 * dt), y(P154) + ((0.12 * (11 - y(P154))) * dt))
s155 = Segment(P154, P155)
P156: ((156 * dt), y(P155) + ((0.12 * (11 - y(P155))) * dt))
s156 = Segment(P155, P156)
P157: ((157 * dt), y(P156) + ((0.12 * (11 - y(P156))) * dt))
s157 = Segment(P156, P157)
P158: ((158 * dt), y(P157) + ((0.12 * (11 - y(P157))) * dt))
s158 = Segment(P157, P158)
P159: ((159 * dt), y(P158) + ((0.12 * (11 - y(P158))) * dt))
s159 = Segment(P158, P159)
P160: ((160 * dt), y(P159) + ((0.12 * (11 - y(P159))) * dt))
s160 = Segment(P159, P160)
P161: ((161 * dt), y(P160) + ((0.12 * (11 - y(P160))) * dt))
s161 = Segment(P160, P161)
P162: ((162 * dt), y(P161) + ((0.12 * (11 - y(P161))) * dt))
s162 = Segment(P161, P162)
P163: ((163 * dt), y(P162) + ((0.12 * (11 - y(P162))) * dt))
s163 = Segment(P162, P163)
P164: ((164 * dt), y(P163) + ((0.12 * (11 - y(P163))) * dt))
s164 = Segment(P163, P164)
P165: ((165 * dt), y(P164) + ((0.12 * (11 - y(P164))) * dt))
s165 = Segment(P164, P165)
P166: ((166 * dt), y(P165) + ((0.12 * (11 - y(P165))) * dt))
s166 = Segment(P165, P166)
P167: ((167 * dt), y(P166) + ((0.12 * (11 - y(P166))) * dt))
s167 = Segment(P166, P167)
P168: ((168 * dt), y(P167) + ((0.12 * (11 - y(P167))) * dt))
s168 = Segment(P167, P168)
P169: ((169 * dt), y(P168) + ((0.12 * (11 - y(P168))) * dt))
s169 = Segment(P168, P169)
P170: ((170 * dt), y(P169) + ((0.12 * (11 - y(P169))) * dt))
s170 = Segment(P169, P170)
P171: ((171 * dt), y(P170) + ((0.12 * (11 - y(P170))) * dt))
s171 = Segment(P170, P171)
P172: ((172 * dt), y(P171) + ((0.12 * (11 - y(P171))) * dt))
s172 = Segment(P171, P172)
P173: ((173 * dt), y(P172) + ((0.12 * (11 - y(P172))) * dt))
s173 = Segment(P172, P173)
P174: ((174 * dt), y(P173) + ((0.12 * (11 - y(P173))) * dt))
s174 = Segment(P173, P174)
P175: ((175 * dt), y(P174) + ((0.12 * (11 - y(P174))) * dt))
s175 = Segment(P174, P175)
P176: ((176 * dt), y(P175) + ((0.12 * (11 - y(P175))) * dt))
s176 = Segment(P175, P176)
P177: ((177 * dt), y(P176) + ((0.12 * (11 - y(P176))) * dt))
s177 = Segment(P176, P177)
P178: ((178 * dt), y(P177) + ((0.12 * (11 - y(P177))) * dt))
s178 = Segment(P177, P178)
P179: ((179 * dt), y(P178) + ((0.12 * (11 - y(P178))) * dt))
s179 = Segment(P178, P179)
P180: ((180 * dt), y(P179) + ((0.12 * (11 - y(P179))) * dt))
s180 = Segment(P179, P180)
P181: ((181 * dt), y(P180) + ((0.12 * (11 - y(P180))) * dt))
s181 = Segment(P180, P181)
P182: ((182 * dt), y(P181) + ((0.12 * (11 - y(P181))) * dt))
s182 = Segment(P181, P182)
P183: ((183 * dt), y(P182) + ((0.12 * (11 - y(P182))) * dt))
s183 = Segment(P182, P183)
P184: ((184 * dt), y(P183) + ((0.12 * (11 - y(P183))) * dt))
s184 = Segment(P183, P184)
P185: ((185 * dt), y(P184) + ((0.12 * (11 - y(P184))) * dt))
s185 = Segment(P184, P185)
P186: ((186 * dt), y(P185) + ((0.12 * (11 - y(P185))) * dt))
s186 = Segment(P185, P186)
P187: ((187 * dt), y(P186) + ((0.12 * (11 - y(P186))) * dt))
s187 = Segment(P186, P187)
P188: ((188 * dt), y(P187) + ((0.12 * (11 - y(P187))) * dt))
s188 = Segment(P187, P188)
P189: ((189 * dt), y(P188) + ((0.12 * (11 - y(P188))) * dt))
s189 = Segment(P188, P189)
P190: ((190 * dt), y(P189) + ((0.12 * (11 - y(P189))) * dt))
s190 = Segment(P189, P190)
P191: ((191 * dt), y(P190) + ((0.12 * (11 - y(P190))) * dt))
s191 = Segment(P190, P191)
P192: ((192 * dt), y(P191) + ((0.12 * (11 - y(P191))) * dt))
s192 = Segment(P191, P192)
P193: ((193 * dt), y(P192) + ((0.12 * (11 - y(P192))) * dt))
s193 = Segment(P192, P193)
P194: ((194 * dt), y(P193) + ((0.12 * (11 - y(P193))) * dt))
s194 = Segment(P193, P194)
P195: ((195 * dt), y(P194) + ((0.12 * (11 - y(P194))) * dt))
s195 = Segment(P194, P195)
P196: ((196 * dt), y(P195) + ((0.12 * (11 - y(P195))) * dt))
s196 = Segment(P195, P196)
P197: ((197 * dt), y(P196) + ((0.12 * (11 - y(P196))) * dt))
s197 = Segment(P196, P197)
P198: ((198 * dt), y(P197) + ((0.12 * (11 - y(P197))) * dt))
s198 = Segment(P197, P198)
P199: ((199 * dt), y(P198) + ((0.12 * (11 - y(P198))) * dt))
s199 = Segment(P198, P199)
P200: ((200 * dt), y(P199) + ((0.12 * (11 - y(P199))) * dt))
s200 = Segment(P199, P200)
P201: ((201 * dt), y(P200) + ((0.12 * (11 - y(P200))) * dt))
s201 = Segment(P200, P201)
P202: ((202 * dt), y(P201) + ((0.12 * (11 - y(P201))) * dt))
s202 = Segment(P201, P202)
P203: ((203 * dt), y(P202) + ((0.12 * (11 - y(P202))) * dt))
s203 = Segment(P202, P203)
P204: ((204 * dt), y(P203) + ((0.12 * (11 - y(P203))) * dt))
s204 = Segment(P203, P204)
P205: ((205 * dt), y(P204) + ((0.12 * (11 - y(P204))) * dt))
s205 = Segment(P204, P205)
P206: ((206 * dt), y(P205) + ((0.12 * (11 - y(P205))) * dt))
s206 = Segment(P205, P206)
P207: ((207 * dt), y(P206) + ((0.12 * (11 - y(P206))) * dt))
s207 = Segment(P206, P207)
P208: ((208 * dt), y(P207) + ((0.12 * (11 - y(P207))) * dt))
s208 = Segment(P207, P208)
P209: ((209 * dt), y(P208) + ((0.12 * (11 - y(P208))) * dt))
s209 = Segment(P208, P209)
P210: ((210 * dt), y(P209) + ((0.12 * (11 - y(P209))) * dt))
s210 = Segment(P209, P210)
P211: ((211 * dt), y(P210) + ((0.12 * (11 - y(P210))) * dt))
s211 = Segment(P210, P211)
P212: ((212 * dt), y(P211) + ((0.12 * (11 - y(P211))) * dt))
s212 = Segment(P211, P212)
P213: ((213 * dt), y(P212) + ((0.12 * (11 - y(P212))) * dt))
s213 = Segment(P212, P213)
P214: ((214 * dt), y(P213) + ((0.12 * (11 - y(P213))) * dt))
s214 = Segment(P213, P214)
P215: ((215 * dt), y(P214) + ((0.12 * (11 - y(P214))) * dt))
s215 = Segment(P214, P215)
P216: ((216 * dt), y(P215) + ((0.12 * (11 - y(P215))) * dt))
s216 = Segment(P215, P216)
P217: ((217 * dt), y(P216) + ((0.12 * (11 - y(P216))) * dt))
s217 = Segment(P216, P217)
P218: ((218 * dt), y(P217) + ((0.12 * (11 - y(P217))) * dt))
s218 = Segment(P217, P218)
P219: ((219 * dt), y(P218) + ((0.12 * (11 - y(P218))) * dt))
s219 = Segment(P218, P219)
P220: ((220 * dt), y(P219) + ((0.12 * (11 - y(P219))) * dt))
s220 = Segment(P219, P220)
P221: ((221 * dt), y(P220) + ((0.12 * (11 - y(P220))) * dt))
s221 = Segment(P220, P221)
P222: ((222 * dt), y(P221) + ((0.12 * (11 - y(P221))) * dt))
s222 = Segment(P221, P222)
P223: ((223 * dt), y(P222) + ((0.12 * (11 - y(P222))) * dt))
s223 = Segment(P222, P223)
P224: ((224 * dt), y(P223) + ((0.12 * (11 - y(P223))) * dt))
s224 = Segment(P223, P224)
P225: ((225 * dt), y(P224) + ((0.12 * (11 - y(P224))) * dt))
s225 = Segment(P224, P225)
P226: ((226 * dt), y(P225) + ((0.12 * (11 - y(P225))) * dt))
s226 = Segment(P225, P226)
P227: ((227 * dt), y(P226) + ((0.12 * (11 - y(P226))) * dt))
s227 = Segment(P226, P227)
P228: ((228 * dt), y(P227) + ((0.12 * (11 - y(P227))) * dt))
s228 = Segment(P227, P228)
P229: ((229 * dt), y(P228) + ((0.12 * (11 - y(P228))) * dt))
s229 = Segment(P228, P229)
P230: ((230 * dt), y(P229) + ((0.12 * (11 - y(P229))) * dt))
s230 = Segment(P229, P230)
P231: ((231 * dt), y(P230) + ((0.12 * (11 - y(P230))) * dt))
s231 = Segment(P230, P231)
P232: ((232 * dt), y(P231) + ((0.12 * (11 - y(P231))) * dt))
s232 = Segment(P231, P232)
P233: ((233 * dt), y(P232) + ((0.12 * (11 - y(P232))) * dt))
s233 = Segment(P232, P233)
P234: ((234 * dt), y(P233) + ((0.12 * (11 - y(P233))) * dt))
s234 = Segment(P233, P234)
P235: ((235 * dt), y(P234) + ((0.12 * (11 - y(P234))) * dt))
s235 = Segment(P234, P235)
P236: ((236 * dt), y(P235) + ((0.12 * (11 - y(P235))) * dt))
s236 = Segment(P235, P236)
P237: ((237 * dt), y(P236) + ((0.12 * (11 - y(P236))) * dt))
s237 = Segment(P236, P237)
P238: ((238 * dt), y(P237) + ((0.12 * (11 - y(P237))) * dt))
s238 = Segment(P237, P238)
P239: ((239 * dt), y(P238) + ((0.12 * (11 - y(P238))) * dt))
s239 = Segment(P238, P239)
P240: ((240 * dt), y(P239) + ((0.12 * (11 - y(P239))) * dt))
s240 = Segment(P239, P240)
P241: ((241 * dt), y(P240) + ((0.12 * (11 - y(P240))) * dt))
s241 = Segment(P240, P241)
P242: ((242 * dt), y(P241) + ((0.12 * (11 - y(P241))) * dt))
s242 = Segment(P241, P242)
P243: ((243 * dt), y(P242) + ((0.12 * (11 - y(P242))) * dt))
s243 = Segment(P242, P243)
P244: ((244 * dt), y(P243) + ((0.12 * (11 - y(P243))) * dt))
s244 = Segment(P243, P244)
P245: ((245 * dt), y(P244) + ((0.12 * (11 - y(P244))) * dt))
s245 = Segment(P244, P245)
P246: ((246 * dt), y(P245) + ((0.12 * (11 - y(P245))) * dt))
s246 = Segment(P245, P246)
P247: ((247 * dt), y(P246) + ((0.12 * (11 - y(P246))) * dt))
s247 = Segment(P246, P247)
P248: ((248 * dt), y(P247) + ((0.12 * (11 - y(P247))) * dt))
s248 = Segment(P247, P248)
P249: ((249 * dt), y(P248) + ((0.12 * (11 - y(P248))) * dt))
s249 = Segment(P248, P249)
P250: ((250 * dt), y(P249) + ((0.12 * (11 - y(P249))) * dt))
s250 = Segment(P249, P250)
P251: ((251 * dt), y(P250) + ((0.12 * (11 - y(P250))) * dt))
s251 = Segment(P250, P251)
P252: ((252 * dt), y(P251) + ((0.12 * (11 - y(P251))) * dt))
s252 = Segment(P251, P252)
P253: ((253 * dt), y(P252) + ((0.12 * (11 - y(P252))) * dt))
s253 = Segment(P252, P253)
P254: ((254 * dt), y(P253) + ((0.12 * (11 - y(P253))) * dt))
s254 = Segment(P253, P254)
P255: ((255 * dt), y(P254) + ((0.12 * (11 - y(P254))) * dt))
s255 = Segment(P254, P255)
P256: ((256 * dt), y(P255) + ((0.12 * (11 - y(P255))) * dt))
s256 = Segment(P255, P256)
P257: ((257 * dt), y(P256) + ((0.12 * (11 - y(P256))) * dt))
s257 = Segment(P256, P257)
P258: ((258 * dt), y(P257) + ((0.12 * (11 - y(P257))) * dt))
s258 = Segment(P257, P258)
P259: ((259 * dt), y(P258) + ((0.12 * (11 - y(P258))) * dt))
s259 = Segment(P258, P259)
P260: ((260 * dt), y(P259) + ((0.12 * (11 - y(P259))) * dt))
s260 = Segment(P259, P260)
P261: ((261 * dt), y(P260) + ((0.12 * (11 - y(P260))) * dt))
s261 = Segment(P260, P261)
P262: ((262 * dt), y(P261) + ((0.12 * (11 - y(P261))) * dt))
s262 = Segment(P261, P262)
P263: ((263 * dt), y(P262) + ((0.12 * (11 - y(P262))) * dt))
s263 = Segment(P262, P263)
P264: ((264 * dt), y(P263) + ((0.12 * (11 - y(P263))) * dt))
s264 = Segment(P263, P264)
P265: ((265 * dt), y(P264) + ((0.12 * (11 - y(P264))) * dt))
s265 = Segment(P264, P265)
P266: ((266 * dt), y(P265) + ((0.12 * (11 - y(P265))) * dt))
s266 = Segment(P265, P266)
P267: ((267 * dt), y(P266) + ((0.12 * (11 - y(P266))) * dt))
s267 = Segment(P266, P267)
P268: ((268 * dt), y(P267) + ((0.12 * (11 - y(P267))) * dt))
s268 = Segment(P267, P268)
P269: ((269 * dt), y(P268) + ((0.12 * (11 - y(P268))) * dt))
s269 = Segment(P268, P269)
P270: ((270 * dt), y(P269) + ((0.12 * (11 - y(P269))) * dt))
s270 = Segment(P269, P270)
P271: ((271 * dt), y(P270) + ((0.12 * (11 - y(P270))) * dt))
s271 = Segment(P270, P271)
P272: ((272 * dt), y(P271) + ((0.12 * (11 - y(P271))) * dt))
s272 = Segment(P271, P272)
P273: ((273 * dt), y(P272) + ((0.12 * (11 - y(P272))) * dt))
s273 = Segment(P272, P273)
P274: ((274 * dt), y(P273) + ((0.12 * (11 - y(P273))) * dt))
s274 = Segment(P273, P274)
P275: ((275 * dt), y(P274) + ((0.12 * (11 - y(P274))) * dt))
s275 = Segment(P274, P275)
P276: ((276 * dt), y(P275) + ((0.12 * (11 - y(P275))) * dt))
s276 = Segment(P275, P276)
P277: ((277 * dt), y(P276) + ((0.12 * (11 - y(P276))) * dt))
s277 = Segment(P276, P277)
P278: ((278 * dt), y(P277) + ((0.12 * (11 - y(P277))) * dt))
s278 = Segment(P277, P278)
P279: ((279 * dt), y(P278) + ((0.12 * (11 - y(P278))) * dt))
s279 = Segment(P278, P279)
P280: ((280 * dt), y(P279) + ((0.12 * (11 - y(P279))) * dt))
s280 = Segment(P279, P280)
P281: ((281 * dt), y(P280) + ((0.12 * (11 - y(P280))) * dt))
s281 = Segment(P280, P281)
P282: ((282 * dt), y(P281) + ((0.12 * (11 - y(P281))) * dt))
s282 = Segment(P281, P282)
P283: ((283 * dt), y(P282) + ((0.12 * (11 - y(P282))) * dt))
s283 = Segment(P282, P283)
P284: ((284 * dt), y(P283) + ((0.12 * (11 - y(P283))) * dt))
s284 = Segment(P283, P284)
P285: ((285 * dt), y(P284) + ((0.12 * (11 - y(P284))) * dt))
s285 = Segment(P284, P285)
P286: ((286 * dt), y(P285) + ((0.12 * (11 - y(P285))) * dt))
s286 = Segment(P285, P286)
P287: ((287 * dt), y(P286) + ((0.12 * (11 - y(P286))) * dt))
s287 = Segment(P286, P287)
P288: ((288 * dt), y(P287) + ((0.12 * (11 - y(P287))) * dt))
s288 = Segment(P287, P288)
P289: ((289 * dt), y(P288) + ((0.12 * (11 - y(P288))) * dt))
s289 = Segment(P288, P289)
P290: ((290 * dt), y(P289) + ((0.12 * (11 - y(P289))) * dt))
s290 = Segment(P289, P290)
P291: ((291 * dt), y(P290) + ((0.12 * (11 - y(P290))) * dt))
s291 = Segment(P290, P291)
P292: ((292 * dt), y(P291) + ((0.12 * (11 - y(P291))) * dt))
s292 = Segment(P291, P292)
P293: ((293 * dt), y(P292) + ((0.12 * (11 - y(P292))) * dt))
s293 = Segment(P292, P293)
P294: ((294 * dt), y(P293) + ((0.12 * (11 - y(P293))) * dt))
s294 = Segment(P293, P294)
P295: ((295 * dt), y(P294) + ((0.12 * (11 - y(P294))) * dt))
s295 = Segment(P294, P295)
P296: ((296 * dt), y(P295) + ((0.12 * (11 - y(P295))) * dt))
s296 = Segment(P295, P296)
P297: ((297 * dt), y(P296) + ((0.12 * (11 - y(P296))) * dt))
s297 = Segment(P296, P297)
P298: ((298 * dt), y(P297) + ((0.12 * (11 - y(P297))) * dt))
s298 = Segment(P297, P298)
P299: ((299 * dt), y(P298) + ((0.12 * (11 - y(P298))) * dt))
s299 = Segment(P298, P299)
P300: ((300 * dt), y(P299) + ((0.12 * (11 - y(P299))) * dt))
s300 = Segment(P299, P300)
P301: ((301 * dt), y(P300) + ((0.12 * (11 - y(P300))) * dt))
s301 = Segment(P300, P301)
P302: ((302 * dt), y(P301) + ((0.12 * (11 - y(P301))) * dt))
s302 = Segment(P301, P302)
P303: ((303 * dt), y(P302) + ((0.12 * (11 - y(P302))) * dt))
s303 = Segment(P302, P303)
P304: ((304 * dt), y(P303) + ((0.12 * (11 - y(P303))) * dt))
s304 = Segment(P303, P304)
P305: ((305 * dt), y(P304) + ((0.12 * (11 - y(P304))) * dt))
s305 = Segment(P304, P305)
P306: ((306 * dt), y(P305) + ((0.12 * (11 - y(P305))) * dt))
s306 = Segment(P305, P306)
P307: ((307 * dt), y(P306) + ((0.12 * (11 - y(P306))) * dt))
s307 = Segment(P306, P307)
P308: ((308 * dt), y(P307) + ((0.12 * (11 - y(P307))) * dt))
s308 = Segment(P307, P308)
P309: ((309 * dt), y(P308) + ((0.12 * (11 - y(P308))) * dt))
s309 = Segment(P308, P309)
P310: ((310 * dt), y(P309) + ((0.12 * (11 - y(P309))) * dt))
s310 = Segment(P309, P310)
P311: ((311 * dt), y(P310) + ((0.12 * (11 - y(P310))) * dt))
s311 = Segment(P310, P311)
P312: ((312 * dt), y(P311) + ((0.12 * (11 - y(P311))) * dt))
s312 = Segment(P311, P312)
P313: ((313 * dt), y(P312) + ((0.12 * (11 - y(P312))) * dt))
s313 = Segment(P312, P313)
P314: ((314 * dt), y(P313) + ((0.12 * (11 - y(P313))) * dt))
s314 = Segment(P313, P314)
P315: ((315 * dt), y(P314) + ((0.12 * (11 - y(P314))) * dt))
s315 = Segment(P314, P315)
P316: ((316 * dt), y(P315) + ((0.12 * (11 - y(P315))) * dt))
s316 = Segment(P315, P316)
P317: ((317 * dt), y(P316) + ((0.12 * (11 - y(P316))) * dt))
s317 = Segment(P316, P317)
P318: ((318 * dt), y(P317) + ((0.12 * (11 - y(P317))) * dt))
s318 = Segment(P317, P318)
P319: ((319 * dt), y(P318) + ((0.12 * (11 - y(P318))) * dt))
s319 = Segment(P318, P319)
P320: ((320 * dt), y(P319) + ((0.12 * (11 - y(P319))) * dt))
s320 = Segment(P319, P320)
P321: ((321 * dt), y(P320) + ((0.12 * (11 - y(P320))) * dt))
s321 = Segment(P320, P321)
P322: ((322 * dt), y(P321) + ((0.12 * (11 - y(P321))) * dt))
s322 = Segment(P321, P322)
P323: ((323 * dt), y(P322) + ((0.12 * (11 - y(P322))) * dt))
s323 = Segment(P322, P323)
P324: ((324 * dt), y(P323) + ((0.12 * (11 - y(P323))) * dt))
s324 = Segment(P323, P324)
P325: ((325 * dt), y(P324) + ((0.12 * (11 - y(P324))) * dt))
s325 = Segment(P324, P325)
P326: ((326 * dt), y(P325) + ((0.12 * (11 - y(P325))) * dt))
s326 = Segment(P325, P326)
P327: ((327 * dt), y(P326) + ((0.12 * (11 - y(P326))) * dt))
s327 = Segment(P326, P327)
P328: ((328 * dt), y(P327) + ((0.12 * (11 - y(P327))) * dt))
s328 = Segment(P327, P328)
P329: ((329 * dt), y(P328) + ((0.12 * (11 - y(P328))) * dt))
s329 = Segment(P328, P329)
P330: ((330 * dt), y(P329) + ((0.12 * (11 - y(P329))) * dt))
s330 = Segment(P329, P330)
P331: ((331 * dt), y(P330) + ((0.12 * (11 - y(P330))) * dt))
s331 = Segment(P330, P331)
P332: ((332 * dt), y(P331) + ((0.12 * (11 - y(P331))) * dt))
s332 = Segment(P331, P332)
P333: ((333 * dt), y(P332) + ((0.12 * (11 - y(P332))) * dt))
s333 = Segment(P332, P333)
P334: ((334 * dt), y(P333) + ((0.12 * (11 - y(P333))) * dt))
s334 = Segment(P333, P334)
P335: ((335 * dt), y(P334) + ((0.12 * (11 - y(P334))) * dt))
s335 = Segment(P334, P335)
P336: ((336 * dt), y(P335) + ((0.12 * (11 - y(P335))) * dt))
s336 = Segment(P335, P336)
P337: ((337 * dt), y(P336) + ((0.12 * (11 - y(P336))) * dt))
s337 = Segment(P336, P337)
P338: ((338 * dt), y(P337) + ((0.12 * (11 - y(P337))) * dt))
s338 = Segment(P337, P338)
P339: ((339 * dt), y(P338) + ((0.12 * (11 - y(P338))) * dt))
s339 = Segment(P338, P339)
P340: ((340 * dt), y(P339) + ((0.12 * (11 - y(P339))) * dt))
s340 = Segment(P339, P340)
P341: ((341 * dt), y(P340) + ((0.12 * (11 - y(P340))) * dt))
s341 = Segment(P340, P341)
P342: ((342 * dt), y(P341) + ((0.12 * (11 - y(P341))) * dt))
s342 = Segment(P341, P342)
P343: ((343 * dt), y(P342) + ((0.12 * (11 - y(P342))) * dt))
s343 = Segment(P342, P343)
P344: ((344 * dt), y(P343) + ((0.12 * (11 - y(P343))) * dt))
s344 = Segment(P343, P344)
P345: ((345 * dt), y(P344) + ((0.12 * (11 - y(P344))) * dt))
s345 = Segment(P344, P345)
P346: ((346 * dt), y(P345) + ((0.12 * (11 - y(P345))) * dt))
s346 = Segment(P345, P346)
P347: ((347 * dt), y(P346) + ((0.12 * (11 - y(P346))) * dt))
s347 = Segment(P346, P347)
P348: ((348 * dt), y(P347) + ((0.12 * (11 - y(P347))) * dt))
s348 = Segment(P347, P348)
P349: ((349 * dt), y(P348) + ((0.12 * (11 - y(P348))) * dt))
s349 = Segment(P348, P349)
P350: ((350 * dt), y(P349) + ((0.12 * (11 - y(P349))) * dt))
s350 = Segment(P349, P350)
P351: ((351 * dt), y(P350) + ((0.12 * (11 - y(P350))) * dt))
s351 = Segment(P350, P351)
P352: ((352 * dt), y(P351) + ((0.12 * (11 - y(P351))) * dt))
s352 = Segment(P351, P352)
P353: ((353 * dt), y(P352) + ((0.12 * (11 - y(P352))) * dt))
s353 = Segment(P352, P353)
P354: ((354 * dt), y(P353) + ((0.12 * (11 - y(P353))) * dt))
s354 = Segment(P353, P354)
P355: ((355 * dt), y(P354) + ((0.12 * (11 - y(P354))) * dt))
s355 = Segment(P354, P355)
P356: ((356 * dt), y(P355) + ((0.12 * (11 - y(P355))) * dt))
s356 = Segment(P355, P356)
P357: ((357 * dt), y(P356) + ((0.12 * (11 - y(P356))) * dt))
s357 = Segment(P356, P357)
P358: ((358 * dt), y(P357) + ((0.12 * (11 - y(P357))) * dt))
s358 = Segment(P357, P358)
P359: ((359 * dt), y(P358) + ((0.12 * (11 - y(P358))) * dt))
s359 = Segment(P358, P359)
P360: ((360 * dt), y(P359) + ((0.12 * (11 - y(P359))) * dt))
s360 = Segment(P359, P360)
P361: ((361 * dt), y(P360) + ((0.12 * (11 - y(P360))) * dt))
s361 = Segment(P360, P361)
P362: ((362 * dt), y(P361) + ((0.12 * (11 - y(P361))) * dt))
s362 = Segment(P361, P362)
P363: ((363 * dt), y(P362) + ((0.12 * (11 - y(P362))) * dt))
s363 = Segment(P362, P363)
P364: ((364 * dt), y(P363) + ((0.12 * (11 - y(P363))) * dt))
s364 = Segment(P363, P364)
P365: ((365 * dt), y(P364) + ((0.12 * (11 - y(P364))) * dt))
s365 = Segment(P364, P365)
P366: ((366 * dt), y(P365) + ((0.12 * (11 - y(P365))) * dt))
s366 = Segment(P365, P366)
P367: ((367 * dt), y(P366) + ((0.12 * (11 - y(P366))) * dt))
s367 = Segment(P366, P367)
P368: ((368 * dt), y(P367) + ((0.12 * (11 - y(P367))) * dt))
s368 = Segment(P367, P368)
P369: ((369 * dt), y(P368) + ((0.12 * (11 - y(P368))) * dt))
s369 = Segment(P368, P369)
P370: ((370 * dt), y(P369) + ((0.12 * (11 - y(P369))) * dt))
s370 = Segment(P369, P370)
P371: ((371 * dt), y(P370) + ((0.12 * (11 - y(P370))) * dt))
s371 = Segment(P370, P371)
P372: ((372 * dt), y(P371) + ((0.12 * (11 - y(P371))) * dt))
s372 = Segment(P371, P372)
P373: ((373 * dt), y(P372) + ((0.12 * (11 - y(P372))) * dt))
s373 = Segment(P372, P373)
P374: ((374 * dt), y(P373) + ((0.12 * (11 - y(P373))) * dt))
s374 = Segment(P373, P374)
P375: ((375 * dt), y(P374) + ((0.12 * (11 - y(P374))) * dt))
s375 = Segment(P374, P375)
P376: ((376 * dt), y(P375) + ((0.12 * (11 - y(P375))) * dt))
s376 = Segment(P375, P376)
P377: ((377 * dt), y(P376) + ((0.12 * (11 - y(P376))) * dt))
s377 = Segment(P376, P377)
P378: ((378 * dt), y(P377) + ((0.12 * (11 - y(P377))) * dt))
s378 = Segment(P377, P378)
P379: ((379 * dt), y(P378) + ((0.12 * (11 - y(P378))) * dt))
s379 = Segment(P378, P379)
P380: ((380 * dt), y(P379) + ((0.12 * (11 - y(P379))) * dt))
s380 = Segment(P379, P380)
P381: ((381 * dt), y(P380) + ((0.12 * (11 - y(P380))) * dt))
s381 = Segment(P380, P381)
P382: ((382 * dt), y(P381) + ((0.12 * (11 - y(P381))) * dt))
s382 = Segment(P381, P382)
P383: ((383 * dt), y(P382) + ((0.12 * (11 - y(P382))) * dt))
s383 = Segment(P382, P383)
P384: ((384 * dt), y(P383) + ((0.12 * (11 - y(P383))) * dt))
s384 = Segment(P383, P384)
P385: ((385 * dt), y(P384) + ((0.12 * (11 - y(P384))) * dt))
s385 = Segment(P384, P385)
P386: ((386 * dt), y(P385) + ((0.12 * (11 - y(P385))) * dt))
s386 = Segment(P385, P386)
P387: ((387 * dt), y(P386) + ((0.12 * (11 - y(P386))) * dt))
s387 = Segment(P386, P387)
P388: ((388 * dt), y(P387) + ((0.12 * (11 - y(P387))) * dt))
s388 = Segment(P387, P388)
P389: ((389 * dt), y(P388) + ((0.12 * (11 - y(P388))) * dt))
s389 = Segment(P388, P389)
P390: ((390 * dt), y(P389) + ((0.12 * (11 - y(P389))) * dt))
s390 = Segment(P389, P390)
P391: ((391 * dt), y(P390) + ((0.12 * (11 - y(P390))) * dt))
s391 = Segment(P390, P391)
P392: ((392 * dt), y(P391) + ((0.12 * (11 - y(P391))) * dt))
s392 = Segment(P391, P392)
P393: ((393 * dt), y(P392) + ((0.12 * (11 - y(P392))) * dt))
s393 = Segment(P392, P393)
P394: ((394 * dt), y(P393) + ((0.12 * (11 - y(P393))) * dt))
s394 = Segment(P393, P394)
P395: ((395 * dt), y(P394) + ((0.12 * (11 - y(P394))) * dt))
s395 = Segment(P394, P395)
P396: ((396 * dt), y(P395) + ((0.12 * (11 - y(P395))) * dt))
s396 = Segment(P395, P396)
P397: ((397 * dt), y(P396) + ((0.12 * (11 - y(P396))) * dt))
s397 = Segment(P396, P397)
P398: ((398 * dt), y(P397) + ((0.12 * (11 - y(P397))) * dt))
s398 = Segment(P397, P398)
P399: ((399 * dt), y(P398) + ((0.12 * (11 - y(P398))) * dt))
s399 = Segment(P398, P399)
P400: ((400 * dt), y(P399) + ((0.12 * (11 - y(P399))) * dt))
s400 = Segment(P399, P400)
P401: ((401 * dt), y(P400) + ((0.12 * (11 - y(P400))) * dt))
s401 = Segment(P400, P401)
P402: ((402 * dt), y(P401) + ((0.12 * (11 - y(P401))) * dt))
s402 = Segment(P401, P402)
P403: ((403 * dt), y(P402) + ((0.12 * (11 - y(P402))) * dt))
s403 = Segment(P402, P403)
P404: ((404 * dt), y(P403) + ((0.12 * (11 - y(P403))) * dt))
s404 = Segment(P403, P404)
P405: ((405 * dt), y(P404) + ((0.12 * (11 - y(P404))) * dt))
s405 = Segment(P404, P405)
P406: ((406 * dt), y(P405) + ((0.12 * (11 - y(P405))) * dt))
s406 = Segment(P405, P406)
P407: ((407 * dt), y(P406) + ((0.12 * (11 - y(P406))) * dt))
s407 = Segment(P406, P407)
P408: ((408 * dt), y(P407) + ((0.12 * (11 - y(P407))) * dt))
s408 = Segment(P407, P408)
P409: ((409 * dt), y(P408) + ((0.12 * (11 - y(P408))) * dt))
s409 = Segment(P408, P409)
P410: ((410 * dt), y(P409) + ((0.12 * (11 - y(P409))) * dt))
s410 = Segment(P409, P410)
P411: ((411 * dt), y(P410) + ((0.12 * (11 - y(P410))) * dt))
s411 = Segment(P410, P411)
P412: ((412 * dt), y(P411) + ((0.12 * (11 - y(P411))) * dt))
s412 = Segment(P411, P412)
P413: ((413 * dt), y(P412) + ((0.12 * (11 - y(P412))) * dt))
s413 = Segment(P412, P413)
P414: ((414 * dt), y(P413) + ((0.12 * (11 - y(P413))) * dt))
s414 = Segment(P413, P414)
P415: ((415 * dt), y(P414) + ((0.12 * (11 - y(P414))) * dt))
s415 = Segment(P414, P415)
P416: ((416 * dt), y(P415) + ((0.12 * (11 - y(P415))) * dt))
s416 = Segment(P415, P416)
P417: ((417 * dt), y(P416) + ((0.12 * (11 - y(P416))) * dt))
s417 = Segment(P416, P417)
P418: ((418 * dt), y(P417) + ((0.12 * (11 - y(P417))) * dt))
s418 = Segment(P417, P418)
P419: ((419 * dt), y(P418) + ((0.12 * (11 - y(P418))) * dt))
s419 = Segment(P418, P419)
P420: ((420 * dt), y(P419) + ((0.12 * (11 - y(P419))) * dt))
s420 = Segment(P419, P420)
P421: ((421 * dt), y(P420) + ((0.12 * (11 - y(P420))) * dt))
s421 = Segment(P420, P421)
P422: ((422 * dt), y(P421) + ((0.12 * (11 - y(P421))) * dt))
s422 = Segment(P421, P422)
P423: ((423 * dt), y(P422) + ((0.12 * (11 - y(P422))) * dt))
s423 = Segment(P422, P423)
P424: ((424 * dt), y(P423) + ((0.12 * (11 - y(P423))) * dt))
s424 = Segment(P423, P424)
P425: ((425 * dt), y(P424) + ((0.12 * (11 - y(P424))) * dt))
s425 = Segment(P424, P425)
P426: ((426 * dt), y(P425) + ((0.12 * (11 - y(P425))) * dt))
s426 = Segment(P425, P426)
P427: ((427 * dt), y(P426) + ((0.12 * (11 - y(P426))) * dt))
s427 = Segment(P426, P427)
P428: ((428 * dt), y(P427) + ((0.12 * (11 - y(P427))) * dt))
s428 = Segment(P427, P428)
P429: ((429 * dt), y(P428) + ((0.12 * (11 - y(P428))) * dt))
s429 = Segment(P428, P429)
P430: ((430 * dt), y(P429) + ((0.12 * (11 - y(P429))) * dt))
s430 = Segment(P429, P430)
P431: ((431 * dt), y(P430) + ((0.12 * (11 - y(P430))) * dt))
s431 = Segment(P430, P431)
P432: ((432 * dt), y(P431) + ((0.12 * (11 - y(P431))) * dt))
s432 = Segment(P431, P432)
P433: ((433 * dt), y(P432) + ((0.12 * (11 - y(P432))) * dt))
s433 = Segment(P432, P433)
P434: ((434 * dt), y(P433) + ((0.12 * (11 - y(P433))) * dt))
s434 = Segment(P433, P434)
P435: ((435 * dt), y(P434) + ((0.12 * (11 - y(P434))) * dt))
s435 = Segment(P434, P435)
P436: ((436 * dt), y(P435) + ((0.12 * (11 - y(P435))) * dt))
s436 = Segment(P435, P436)
P437: ((437 * dt), y(P436) + ((0.12 * (11 - y(P436))) * dt))
s437 = Segment(P436, P437)
P438: ((438 * dt), y(P437) + ((0.12 * (11 - y(P437))) * dt))
s438 = Segment(P437, P438)
P439: ((439 * dt), y(P438) + ((0.12 * (11 - y(P438))) * dt))
s439 = Segment(P438, P439)
P440: ((440 * dt), y(P439) + ((0.12 * (11 - y(P439))) * dt))
s440 = Segment(P439, P440)
P441: ((441 * dt), y(P440) + ((0.12 * (11 - y(P440))) * dt))
s441 = Segment(P440, P441)
P442: ((442 * dt), y(P441) + ((0.12 * (11 - y(P441))) * dt))
s442 = Segment(P441, P442)
P443: ((443 * dt), y(P442) + ((0.12 * (11 - y(P442))) * dt))
s443 = Segment(P442, P443)
P444: ((444 * dt), y(P443) + ((0.12 * (11 - y(P443))) * dt))
s444 = Segment(P443, P444)
P445: ((445 * dt), y(P444) + ((0.12 * (11 - y(P444))) * dt))
s445 = Segment(P444, P445)
P446: ((446 * dt), y(P445) + ((0.12 * (11 - y(P445))) * dt))
s446 = Segment(P445, P446)
P447: ((447 * dt), y(P446) + ((0.12 * (11 - y(P446))) * dt))
s447 = Segment(P446, P447)
P448: ((448 * dt), y(P447) + ((0.12 * (11 - y(P447))) * dt))
s448 = Segment(P447, P448)
P449: ((449 * dt), y(P448) + ((0.12 * (11 - y(P448))) * dt))
s449 = Segment(P448, P449)
P450: ((450 * dt), y(P449) + ((0.12 * (11 - y(P449))) * dt))
s450 = Segment(P449, P450)
P451: ((451 * dt), y(P450) + ((0.12 * (11 - y(P450))) * dt))
s451 = Segment(P450, P451)
P452: ((452 * dt), y(P451) + ((0.12 * (11 - y(P451))) * dt))
s452 = Segment(P451, P452)
P453: ((453 * dt), y(P452) + ((0.12 * (11 - y(P452))) * dt))
s453 = Segment(P452, P453)
P454: ((454 * dt), y(P453) + ((0.12 * (11 - y(P453))) * dt))
s454 = Segment(P453, P454)
P455: ((455 * dt), y(P454) + ((0.12 * (11 - y(P454))) * dt))
s455 = Segment(P454, P455)
P456: ((456 * dt), y(P455) + ((0.12 * (11 - y(P455))) * dt))
s456 = Segment(P455, P456)
P457: ((457 * dt), y(P456) + ((0.12 * (11 - y(P456))) * dt))
s457 = Segment(P456, P457)
P458: ((458 * dt), y(P457) + ((0.12 * (11 - y(P457))) * dt))
s458 = Segment(P457, P458)
P459: ((459 * dt), y(P458) + ((0.12 * (11 - y(P458))) * dt))
s459 = Segment(P458, P459)
P460: ((460 * dt), y(P459) + ((0.12 * (11 - y(P459))) * dt))
s460 = Segment(P459, P460)
P461: ((461 * dt), y(P460) + ((0.12 * (11 - y(P460))) * dt))
s461 = Segment(P460, P461)
P462: ((462 * dt), y(P461) + ((0.12 * (11 - y(P461))) * dt))
s462 = Segment(P461, P462)
P463: ((463 * dt), y(P462) + ((0.12 * (11 - y(P462))) * dt))
s463 = Segment(P462, P463)
P464: ((464 * dt), y(P463) + ((0.12 * (11 - y(P463))) * dt))
s464 = Segment(P463, P464)
P465: ((465 * dt), y(P464) + ((0.12 * (11 - y(P464))) * dt))
s465 = Segment(P464, P465)
P466: ((466 * dt), y(P465) + ((0.12 * (11 - y(P465))) * dt))
s466 = Segment(P465, P466)
P467: ((467 * dt), y(P466) + ((0.12 * (11 - y(P466))) * dt))
s467 = Segment(P466, P467)
P468: ((468 * dt), y(P467) + ((0.12 * (11 - y(P467))) * dt))
s468 = Segment(P467, P468)
P469: ((469 * dt), y(P468) + ((0.12 * (11 - y(P468))) * dt))
s469 = Segment(P468, P469)
P470: ((470 * dt), y(P469) + ((0.12 * (11 - y(P469))) * dt))
s470 = Segment(P469, P470)
P471: ((471 * dt), y(P470) + ((0.12 * (11 - y(P470))) * dt))
s471 = Segment(P470, P471)
P472: ((472 * dt), y(P471) + ((0.12 * (11 - y(P471))) * dt))
s472 = Segment(P471, P472)
P473: ((473 * dt), y(P472) + ((0.12 * (11 - y(P472))) * dt))
s473 = Segment(P472, P473)
P474: ((474 * dt), y(P473) + ((0.12 * (11 - y(P473))) * dt))
s474 = Segment(P473, P474)
P475: ((475 * dt), y(P474) + ((0.12 * (11 - y(P474))) * dt))
s475 = Segment(P474, P475)
P476: ((476 * dt), y(P475) + ((0.12 * (11 - y(P475))) * dt))
s476 = Segment(P475, P476)
P477: ((477 * dt), y(P476) + ((0.12 * (11 - y(P476))) * dt))
s477 = Segment(P476, P477)
P478: ((478 * dt), y(P477) + ((0.12 * (11 - y(P477))) * dt))
s478 = Segment(P477, P478)
P479: ((479 * dt), y(P478) + ((0.12 * (11 - y(P478))) * dt))
s479 = Segment(P478, P479)
P480: ((480 * dt), y(P479) + ((0.12 * (11 - y(P479))) * dt))
s480 = Segment(P479, P480)
P481: ((481 * dt), y(P480) + ((0.12 * (11 - y(P480))) * dt))
s481 = Segment(P480, P481)
P482: ((482 * dt), y(P481) + ((0.12 * (11 - y(P481))) * dt))
s482 = Segment(P481, P482)
P483: ((483 * dt), y(P482) + ((0.12 * (11 - y(P482))) * dt))
s483 = Segment(P482, P483)
P484: ((484 * dt), y(P483) + ((0.12 * (11 - y(P483))) * dt))
s484 = Segment(P483, P484)
P485: ((485 * dt), y(P484) + ((0.12 * (11 - y(P484))) * dt))
s485 = Segment(P484, P485)
P486: ((486 * dt), y(P485) + ((0.12 * (11 - y(P485))) * dt))
s486 = Segment(P485, P486)
P487: ((487 * dt), y(P486) + ((0.12 * (11 - y(P486))) * dt))
s487 = Segment(P486, P487)
P488: ((488 * dt), y(P487) + ((0.12 * (11 - y(P487))) * dt))
s488 = Segment(P487, P488)
P489: ((489 * dt), y(P488) + ((0.12 * (11 - y(P488))) * dt))
s489 = Segment(P488, P489)
P490: ((490 * dt), y(P489) + ((0.12 * (11 - y(P489))) * dt))
s490 = Segment(P489, P490)
P491: ((491 * dt), y(P490) + ((0.12 * (11 - y(P490))) * dt))
s491 = Segment(P490, P491)
P492: ((492 * dt), y(P491) + ((0.12 * (11 - y(P491))) * dt))
s492 = Segment(P491, P492)
P493: ((493 * dt), y(P492) + ((0.12 * (11 - y(P492))) * dt))
s493 = Segment(P492, P493)
P494: ((494 * dt), y(P493) + ((0.12 * (11 - y(P493))) * dt))
s494 = Segment(P493, P494)
P495: ((495 * dt), y(P494) + ((0.12 * (11 - y(P494))) * dt))
s495 = Segment(P494, P495)
P496: ((496 * dt), y(P495) + ((0.12 * (11 - y(P495))) * dt))
s496 = Segment(P495, P496)
P497: ((497 * dt), y(P496) + ((0.12 * (11 - y(P496))) * dt))
s497 = Segment(P496, P497)
P498: ((498 * dt), y(P497) + ((0.12 * (11 - y(P497))) * dt))
s498 = Segment(P497, P498)
P499: ((499 * dt), y(P498) + ((0.12 * (11 - y(P498))) * dt))
s499 = Segment(P498, P499)
P500: ((500 * dt), y(P499) + ((0.12 * (11 - y(P499))) * dt))
s500 = Segment(P499, P500)
P501: ((501 * dt), y(P500) + ((0.12 * (11 - y(P500))) * dt))
s501 = Segment(P500, P501)
P502: ((502 * dt), y(P501) + ((0.12 * (11 - y(P501))) * dt))
s502 = Segment(P501, P502)
P503: ((503 * dt), y(P502) + ((0.12 * (11 - y(P502))) * dt))
s503 = Segment(P502, P503)
P504: ((504 * dt), y(P503) + ((0.12 * (11 - y(P503))) * dt))
s504 = Segment(P503, P504)
P505: ((505 * dt), y(P504) + ((0.12 * (11 - y(P504))) * dt))
s505 = Segment(P504, P505)
P506: ((506 * dt), y(P505) + ((0.12 * (11 - y(P505))) * dt))
s506 = Segment(P505, P506)
P507: ((507 * dt), y(P506) + ((0.12 * (11 - y(P506))) * dt))
s507 = Segment(P506, P507)
P508: ((508 * dt), y(P507) + ((0.12 * (11 - y(P507))) * dt))
s508 = Segment(P507, P508)
P509: ((509 * dt), y(P508) + ((0.12 * (11 - y(P508))) * dt))
s509 = Segment(P508, P509)
P510: ((510 * dt), y(P509) + ((0.12 * (11 - y(P509))) * dt))
s510 = Segment(P509, P510)
P511: ((511 * dt), y(P510) + ((0.12 * (11 - y(P510))) * dt))
s511 = Segment(P510, P511)
P512: ((512 * dt), y(P511) + ((0.12 * (11 - y(P511))) * dt))
s512 = Segment(P511, P512)
P513: ((513 * dt), y(P512) + ((0.12 * (11 - y(P512))) * dt))
s513 = Segment(P512, P513)
P514: ((514 * dt), y(P513) + ((0.12 * (11 - y(P513))) * dt))
s514 = Segment(P513, P514)
P515: ((515 * dt), y(P514) + ((0.12 * (11 - y(P514))) * dt))
s515 = Segment(P514, P515)
P516: ((516 * dt), y(P515) + ((0.12 * (11 - y(P515))) * dt))
s516 = Segment(P515, P516)
P517: ((517 * dt), y(P516) + ((0.12 * (11 - y(P516))) * dt))
s517 = Segment(P516, P517)
P518: ((518 * dt), y(P517) + ((0.12 * (11 - y(P517))) * dt))
s518 = Segment(P517, P518)
P519: ((519 * dt), y(P518) + ((0.12 * (11 - y(P518))) * dt))
s519 = Segment(P518, P519)
P520: ((520 * dt), y(P519) + ((0.12 * (11 - y(P519))) * dt))
s520 = Segment(P519, P520)
P521: ((521 * dt), y(P520) + ((0.12 * (11 - y(P520))) * dt))
s521 = Segment(P520, P521)
P522: ((522 * dt), y(P521) + ((0.12 * (11 - y(P521))) * dt))
s522 = Segment(P521, P522)
P523: ((523 * dt), y(P522) + ((0.12 * (11 - y(P522))) * dt))
s523 = Segment(P522, P523)
P524: ((524 * dt), y(P523) + ((0.12 * (11 - y(P523))) * dt))
s524 = Segment(P523, P524)
P525: ((525 * dt), y(P524) + ((0.12 * (11 - y(P524))) * dt))
s525 = Segment(P524, P525)
P526: ((526 * dt), y(P525) + ((0.12 * (11 - y(P525))) * dt))
s526 = Segment(P525, P526)
P527: ((527 * dt), y(P526) + ((0.12 * (11 - y(P526))) * dt))
s527 = Segment(P526, P527)
P528: ((528 * dt), y(P527) + ((0.12 * (11 - y(P527))) * dt))
s528 = Segment(P527, P528)
P529: ((529 * dt), y(P528) + ((0.12 * (11 - y(P528))) * dt))
s529 = Segment(P528, P529)
P530: ((530 * dt), y(P529) + ((0.12 * (11 - y(P529))) * dt))
s530 = Segment(P529, P530)
P531: ((531 * dt), y(P530) + ((0.12 * (11 - y(P530))) * dt))
s531 = Segment(P530, P531)
P532: ((532 * dt), y(P531) + ((0.12 * (11 - y(P531))) * dt))
s532 = Segment(P531, P532)
P533: ((533 * dt), y(P532) + ((0.12 * (11 - y(P532))) * dt))
s533 = Segment(P532, P533)
P534: ((534 * dt), y(P533) + ((0.12 * (11 - y(P533))) * dt))
s534 = Segment(P533, P534)
P535: ((535 * dt), y(P534) + ((0.12 * (11 - y(P534))) * dt))
s535 = Segment(P534, P535)
P536: ((536 * dt), y(P535) + ((0.12 * (11 - y(P535))) * dt))
s536 = Segment(P535, P536)
P537: ((537 * dt), y(P536) + ((0.12 * (11 - y(P536))) * dt))
s537 = Segment(P536, P537)
P538: ((538 * dt), y(P537) + ((0.12 * (11 - y(P537))) * dt))
s538 = Segment(P537, P538)
P539: ((539 * dt), y(P538) + ((0.12 * (11 - y(P538))) * dt))
s539 = Segment(P538, P539)
P540: ((540 * dt), y(P539) + ((0.12 * (11 - y(P539))) * dt))
s540 = Segment(P539, P540)
P541: ((541 * dt), y(P540) + ((0.12 * (11 - y(P540))) * dt))
s541 = Segment(P540, P541)
P542: ((542 * dt), y(P541) + ((0.12 * (11 - y(P541))) * dt))
s542 = Segment(P541, P542)
P543: ((543 * dt), y(P542) + ((0.12 * (11 - y(P542))) * dt))
s543 = Segment(P542, P543)
P544: ((544 * dt), y(P543) + ((0.12 * (11 - y(P543))) * dt))
s544 = Segment(P543, P544)
P545: ((545 * dt), y(P544) + ((0.12 * (11 - y(P544))) * dt))
s545 = Segment(P544, P545)
P546: ((546 * dt), y(P545) + ((0.12 * (11 - y(P545))) * dt))
s546 = Segment(P545, P546)
P547: ((547 * dt), y(P546) + ((0.12 * (11 - y(P546))) * dt))
s547 = Segment(P546, P547)
P548: ((548 * dt), y(P547) + ((0.12 * (11 - y(P547))) * dt))
s548 = Segment(P547, P548)
P549: ((549 * dt), y(P548) + ((0.12 * (11 - y(P548))) * dt))
s549 = Segment(P548, P549)
P550: ((550 * dt), y(P549) + ((0.12 * (11 - y(P549))) * dt))
s550 = Segment(P549, P550)
P551: ((551 * dt), y(P550) + ((0.12 * (11 - y(P550))) * dt))
s551 = Segment(P550, P551)
P552: ((552 * dt), y(P551) + ((0.12 * (11 - y(P551))) * dt))
s552 = Segment(P551, P552)
P553: ((553 * dt), y(P552) + ((0.12 * (11 - y(P552))) * dt))
s553 = Segment(P552, P553)
P554: ((554 * dt), y(P553) + ((0.12 * (11 - y(P553))) * dt))
s554 = Segment(P553, P554)
P555: ((555 * dt), y(P554) + ((0.12 * (11 - y(P554))) * dt))
s555 = Segment(P554, P555)
P556: ((556 * dt), y(P555) + ((0.12 * (11 - y(P555))) * dt))
s556 = Segment(P555, P556)
P557: ((557 * dt), y(P556) + ((0.12 * (11 - y(P556))) * dt))
s557 = Segment(P556, P557)
P558: ((558 * dt), y(P557) + ((0.12 * (11 - y(P557))) * dt))
s558 = Segment(P557, P558)
P559: ((559 * dt), y(P558) + ((0.12 * (11 - y(P558))) * dt))
s559 = Segment(P558, P559)
P560: ((560 * dt), y(P559) + ((0.12 * (11 - y(P559))) * dt))
s560 = Segment(P559, P560)
P561: ((561 * dt), y(P560) + ((0.12 * (11 - y(P560))) * dt))
s561 = Segment(P560, P561)
P562: ((562 * dt), y(P561) + ((0.12 * (11 - y(P561))) * dt))
s562 = Segment(P561, P562)
P563: ((563 * dt), y(P562) + ((0.12 * (11 - y(P562))) * dt))
s563 = Segment(P562, P563)
P564: ((564 * dt), y(P563) + ((0.12 * (11 - y(P563))) * dt))
s564 = Segment(P563, P564)
P565: ((565 * dt), y(P564) + ((0.12 * (11 - y(P564))) * dt))
s565 = Segment(P564, P565)
P566: ((566 * dt), y(P565) + ((0.12 * (11 - y(P565))) * dt))
s566 = Segment(P565, P566)
P567: ((567 * dt), y(P566) + ((0.12 * (11 - y(P566))) * dt))
s567 = Segment(P566, P567)
P568: ((568 * dt), y(P567) + ((0.12 * (11 - y(P567))) * dt))
s568 = Segment(P567, P568)
P569: ((569 * dt), y(P568) + ((0.12 * (11 - y(P568))) * dt))
s569 = Segment(P568, P569)
P570: ((570 * dt), y(P569) + ((0.12 * (11 - y(P569))) * dt))
s570 = Segment(P569, P570)
P571: ((571 * dt), y(P570) + ((0.12 * (11 - y(P570))) * dt))
s571 = Segment(P570, P571)
P572: ((572 * dt), y(P571) + ((0.12 * (11 - y(P571))) * dt))
s572 = Segment(P571, P572)
P573: ((573 * dt), y(P572) + ((0.12 * (11 - y(P572))) * dt))
s573 = Segment(P572, P573)
P574: ((574 * dt), y(P573) + ((0.12 * (11 - y(P573))) * dt))
s574 = Segment(P573, P574)
P575: ((575 * dt), y(P574) + ((0.12 * (11 - y(P574))) * dt))
s575 = Segment(P574, P575)
P576: ((576 * dt), y(P575) + ((0.12 * (11 - y(P575))) * dt))
s576 = Segment(P575, P576)
P577: ((577 * dt), y(P576) + ((0.12 * (11 - y(P576))) * dt))
s577 = Segment(P576, P577)
P578: ((578 * dt), y(P577) + ((0.12 * (11 - y(P577))) * dt))
s578 = Segment(P577, P578)
P579: ((579 * dt), y(P578) + ((0.12 * (11 - y(P578))) * dt))
s579 = Segment(P578, P579)
P580: ((580 * dt), y(P579) + ((0.12 * (11 - y(P579))) * dt))
s580 = Segment(P579, P580)
P581: ((581 * dt), y(P580) + ((0.12 * (11 - y(P580))) * dt))
s581 = Segment(P580, P581)
P582: ((582 * dt), y(P581) + ((0.12 * (11 - y(P581))) * dt))
s582 = Segment(P581, P582)
P583: ((583 * dt), y(P582) + ((0.12 * (11 - y(P582))) * dt))
s583 = Segment(P582, P583)
P584: ((584 * dt), y(P583) + ((0.12 * (11 - y(P583))) * dt))
s584 = Segment(P583, P584)
P585: ((585 * dt), y(P584) + ((0.12 * (11 - y(P584))) * dt))
s585 = Segment(P584, P585)
P586: ((586 * dt), y(P585) + ((0.12 * (11 - y(P585))) * dt))
s586 = Segment(P585, P586)
P587: ((587 * dt), y(P586) + ((0.12 * (11 - y(P586))) * dt))
s587 = Segment(P586, P587)
P588: ((588 * dt), y(P587) + ((0.12 * (11 - y(P587))) * dt))
s588 = Segment(P587, P588)
P589: ((589 * dt), y(P588) + ((0.12 * (11 - y(P588))) * dt))
s589 = Segment(P588, P589)
P590: ((590 * dt), y(P589) + ((0.12 * (11 - y(P589))) * dt))
s590 = Segment(P589, P590)
P591: ((591 * dt), y(P590) + ((0.12 * (11 - y(P590))) * dt))
s591 = Segment(P590, P591)
P592: ((592 * dt), y(P591) + ((0.12 * (11 - y(P591))) * dt))
s592 = Segment(P591, P592)
P593: ((593 * dt), y(P592) + ((0.12 * (11 - y(P592))) * dt))
s593 = Segment(P592, P593)
P594: ((594 * dt), y(P593) + ((0.12 * (11 - y(P593))) * dt))
s594 = Segment(P593, P594)
P595: ((595 * dt), y(P594) + ((0.12 * (11 - y(P594))) * dt))
s595 = Segment(P594, P595)
P596: ((596 * dt), y(P595) + ((0.12 * (11 - y(P595))) * dt))
s596 = Segment(P595, P596)
P597: ((597 * dt), y(P596) + ((0.12 * (11 - y(P596))) * dt))
s597 = Segment(P596, P597)
P598: ((598 * dt), y(P597) + ((0.12 * (11 - y(P597))) * dt))
s598 = Segment(P597, P598)
P599: ((599 * dt), y(P598) + ((0.12 * (11 - y(P598))) * dt))
s599 = Segment(P598, P599)
P600: ((600 * dt), y(P599) + ((0.12 * (11 - y(P599))) * dt))
s600 = Segment(P599, P600)
P601: ((601 * dt), y(P600) + ((0.12 * (11 - y(P600))) * dt))
s601 = Segment(P600, P601)
P602: ((602 * dt), y(P601) + ((0.12 * (11 - y(P601))) * dt))
s602 = Segment(P601, P602)
P603: ((603 * dt), y(P602) + ((0.12 * (11 - y(P602))) * dt))
s603 = Segment(P602, P603)
P604: ((604 * dt), y(P603) + ((0.12 * (11 - y(P603))) * dt))
s604 = Segment(P603, P604)
P605: ((605 * dt), y(P604) + ((0.12 * (11 - y(P604))) * dt))
s605 = Segment(P604, P605)
P606: ((606 * dt), y(P605) + ((0.12 * (11 - y(P605))) * dt))
s606 = Segment(P605, P606)
P607: ((607 * dt), y(P606) + ((0.12 * (11 - y(P606))) * dt))
s607 = Segment(P606, P607)
P608: ((608 * dt), y(P607) + ((0.12 * (11 - y(P607))) * dt))
s608 = Segment(P607, P608)
P609: ((609 * dt), y(P608) + ((0.12 * (11 - y(P608))) * dt))
s609 = Segment(P608, P609)
P610: ((610 * dt), y(P609) + ((0.12 * (11 - y(P609))) * dt))
s610 = Segment(P609, P610)
P611: ((611 * dt), y(P610) + ((0.12 * (11 - y(P610))) * dt))
s611 = Segment(P610, P611)
P612: ((612 * dt), y(P611) + ((0.12 * (11 - y(P611))) * dt))
s612 = Segment(P611, P612)
P613: ((613 * dt), y(P612) + ((0.12 * (11 - y(P612))) * dt))
s613 = Segment(P612, P613)
P614: ((614 * dt), y(P613) + ((0.12 * (11 - y(P613))) * dt))
s614 = Segment(P613, P614)
P615: ((615 * dt), y(P614) + ((0.12 * (11 - y(P614))) * dt))
s615 = Segment(P614, P615)
P616: ((616 * dt), y(P615) + ((0.12 * (11 - y(P615))) * dt))
s616 = Segment(P615, P616)
P617: ((617 * dt), y(P616) + ((0.12 * (11 - y(P616))) * dt))
s617 = Segment(P616, P617)
P618: ((618 * dt), y(P617) + ((0.12 * (11 - y(P617))) * dt))
s618 = Segment(P617, P618)
P619: ((619 * dt), y(P618) + ((0.12 * (11 - y(P618))) * dt))
s619 = Segment(P618, P619)
P620: ((620 * dt), y(P619) + ((0.12 * (11 - y(P619))) * dt))
s620 = Segment(P619, P620)
P621: ((621 * dt), y(P620) + ((0.12 * (11 - y(P620))) * dt))
s621 = Segment(P620, P621)
P622: ((622 * dt), y(P621) + ((0.12 * (11 - y(P621))) * dt))
s622 = Segment(P621, P622)
P623: ((623 * dt), y(P622) + ((0.12 * (11 - y(P622))) * dt))
s623 = Segment(P622, P623)
P624: ((624 * dt), y(P623) + ((0.12 * (11 - y(P623))) * dt))
s624 = Segment(P623, P624)
P625: ((625 * dt), y(P624) + ((0.12 * (11 - y(P624))) * dt))
s625 = Segment(P624, P625)
P626: ((626 * dt), y(P625) + ((0.12 * (11 - y(P625))) * dt))
s626 = Segment(P625, P626)
P627: ((627 * dt), y(P626) + ((0.12 * (11 - y(P626))) * dt))
s627 = Segment(P626, P627)
P628: ((628 * dt), y(P627) + ((0.12 * (11 - y(P627))) * dt))
s628 = Segment(P627, P628)
P629: ((629 * dt), y(P628) + ((0.12 * (11 - y(P628))) * dt))
s629 = Segment(P628, P629)
P630: ((630 * dt), y(P629) + ((0.12 * (11 - y(P629))) * dt))
s630 = Segment(P629, P630)
P631: ((631 * dt), y(P630) + ((0.12 * (11 - y(P630))) * dt))
s631 = Segment(P630, P631)
P632: ((632 * dt), y(P631) + ((0.12 * (11 - y(P631))) * dt))
s632 = Segment(P631, P632)
P633: ((633 * dt), y(P632) + ((0.12 * (11 - y(P632))) * dt))
s633 = Segment(P632, P633)
P634: ((634 * dt), y(P633) + ((0.12 * (11 - y(P633))) * dt))
s634 = Segment(P633, P634)
P635: ((635 * dt), y(P634) + ((0.12 * (11 - y(P634))) * dt))
s635 = Segment(P634, P635)
P636: ((636 * dt), y(P635) + ((0.12 * (11 - y(P635))) * dt))
s636 = Segment(P635, P636)
P637: ((637 * dt), y(P636) + ((0.12 * (11 - y(P636))) * dt))
s637 = Segment(P636, P637)
P638: ((638 * dt), y(P637) + ((0.12 * (11 - y(P637))) * dt))
s638 = Segment(P637, P638)
P639: ((639 * dt), y(P638) + ((0.12 * (11 - y(P638))) * dt))
s639 = Segment(P638, P639)
P640: ((640 * dt), y(P639) + ((0.12 * (11 - y(P639))) * dt))
s640 = Segment(P639, P640)
P641: ((641 * dt), y(P640) + ((0.12 * (11 - y(P640))) * dt))
s641 = Segment(P640, P641)
P642: ((642 * dt), y(P641) + ((0.12 * (11 - y(P641))) * dt))
s642 = Segment(P641, P642)
P643: ((643 * dt), y(P642) + ((0.12 * (11 - y(P642))) * dt))
s643 = Segment(P642, P643)
P644: ((644 * dt), y(P643) + ((0.12 * (11 - y(P643))) * dt))
s644 = Segment(P643, P644)
P645: ((645 * dt), y(P644) + ((0.12 * (11 - y(P644))) * dt))
s645 = Segment(P644, P645)
P646: ((646 * dt), y(P645) + ((0.12 * (11 - y(P645))) * dt))
s646 = Segment(P645, P646)
P647: ((647 * dt), y(P646) + ((0.12 * (11 - y(P646))) * dt))
s647 = Segment(P646, P647)
P648: ((648 * dt), y(P647) + ((0.12 * (11 - y(P647))) * dt))
s648 = Segment(P647, P648)
P649: ((649 * dt), y(P648) + ((0.12 * (11 - y(P648))) * dt))
s649 = Segment(P648, P649)
P650: ((650 * dt), y(P649) + ((0.12 * (11 - y(P649))) * dt))
s650 = Segment(P649, P650)
P651: ((651 * dt), y(P650) + ((0.12 * (11 - y(P650))) * dt))
s651 = Segment(P650, P651)
P652: ((652 * dt), y(P651) + ((0.12 * (11 - y(P651))) * dt))
s652 = Segment(P651, P652)
P653: ((653 * dt), y(P652) + ((0.12 * (11 - y(P652))) * dt))
s653 = Segment(P652, P653)
P654: ((654 * dt), y(P653) + ((0.12 * (11 - y(P653))) * dt))
s654 = Segment(P653, P654)
P655: ((655 * dt), y(P654) + ((0.12 * (11 - y(P654))) * dt))
s655 = Segment(P654, P655)
P656: ((656 * dt), y(P655) + ((0.12 * (11 - y(P655))) * dt))
s656 = Segment(P655, P656)
P657: ((657 * dt), y(P656) + ((0.12 * (11 - y(P656))) * dt))
s657 = Segment(P656, P657)
P658: ((658 * dt), y(P657) + ((0.12 * (11 - y(P657))) * dt))
s658 = Segment(P657, P658)
P659: ((659 * dt), y(P658) + ((0.12 * (11 - y(P658))) * dt))
s659 = Segment(P658, P659)
P660: ((660 * dt), y(P659) + ((0.12 * (11 - y(P659))) * dt))
s660 = Segment(P659, P660)
P661: ((661 * dt), y(P660) + ((0.12 * (11 - y(P660))) * dt))
s661 = Segment(P660, P661)
P662: ((662 * dt), y(P661) + ((0.12 * (11 - y(P661))) * dt))
s662 = Segment(P661, P662)
P663: ((663 * dt), y(P662) + ((0.12 * (11 - y(P662))) * dt))
s663 = Segment(P662, P663)
P664: ((664 * dt), y(P663) + ((0.12 * (11 - y(P663))) * dt))
s664 = Segment(P663, P664)
P665: ((665 * dt), y(P664) + ((0.12 * (11 - y(P664))) * dt))
s665 = Segment(P664, P665)
P666: ((666 * dt), y(P665) + ((0.12 * (11 - y(P665))) * dt))
s666 = Segment(P665, P666)
P667: ((667 * dt), y(P666) + ((0.12 * (11 - y(P666))) * dt))
s667 = Segment(P666, P667)
P668: ((668 * dt), y(P667) + ((0.12 * (11 - y(P667))) * dt))
s668 = Segment(P667, P668)
P669: ((669 * dt), y(P668) + ((0.12 * (11 - y(P668))) * dt))
s669 = Segment(P668, P669)
P670: ((670 * dt), y(P669) + ((0.12 * (11 - y(P669))) * dt))
s670 = Segment(P669, P670)
P671: ((671 * dt), y(P670) + ((0.12 * (11 - y(P670))) * dt))
s671 = Segment(P670, P671)
P672: ((672 * dt), y(P671) + ((0.12 * (11 - y(P671))) * dt))
s672 = Segment(P671, P672)
P673: ((673 * dt), y(P672) + ((0.12 * (11 - y(P672))) * dt))
s673 = Segment(P672, P673)
P674: ((674 * dt), y(P673) + ((0.12 * (11 - y(P673))) * dt))
s674 = Segment(P673, P674)
P675: ((675 * dt), y(P674) + ((0.12 * (11 - y(P674))) * dt))
s675 = Segment(P674, P675)
P676: ((676 * dt), y(P675) + ((0.12 * (11 - y(P675))) * dt))
s676 = Segment(P675, P676)
P677: ((677 * dt), y(P676) + ((0.12 * (11 - y(P676))) * dt))
s677 = Segment(P676, P677)
P678: ((678 * dt), y(P677) + ((0.12 * (11 - y(P677))) * dt))
s678 = Segment(P677, P678)
P679: ((679 * dt), y(P678) + ((0.12 * (11 - y(P678))) * dt))
s679 = Segment(P678, P679)
P680: ((680 * dt), y(P679) + ((0.12 * (11 - y(P679))) * dt))
s680 = Segment(P679, P680)
P681: ((681 * dt), y(P680) + ((0.12 * (11 - y(P680))) * dt))
s681 = Segment(P680, P681)
P682: ((682 * dt), y(P681) + ((0.12 * (11 - y(P681))) * dt))
s682 = Segment(P681, P682)
P683: ((683 * dt), y(P682) + ((0.12 * (11 - y(P682))) * dt))
s683 = Segment(P682, P683)
P684: ((684 * dt), y(P683) + ((0.12 * (11 - y(P683))) * dt))
s684 = Segment(P683, P684)
P685: ((685 * dt), y(P684) + ((0.12 * (11 - y(P684))) * dt))
s685 = Segment(P684, P685)
P686: ((686 * dt), y(P685) + ((0.12 * (11 - y(P685))) * dt))
s686 = Segment(P685, P686)
P687: ((687 * dt), y(P686) + ((0.12 * (11 - y(P686))) * dt))
s687 = Segment(P686, P687)
P688: ((688 * dt), y(P687) + ((0.12 * (11 - y(P687))) * dt))
s688 = Segment(P687, P688)
P689: ((689 * dt), y(P688) + ((0.12 * (11 - y(P688))) * dt))
s689 = Segment(P688, P689)
P690: ((690 * dt), y(P689) + ((0.12 * (11 - y(P689))) * dt))
s690 = Segment(P689, P690)
P691: ((691 * dt), y(P690) + ((0.12 * (11 - y(P690))) * dt))
s691 = Segment(P690, P691)
P692: ((692 * dt), y(P691) + ((0.12 * (11 - y(P691))) * dt))
s692 = Segment(P691, P692)
P693: ((693 * dt), y(P692) + ((0.12 * (11 - y(P692))) * dt))
s693 = Segment(P692, P693)
P694: ((694 * dt), y(P693) + ((0.12 * (11 - y(P693))) * dt))
s694 = Segment(P693, P694)
P695: ((695 * dt), y(P694) + ((0.12 * (11 - y(P694))) * dt))
s695 = Segment(P694, P695)
P696: ((696 * dt), y(P695) + ((0.12 * (11 - y(P695))) * dt))
s696 = Segment(P695, P696)
P697: ((697 * dt), y(P696) + ((0.12 * (11 - y(P696))) * dt))
s697 = Segment(P696, P697)
P698: ((698 * dt), y(P697) + ((0.12 * (11 - y(P697))) * dt))
s698 = Segment(P697, P698)
P699: ((699 * dt), y(P698) + ((0.12 * (11 - y(P698))) * dt))
s699 = Segment(P698, P699)
P700: ((700 * dt), y(P699) + ((0.12 * (11 - y(P699))) * dt))
s700 = Segment(P699, P700)
P701: ((701 * dt), y(P700) + ((0.12 * (11 - y(P700))) * dt))
s701 = Segment(P700, P701)
P702: ((702 * dt), y(P701) + ((0.12 * (11 - y(P701))) * dt))
s702 = Segment(P701, P702)
P703: ((703 * dt), y(P702) + ((0.12 * (11 - y(P702))) * dt))
s703 = Segment(P702, P703)
P704: ((704 * dt), y(P703) + ((0.12 * (11 - y(P703))) * dt))
s704 = Segment(P703, P704)
P705: ((705 * dt), y(P704) + ((0.12 * (11 - y(P704))) * dt))
s705 = Segment(P704, P705)
P706: ((706 * dt), y(P705) + ((0.12 * (11 - y(P705))) * dt))
s706 = Segment(P705, P706)
P707: ((707 * dt), y(P706) + ((0.12 * (11 - y(P706))) * dt))
s707 = Segment(P706, P707)
P708: ((708 * dt), y(P707) + ((0.12 * (11 - y(P707))) * dt))
s708 = Segment(P707, P708)
P709: ((709 * dt), y(P708) + ((0.12 * (11 - y(P708))) * dt))
s709 = Segment(P708, P709)
P710: ((710 * dt), y(P709) + ((0.12 * (11 - y(P709))) * dt))
s710 = Segment(P709, P710)
P711: ((711 * dt), y(P710) + ((0.12 * (11 - y(P710))) * dt))
s711 = Segment(P710, P711)
P712: ((712 * dt), y(P711) + ((0.12 * (11 - y(P711))) * dt))
s712 = Segment(P711, P712)
P713: ((713 * dt), y(P712) + ((0.12 * (11 - y(P712))) * dt))
s713 = Segment(P712, P713)
P714: ((714 * dt), y(P713) + ((0.12 * (11 - y(P713))) * dt))
s714 = Segment(P713, P714)
P715: ((715 * dt), y(P714) + ((0.12 * (11 - y(P714))) * dt))
s715 = Segment(P714, P715)
P716: ((716 * dt), y(P715) + ((0.12 * (11 - y(P715))) * dt))
s716 = Segment(P715, P716)
P717: ((717 * dt), y(P716) + ((0.12 * (11 - y(P716))) * dt))
s717 = Segment(P716, P717)
P718: ((718 * dt), y(P717) + ((0.12 * (11 - y(P717))) * dt))
s718 = Segment(P717, P718)
P719: ((719 * dt), y(P718) + ((0.12 * (11 - y(P718))) * dt))
s719 = Segment(P718, P719)
P720: ((720 * dt), y(P719) + ((0.12 * (11 - y(P719))) * dt))
s720 = Segment(P719, P720)
P721: ((721 * dt), y(P720) + ((0.12 * (11 - y(P720))) * dt))
s721 = Segment(P720, P721)
P722: ((722 * dt), y(P721) + ((0.12 * (11 - y(P721))) * dt))
s722 = Segment(P721, P722)
P723: ((723 * dt), y(P722) + ((0.12 * (11 - y(P722))) * dt))
s723 = Segment(P722, P723)
P724: ((724 * dt), y(P723) + ((0.12 * (11 - y(P723))) * dt))
s724 = Segment(P723, P724)
P725: ((725 * dt), y(P724) + ((0.12 * (11 - y(P724))) * dt))
s725 = Segment(P724, P725)
P726: ((726 * dt), y(P725) + ((0.12 * (11 - y(P725))) * dt))
s726 = Segment(P725, P726)
P727: ((727 * dt), y(P726) + ((0.12 * (11 - y(P726))) * dt))
s727 = Segment(P726, P727)
P728: ((728 * dt), y(P727) + ((0.12 * (11 - y(P727))) * dt))
s728 = Segment(P727, P728)
P729: ((729 * dt), y(P728) + ((0.12 * (11 - y(P728))) * dt))
s729 = Segment(P728, P729)
P730: ((730 * dt), y(P729) + ((0.12 * (11 - y(P729))) * dt))
s730 = Segment(P729, P730)
P731: ((731 * dt), y(P730) + ((0.12 * (11 - y(P730))) * dt))
s731 = Segment(P730, P731)
P732: ((732 * dt), y(P731) + ((0.12 * (11 - y(P731))) * dt))
s732 = Segment(P731, P732)
P733: ((733 * dt), y(P732) + ((0.12 * (11 - y(P732))) * dt))
s733 = Segment(P732, P733)
P734: ((734 * dt), y(P733) + ((0.12 * (11 - y(P733))) * dt))
s734 = Segment(P733, P734)
P735: ((735 * dt), y(P734) + ((0.12 * (11 - y(P734))) * dt))
s735 = Segment(P734, P735)
P736: ((736 * dt), y(P735) + ((0.12 * (11 - y(P735))) * dt))
s736 = Segment(P735, P736)
P737: ((737 * dt), y(P736) + ((0.12 * (11 - y(P736))) * dt))
s737 = Segment(P736, P737)
P738: ((738 * dt), y(P737) + ((0.12 * (11 - y(P737))) * dt))
s738 = Segment(P737, P738)
P739: ((739 * dt), y(P738) + ((0.12 * (11 - y(P738))) * dt))
s739 = Segment(P738, P739)
P740: ((740 * dt), y(P739) + ((0.12 * (11 - y(P739))) * dt))
s740 = Segment(P739, P740)
P741: ((741 * dt), y(P740) + ((0.12 * (11 - y(P740))) * dt))
s741 = Segment(P740, P741)
P742: ((742 * dt), y(P741) + ((0.12 * (11 - y(P741))) * dt))
s742 = Segment(P741, P742)
P743: ((743 * dt), y(P742) + ((0.12 * (11 - y(P742))) * dt))
s743 = Segment(P742, P743)
P744: ((744 * dt), y(P743) + ((0.12 * (11 - y(P743))) * dt))
s744 = Segment(P743, P744)
P745: ((745 * dt), y(P744) + ((0.12 * (11 - y(P744))) * dt))
s745 = Segment(P744, P745)
P746: ((746 * dt), y(P745) + ((0.12 * (11 - y(P745))) * dt))
s746 = Segment(P745, P746)
P747: ((747 * dt), y(P746) + ((0.12 * (11 - y(P746))) * dt))
s747 = Segment(P746, P747)
P748: ((748 * dt), y(P747) + ((0.12 * (11 - y(P747))) * dt))
s748 = Segment(P747, P748)
P749: ((749 * dt), y(P748) + ((0.12 * (11 - y(P748))) * dt))
s749 = Segment(P748, P749)
P750: ((750 * dt), y(P749) + ((0.12 * (11 - y(P749))) * dt))
s750 = Segment(P749, P750)
P751: ((751 * dt), y(P750) + ((0.12 * (11 - y(P750))) * dt))
s751 = Segment(P750, P751)
P752: ((752 * dt), y(P751) + ((0.12 * (11 - y(P751))) * dt))
s752 = Segment(P751, P752)
P753: ((753 * dt), y(P752) + ((0.12 * (11 - y(P752))) * dt))
s753 = Segment(P752, P753)
P754: ((754 * dt), y(P753) + ((0.12 * (11 - y(P753))) * dt))
s754 = Segment(P753, P754)
P755: ((755 * dt), y(P754) + ((0.12 * (11 - y(P754))) * dt))
s755 = Segment(P754, P755)
P756: ((756 * dt), y(P755) + ((0.12 * (11 - y(P755))) * dt))
s756 = Segment(P755, P756)
P757: ((757 * dt), y(P756) + ((0.12 * (11 - y(P756))) * dt))
s757 = Segment(P756, P757)
P758: ((758 * dt), y(P757) + ((0.12 * (11 - y(P757))) * dt))
s758 = Segment(P757, P758)
P759: ((759 * dt), y(P758) + ((0.12 * (11 - y(P758))) * dt))
s759 = Segment(P758, P759)
P760: ((760 * dt), y(P759) + ((0.12 * (11 - y(P759))) * dt))
s760 = Segment(P759, P760)
P761: ((761 * dt), y(P760) + ((0.12 * (11 - y(P760))) * dt))
s761 = Segment(P760, P761)
P762: ((762 * dt), y(P761) + ((0.12 * (11 - y(P761))) * dt))
s762 = Segment(P761, P762)
P763: ((763 * dt), y(P762) + ((0.12 * (11 - y(P762))) * dt))
s763 = Segment(P762, P763)
P764: ((764 * dt), y(P763) + ((0.12 * (11 - y(P763))) * dt))
s764 = Segment(P763, P764)
P765: ((765 * dt), y(P764) + ((0.12 * (11 - y(P764))) * dt))
s765 = Segment(P764, P765)
P766: ((766 * dt), y(P765) + ((0.12 * (11 - y(P765))) * dt))
s766 = Segment(P765, P766)
P767: ((767 * dt), y(P766) + ((0.12 * (11 - y(P766))) * dt))
s767 = Segment(P766, P767)
P768: ((768 * dt), y(P767) + ((0.12 * (11 - y(P767))) * dt))
s768 = Segment(P767, P768)
P769: ((769 * dt), y(P768) + ((0.12 * (11 - y(P768))) * dt))
s769 = Segment(P768, P769)
P770: ((770 * dt), y(P769) + ((0.12 * (11 - y(P769))) * dt))
s770 = Segment(P769, P770)
P771: ((771 * dt), y(P770) + ((0.12 * (11 - y(P770))) * dt))
s771 = Segment(P770, P771)
P772: ((772 * dt), y(P771) + ((0.12 * (11 - y(P771))) * dt))
s772 = Segment(P771, P772)
P773: ((773 * dt), y(P772) + ((0.12 * (11 - y(P772))) * dt))
s773 = Segment(P772, P773)
P774: ((774 * dt), y(P773) + ((0.12 * (11 - y(P773))) * dt))
s774 = Segment(P773, P774)
P775: ((775 * dt), y(P774) + ((0.12 * (11 - y(P774))) * dt))
s775 = Segment(P774, P775)
P776: ((776 * dt), y(P775) + ((0.12 * (11 - y(P775))) * dt))
s776 = Segment(P775, P776)
P777: ((777 * dt), y(P776) + ((0.12 * (11 - y(P776))) * dt))
s777 = Segment(P776, P777)
P778: ((778 * dt), y(P777) + ((0.12 * (11 - y(P777))) * dt))
s778 = Segment(P777, P778)
P779: ((779 * dt), y(P778) + ((0.12 * (11 - y(P778))) * dt))
s779 = Segment(P778, P779)
P780: ((780 * dt), y(P779) + ((0.12 * (11 - y(P779))) * dt))
s780 = Segment(P779, P780)
P781: ((781 * dt), y(P780) + ((0.12 * (11 - y(P780))) * dt))
s781 = Segment(P780, P781)
P782: ((782 * dt), y(P781) + ((0.12 * (11 - y(P781))) * dt))
s782 = Segment(P781, P782)
P783: ((783 * dt), y(P782) + ((0.12 * (11 - y(P782))) * dt))
s783 = Segment(P782, P783)
P784: ((784 * dt), y(P783) + ((0.12 * (11 - y(P783))) * dt))
s784 = Segment(P783, P784)
P785: ((785 * dt), y(P784) + ((0.12 * (11 - y(P784))) * dt))
s785 = Segment(P784, P785)
P786: ((786 * dt), y(P785) + ((0.12 * (11 - y(P785))) * dt))
s786 = Segment(P785, P786)
P787: ((787 * dt), y(P786) + ((0.12 * (11 - y(P786))) * dt))
s787 = Segment(P786, P787)
P788: ((788 * dt), y(P787) + ((0.12 * (11 - y(P787))) * dt))
s788 = Segment(P787, P788)
P789: ((789 * dt), y(P788) + ((0.12 * (11 - y(P788))) * dt))
s789 = Segment(P788, P789)
P790: ((790 * dt), y(P789) + ((0.12 * (11 - y(P789))) * dt))
s790 = Segment(P789, P790)
P791: ((791 * dt), y(P790) + ((0.12 * (11 - y(P790))) * dt))
s791 = Segment(P790, P791)
P792: ((792 * dt), y(P791) + ((0.12 * (11 - y(P791))) * dt))
s792 = Segment(P791, P792)
P793: ((793 * dt), y(P792) + ((0.12 * (11 - y(P792))) * dt))
s793 = Segment(P792, P793)
P794: ((794 * dt), y(P793) + ((0.12 * (11 - y(P793))) * dt))
s794 = Segment(P793, P794)
P795: ((795 * dt), y(P794) + ((0.12 * (11 - y(P794))) * dt))
s795 = Segment(P794, P795)
P796: ((796 * dt), y(P795) + ((0.12 * (11 - y(P795))) * dt))
s796 = Segment(P795, P796)
P797: ((797 * dt), y(P796) + ((0.12 * (11 - y(P796))) * dt))
s797 = Segment(P796, P797)
P798: ((798 * dt), y(P797) + ((0.12 * (11 - y(P797))) * dt))
s798 = Segment(P797, P798)
P799: ((799 * dt), y(P798) + ((0.12 * (11 - y(P798))) * dt))
s799 = Segment(P798, P799)
P800: ((800 * dt), y(P799) + ((0.12 * (11 - y(P799))) * dt))
s800 = Segment(P799, P800)
P801: ((801 * dt), y(P800) + ((0.12 * (11 - y(P800))) * dt))
s801 = Segment(P800, P801)
P802: ((802 * dt), y(P801) + ((0.12 * (11 - y(P801))) * dt))
s802 = Segment(P801, P802)
P803: ((803 * dt), y(P802) + ((0.12 * (11 - y(P802))) * dt))
s803 = Segment(P802, P803)
P804: ((804 * dt), y(P803) + ((0.12 * (11 - y(P803))) * dt))
s804 = Segment(P803, P804)
P805: ((805 * dt), y(P804) + ((0.12 * (11 - y(P804))) * dt))
s805 = Segment(P804, P805)
P806: ((806 * dt), y(P805) + ((0.12 * (11 - y(P805))) * dt))
s806 = Segment(P805, P806)
P807: ((807 * dt), y(P806) + ((0.12 * (11 - y(P806))) * dt))
s807 = Segment(P806, P807)
P808: ((808 * dt), y(P807) + ((0.12 * (11 - y(P807))) * dt))
s808 = Segment(P807, P808)
P809: ((809 * dt), y(P808) + ((0.12 * (11 - y(P808))) * dt))
s809 = Segment(P808, P809)
P810: ((810 * dt), y(P809) + ((0.12 * (11 - y(P809))) * dt))
s810 = Segment(P809, P810)
P811: ((811 * dt), y(P810) + ((0.12 * (11 - y(P810))) * dt))
s811 = Segment(P810, P811)
P812: ((812 * dt), y(P811) + ((0.12 * (11 - y(P811))) * dt))
s812 = Segment(P811, P812)
P813: ((813 * dt), y(P812) + ((0.12 * (11 - y(P812))) * dt))
s813 = Segment(P812, P813)
P814: ((814 * dt), y(P813) + ((0.12 * (11 - y(P813))) * dt))
s814 = Segment(P813, P814)
P815: ((815 * dt), y(P814) + ((0.12 * (11 - y(P814))) * dt))
s815 = Segment(P814, P815)
P816: ((816 * dt), y(P815) + ((0.12 * (11 - y(P815))) * dt))
s816 = Segment(P815, P816)
P817: ((817 * dt), y(P816) + ((0.12 * (11 - y(P816))) * dt))
s817 = Segment(P816, P817)
P818: ((818 * dt), y(P817) + ((0.12 * (11 - y(P817))) * dt))
s818 = Segment(P817, P818)
P819: ((819 * dt), y(P818) + ((0.12 * (11 - y(P818))) * dt))
s819 = Segment(P818, P819)
P820: ((820 * dt), y(P819) + ((0.12 * (11 - y(P819))) * dt))
s820 = Segment(P819, P820)
P821: ((821 * dt), y(P820) + ((0.12 * (11 - y(P820))) * dt))
s821 = Segment(P820, P821)
P822: ((822 * dt), y(P821) + ((0.12 * (11 - y(P821))) * dt))
s822 = Segment(P821, P822)
P823: ((823 * dt), y(P822) + ((0.12 * (11 - y(P822))) * dt))
s823 = Segment(P822, P823)
P824: ((824 * dt), y(P823) + ((0.12 * (11 - y(P823))) * dt))
s824 = Segment(P823, P824)
P825: ((825 * dt), y(P824) + ((0.12 * (11 - y(P824))) * dt))
s825 = Segment(P824, P825)
P826: ((826 * dt), y(P825) + ((0.12 * (11 - y(P825))) * dt))
s826 = Segment(P825, P826)
P827: ((827 * dt), y(P826) + ((0.12 * (11 - y(P826))) * dt))
s827 = Segment(P826, P827)
P828: ((828 * dt), y(P827) + ((0.12 * (11 - y(P827))) * dt))
s828 = Segment(P827, P828)
P829: ((829 * dt), y(P828) + ((0.12 * (11 - y(P828))) * dt))
s829 = Segment(P828, P829)
P830: ((830 * dt), y(P829) + ((0.12 * (11 - y(P829))) * dt))
s830 = Segment(P829, P830)
P831: ((831 * dt), y(P830) + ((0.12 * (11 - y(P830))) * dt))
s831 = Segment(P830, P831)
P832: ((832 * dt), y(P831) + ((0.12 * (11 - y(P831))) * dt))
s832 = Segment(P831, P832)
P833: ((833 * dt), y(P832) + ((0.12 * (11 - y(P832))) * dt))
s833 = Segment(P832, P833)
P834: ((834 * dt), y(P833) + ((0.12 * (11 - y(P833))) * dt))
s834 = Segment(P833, P834)
P835: ((835 * dt), y(P834) + ((0.12 * (11 - y(P834))) * dt))
s835 = Segment(P834, P835)
P836: ((836 * dt), y(P835) + ((0.12 * (11 - y(P835))) * dt))
s836 = Segment(P835, P836)
P837: ((837 * dt), y(P836) + ((0.12 * (11 - y(P836))) * dt))
s837 = Segment(P836, P837)
P838: ((838 * dt), y(P837) + ((0.12 * (11 - y(P837))) * dt))
s838 = Segment(P837, P838)
P839: ((839 * dt), y(P838) + ((0.12 * (11 - y(P838))) * dt))
s839 = Segment(P838, P839)
P840: ((840 * dt), y(P839) + ((0.12 * (11 - y(P839))) * dt))
s840 = Segment(P839, P840)
P841: ((841 * dt), y(P840) + ((0.12 * (11 - y(P840))) * dt))
s841 = Segment(P840, P841)
P842: ((842 * dt), y(P841) + ((0.12 * (11 - y(P841))) * dt))
s842 = Segment(P841, P842)
P843: ((843 * dt), y(P842) + ((0.12 * (11 - y(P842))) * dt))
s843 = Segment(P842, P843)
P844: ((844 * dt), y(P843) + ((0.12 * (11 - y(P843))) * dt))
s844 = Segment(P843, P844)
P845: ((845 * dt), y(P844) + ((0.12 * (11 - y(P844))) * dt))
s845 = Segment(P844, P845)
P846: ((846 * dt), y(P845) + ((0.12 * (11 - y(P845))) * dt))
s846 = Segment(P845, P846)
P847: ((847 * dt), y(P846) + ((0.12 * (11 - y(P846))) * dt))
s847 = Segment(P846, P847)
P848: ((848 * dt), y(P847) + ((0.12 * (11 - y(P847))) * dt))
s848 = Segment(P847, P848)
P849: ((849 * dt), y(P848) + ((0.12 * (11 - y(P848))) * dt))
s849 = Segment(P848, P849)
P850: ((850 * dt), y(P849) + ((0.12 * (11 - y(P849))) * dt))
s850 = Segment(P849, P850)
P851: ((851 * dt), y(P850) + ((0.12 * (11 - y(P850))) * dt))
s851 = Segment(P850, P851)
P852: ((852 * dt), y(P851) + ((0.12 * (11 - y(P851))) * dt))
s852 = Segment(P851, P852)
P853: ((853 * dt), y(P852) + ((0.12 * (11 - y(P852))) * dt))
s853 = Segment(P852, P853)
P854: ((854 * dt), y(P853) + ((0.12 * (11 - y(P853))) * dt))
s854 = Segment(P853, P854)
P855: ((855 * dt), y(P854) + ((0.12 * (11 - y(P854))) * dt))
s855 = Segment(P854, P855)
P856: ((856 * dt), y(P855) + ((0.12 * (11 - y(P855))) * dt))
s856 = Segment(P855, P856)
P857: ((857 * dt), y(P856) + ((0.12 * (11 - y(P856))) * dt))
s857 = Segment(P856, P857)
P858: ((858 * dt), y(P857) + ((0.12 * (11 - y(P857))) * dt))
s858 = Segment(P857, P858)
P859: ((859 * dt), y(P858) + ((0.12 * (11 - y(P858))) * dt))
s859 = Segment(P858, P859)
P860: ((860 * dt), y(P859) + ((0.12 * (11 - y(P859))) * dt))
s860 = Segment(P859, P860)
P861: ((861 * dt), y(P860) + ((0.12 * (11 - y(P860))) * dt))
s861 = Segment(P860, P861)
P862: ((862 * dt), y(P861) + ((0.12 * (11 - y(P861))) * dt))
s862 = Segment(P861, P862)
P863: ((863 * dt), y(P862) + ((0.12 * (11 - y(P862))) * dt))
s863 = Segment(P862, P863)
P864: ((864 * dt), y(P863) + ((0.12 * (11 - y(P863))) * dt))
s864 = Segment(P863, P864)
P865: ((865 * dt), y(P864) + ((0.12 * (11 - y(P864))) * dt))
s865 = Segment(P864, P865)
P866: ((866 * dt), y(P865) + ((0.12 * (11 - y(P865))) * dt))
s866 = Segment(P865, P866)
P867: ((867 * dt), y(P866) + ((0.12 * (11 - y(P866))) * dt))
s867 = Segment(P866, P867)
P868: ((868 * dt), y(P867) + ((0.12 * (11 - y(P867))) * dt))
s868 = Segment(P867, P868)
P869: ((869 * dt), y(P868) + ((0.12 * (11 - y(P868))) * dt))
s869 = Segment(P868, P869)
P870: ((870 * dt), y(P869) + ((0.12 * (11 - y(P869))) * dt))
s870 = Segment(P869, P870)
P871: ((871 * dt), y(P870) + ((0.12 * (11 - y(P870))) * dt))
s871 = Segment(P870, P871)
P872: ((872 * dt), y(P871) + ((0.12 * (11 - y(P871))) * dt))
s872 = Segment(P871, P872)
P873: ((873 * dt), y(P872) + ((0.12 * (11 - y(P872))) * dt))
s873 = Segment(P872, P873)
P874: ((874 * dt), y(P873) + ((0.12 * (11 - y(P873))) * dt))
s874 = Segment(P873, P874)
P875: ((875 * dt), y(P874) + ((0.12 * (11 - y(P874))) * dt))
s875 = Segment(P874, P875)
P876: ((876 * dt), y(P875) + ((0.12 * (11 - y(P875))) * dt))
s876 = Segment(P875, P876)
P877: ((877 * dt), y(P876) + ((0.12 * (11 - y(P876))) * dt))
s877 = Segment(P876, P877)
P878: ((878 * dt), y(P877) + ((0.12 * (11 - y(P877))) * dt))
s878 = Segment(P877, P878)
P879: ((879 * dt), y(P878) + ((0.12 * (11 - y(P878))) * dt))
s879 = Segment(P878, P879)
P880: ((880 * dt), y(P879) + ((0.12 * (11 - y(P879))) * dt))
s880 = Segment(P879, P880)
P881: ((881 * dt), y(P880) + ((0.12 * (11 - y(P880))) * dt))
s881 = Segment(P880, P881)
P882: ((882 * dt), y(P881) + ((0.12 * (11 - y(P881))) * dt))
s882 = Segment(P881, P882)
P883: ((883 * dt), y(P882) + ((0.12 * (11 - y(P882))) * dt))
s883 = Segment(P882, P883)
P884: ((884 * dt), y(P883) + ((0.12 * (11 - y(P883))) * dt))
s884 = Segment(P883, P884)
P885: ((885 * dt), y(P884) + ((0.12 * (11 - y(P884))) * dt))
s885 = Segment(P884, P885)
P886: ((886 * dt), y(P885) + ((0.12 * (11 - y(P885))) * dt))
s886 = Segment(P885, P886)
P887: ((887 * dt), y(P886) + ((0.12 * (11 - y(P886))) * dt))
s887 = Segment(P886, P887)
P888: ((888 * dt), y(P887) + ((0.12 * (11 - y(P887))) * dt))
s888 = Segment(P887, P888)
P889: ((889 * dt), y(P888) + ((0.12 * (11 - y(P888))) * dt))
s889 = Segment(P888, P889)
P890: ((890 * dt), y(P889) + ((0.12 * (11 - y(P889))) * dt))
s890 = Segment(P889, P890)
P891: ((891 * dt), y(P890) + ((0.12 * (11 - y(P890))) * dt))
s891 = Segment(P890, P891)
P892: ((892 * dt), y(P891) + ((0.12 * (11 - y(P891))) * dt))
s892 = Segment(P891, P892)
P893: ((893 * dt), y(P892) + ((0.12 * (11 - y(P892))) * dt))
s893 = Segment(P892, P893)
P894: ((894 * dt), y(P893) + ((0.12 * (11 - y(P893))) * dt))
s894 = Segment(P893, P894)
P895: ((895 * dt), y(P894) + ((0.12 * (11 - y(P894))) * dt))
s895 = Segment(P894, P895)
P896: ((896 * dt), y(P895) + ((0.12 * (11 - y(P895))) * dt))
s896 = Segment(P895, P896)
P897: ((897 * dt), y(P896) + ((0.12 * (11 - y(P896))) * dt))
s897 = Segment(P896, P897)
P898: ((898 * dt), y(P897) + ((0.12 * (11 - y(P897))) * dt))
s898 = Segment(P897, P898)
P899: ((899 * dt), y(P898) + ((0.12 * (11 - y(P898))) * dt))
s899 = Segment(P898, P899)
P900: ((900 * dt), y(P899) + ((0.12 * (11 - y(P899))) * dt))
s900 = Segment(P899, P900)
P901: ((901 * dt), y(P900) + ((0.12 * (11 - y(P900))) * dt))
s901 = Segment(P900, P901)
P902: ((902 * dt), y(P901) + ((0.12 * (11 - y(P901))) * dt))
s902 = Segment(P901, P902)
P903: ((903 * dt), y(P902) + ((0.12 * (11 - y(P902))) * dt))
s903 = Segment(P902, P903)
P904: ((904 * dt), y(P903) + ((0.12 * (11 - y(P903))) * dt))
s904 = Segment(P903, P904)
P905: ((905 * dt), y(P904) + ((0.12 * (11 - y(P904))) * dt))
s905 = Segment(P904, P905)
P906: ((906 * dt), y(P905) + ((0.12 * (11 - y(P905))) * dt))
s906 = Segment(P905, P906)
P907: ((907 * dt), y(P906) + ((0.12 * (11 - y(P906))) * dt))
s907 = Segment(P906, P907)
P908: ((908 * dt), y(P907) + ((0.12 * (11 - y(P907))) * dt))
s908 = Segment(P907, P908)
P909: ((909 * dt), y(P908) + ((0.12 * (11 - y(P908))) * dt))
s909 = Segment(P908, P909)
P910: ((910 * dt), y(P909) + ((0.12 * (11 - y(P909))) * dt))
s910 = Segment(P909, P910)
P911: ((911 * dt), y(P910) + ((0.12 * (11 - y(P910))) * dt))
s911 = Segment(P910, P911)
P912: ((912 * dt), y(P911) + ((0.12 * (11 - y(P911))) * dt))
s912 = Segment(P911, P912)
P913: ((913 * dt), y(P912) + ((0.12 * (11 - y(P912))) * dt))
s913 = Segment(P912, P913)
P914: ((914 * dt), y(P913) + ((0.12 * (11 - y(P913))) * dt))
s914 = Segment(P913, P914)
P915: ((915 * dt), y(P914) + ((0.12 * (11 - y(P914))) * dt))
s915 = Segment(P914, P915)
P916: ((916 * dt), y(P915) + ((0.12 * (11 - y(P915))) * dt))
s916 = Segment(P915, P916)
P917: ((917 * dt), y(P916) + ((0.12 * (11 - y(P916))) * dt))
s917 = Segment(P916, P917)
P918: ((918 * dt), y(P917) + ((0.12 * (11 - y(P917))) * dt))
s918 = Segment(P917, P918)
P919: ((919 * dt), y(P918) + ((0.12 * (11 - y(P918))) * dt))
s919 = Segment(P918, P919)
P920: ((920 * dt), y(P919) + ((0.12 * (11 - y(P919))) * dt))
s920 = Segment(P919, P920)
P921: ((921 * dt), y(P920) + ((0.12 * (11 - y(P920))) * dt))
s921 = Segment(P920, P921)
P922: ((922 * dt), y(P921) + ((0.12 * (11 - y(P921))) * dt))
s922 = Segment(P921, P922)
P923: ((923 * dt), y(P922) + ((0.12 * (11 - y(P922))) * dt))
s923 = Segment(P922, P923)
P924: ((924 * dt), y(P923) + ((0.12 * (11 - y(P923))) * dt))
s924 = Segment(P923, P924)
P925: ((925 * dt), y(P924) + ((0.12 * (11 - y(P924))) * dt))
s925 = Segment(P924, P925)
P926: ((926 * dt), y(P925) + ((0.12 * (11 - y(P925))) * dt))
s926 = Segment(P925, P926)
P927: ((927 * dt), y(P926) + ((0.12 * (11 - y(P926))) * dt))
s927 = Segment(P926, P927)
P928: ((928 * dt), y(P927) + ((0.12 * (11 - y(P927))) * dt))
s928 = Segment(P927, P928)
P929: ((929 * dt), y(P928) + ((0.12 * (11 - y(P928))) * dt))
s929 = Segment(P928, P929)
P930: ((930 * dt), y(P929) + ((0.12 * (11 - y(P929))) * dt))
s930 = Segment(P929, P930)
P931: ((931 * dt), y(P930) + ((0.12 * (11 - y(P930))) * dt))
s931 = Segment(P930, P931)
P932: ((932 * dt), y(P931) + ((0.12 * (11 - y(P931))) * dt))
s932 = Segment(P931, P932)
P933: ((933 * dt), y(P932) + ((0.12 * (11 - y(P932))) * dt))
s933 = Segment(P932, P933)
P934: ((934 * dt), y(P933) + ((0.12 * (11 - y(P933))) * dt))
s934 = Segment(P933, P934)
P935: ((935 * dt), y(P934) + ((0.12 * (11 - y(P934))) * dt))
s935 = Segment(P934, P935)
P936: ((936 * dt), y(P935) + ((0.12 * (11 - y(P935))) * dt))
s936 = Segment(P935, P936)
P937: ((937 * dt), y(P936) + ((0.12 * (11 - y(P936))) * dt))
s937 = Segment(P936, P937)
P938: ((938 * dt), y(P937) + ((0.12 * (11 - y(P937))) * dt))
s938 = Segment(P937, P938)
P939: ((939 * dt), y(P938) + ((0.12 * (11 - y(P938))) * dt))
s939 = Segment(P938, P939)
P940: ((940 * dt), y(P939) + ((0.12 * (11 - y(P939))) * dt))
s940 = Segment(P939, P940)
P941: ((941 * dt), y(P940) + ((0.12 * (11 - y(P940))) * dt))
s941 = Segment(P940, P941)
P942: ((942 * dt), y(P941) + ((0.12 * (11 - y(P941))) * dt))
s942 = Segment(P941, P942)
P943: ((943 * dt), y(P942) + ((0.12 * (11 - y(P942))) * dt))
s943 = Segment(P942, P943)
P944: ((944 * dt), y(P943) + ((0.12 * (11 - y(P943))) * dt))
s944 = Segment(P943, P944)
P945: ((945 * dt), y(P944) + ((0.12 * (11 - y(P944))) * dt))
s945 = Segment(P944, P945)
P946: ((946 * dt), y(P945) + ((0.12 * (11 - y(P945))) * dt))
s946 = Segment(P945, P946)
P947: ((947 * dt), y(P946) + ((0.12 * (11 - y(P946))) * dt))
s947 = Segment(P946, P947)
P948: ((948 * dt), y(P947) + ((0.12 * (11 - y(P947))) * dt))
s948 = Segment(P947, P948)
P949: ((949 * dt), y(P948) + ((0.12 * (11 - y(P948))) * dt))
s949 = Segment(P948, P949)
P950: ((950 * dt), y(P949) + ((0.12 * (11 - y(P949))) * dt))
s950 = Segment(P949, P950)
P951: ((951 * dt), y(P950) + ((0.12 * (11 - y(P950))) * dt))
s951 = Segment(P950, P951)
P952: ((952 * dt), y(P951) + ((0.12 * (11 - y(P951))) * dt))
s952 = Segment(P951, P952)
P953: ((953 * dt), y(P952) + ((0.12 * (11 - y(P952))) * dt))
s953 = Segment(P952, P953)
P954: ((954 * dt), y(P953) + ((0.12 * (11 - y(P953))) * dt))
s954 = Segment(P953, P954)
P955: ((955 * dt), y(P954) + ((0.12 * (11 - y(P954))) * dt))
s955 = Segment(P954, P955)
P956: ((956 * dt), y(P955) + ((0.12 * (11 - y(P955))) * dt))
s956 = Segment(P955, P956)
P957: ((957 * dt), y(P956) + ((0.12 * (11 - y(P956))) * dt))
s957 = Segment(P956, P957)
P958: ((958 * dt), y(P957) + ((0.12 * (11 - y(P957))) * dt))
s958 = Segment(P957, P958)
P959: ((959 * dt), y(P958) + ((0.12 * (11 - y(P958))) * dt))
s959 = Segment(P958, P959)
P960: ((960 * dt), y(P959) + ((0.12 * (11 - y(P959))) * dt))
s960 = Segment(P959, P960)
P961: ((961 * dt), y(P960) + ((0.12 * (11 - y(P960))) * dt))
s961 = Segment(P960, P961)
P962: ((962 * dt), y(P961) + ((0.12 * (11 - y(P961))) * dt))
s962 = Segment(P961, P962)
P963: ((963 * dt), y(P962) + ((0.12 * (11 - y(P962))) * dt))
s963 = Segment(P962, P963)
P964: ((964 * dt), y(P963) + ((0.12 * (11 - y(P963))) * dt))
s964 = Segment(P963, P964)
P965: ((965 * dt), y(P964) + ((0.12 * (11 - y(P964))) * dt))
s965 = Segment(P964, P965)
P966: ((966 * dt), y(P965) + ((0.12 * (11 - y(P965))) * dt))
s966 = Segment(P965, P966)
P967: ((967 * dt), y(P966) + ((0.12 * (11 - y(P966))) * dt))
s967 = Segment(P966, P967)
P968: ((968 * dt), y(P967) + ((0.12 * (11 - y(P967))) * dt))
s968 = Segment(P967, P968)
P969: ((969 * dt), y(P968) + ((0.12 * (11 - y(P968))) * dt))
s969 = Segment(P968, P969)
P970: ((970 * dt), y(P969) + ((0.12 * (11 - y(P969))) * dt))
s970 = Segment(P969, P970)
P971: ((971 * dt), y(P970) + ((0.12 * (11 - y(P970))) * dt))
s971 = Segment(P970, P971)
P972: ((972 * dt), y(P971) + ((0.12 * (11 - y(P971))) * dt))
s972 = Segment(P971, P972)
P973: ((973 * dt), y(P972) + ((0.12 * (11 - y(P972))) * dt))
s973 = Segment(P972, P973)
P974: ((974 * dt), y(P973) + ((0.12 * (11 - y(P973))) * dt))
s974 = Segment(P973, P974)
P975: ((975 * dt), y(P974) + ((0.12 * (11 - y(P974))) * dt))
s975 = Segment(P974, P975)
P976: ((976 * dt), y(P975) + ((0.12 * (11 - y(P975))) * dt))
s976 = Segment(P975, P976)
P977: ((977 * dt), y(P976) + ((0.12 * (11 - y(P976))) * dt))
s977 = Segment(P976, P977)
P978: ((978 * dt), y(P977) + ((0.12 * (11 - y(P977))) * dt))
s978 = Segment(P977, P978)
P979: ((979 * dt), y(P978) + ((0.12 * (11 - y(P978))) * dt))
s979 = Segment(P978, P979)
P980: ((980 * dt), y(P979) + ((0.12 * (11 - y(P979))) * dt))
s980 = Segment(P979, P980)
P981: ((981 * dt), y(P980) + ((0.12 * (11 - y(P980))) * dt))
s981 = Segment(P980, P981)
P982: ((982 * dt), y(P981) + ((0.12 * (11 - y(P981))) * dt))
s982 = Segment(P981, P982)
P983: ((983 * dt), y(P982) + ((0.12 * (11 - y(P982))) * dt))
s983 = Segment(P982, P983)
P984: ((984 * dt), y(P983) + ((0.12 * (11 - y(P983))) * dt))
s984 = Segment(P983, P984)
P985: ((985 * dt), y(P984) + ((0.12 * (11 - y(P984))) * dt))
s985 = Segment(P984, P985)
P986: ((986 * dt), y(P985) + ((0.12 * (11 - y(P985))) * dt))
s986 = Segment(P985, P986)
P987: ((987 * dt), y(P986) + ((0.12 * (11 - y(P986))) * dt))
s987 = Segment(P986, P987)
P988: ((988 * dt), y(P987) + ((0.12 * (11 - y(P987))) * dt))
s988 = Segment(P987, P988)
P989: ((989 * dt), y(P988) + ((0.12 * (11 - y(P988))) * dt))
s989 = Segment(P988, P989)
P990: ((990 * dt), y(P989) + ((0.12 * (11 - y(P989))) * dt))
s990 = Segment(P989, P990)
P991: ((991 * dt), y(P990) + ((0.12 * (11 - y(P990))) * dt))
s991 = Segment(P990, P991)
P992: ((992 * dt), y(P991) + ((0.12 * (11 - y(P991))) * dt))
s992 = Segment(P991, P992)
P993: ((993 * dt), y(P992) + ((0.12 * (11 - y(P992))) * dt))
s993 = Segment(P992, P993)
P994: ((994 * dt), y(P993) + ((0.12 * (11 - y(P993))) * dt))
s994 = Segment(P993, P994)
P995: ((995 * dt), y(P994) + ((0.12 * (11 - y(P994))) * dt))
s995 = Segment(P994, P995)
P996: ((996 * dt), y(P995) + ((0.12 * (11 - y(P995))) * dt))
s996 = Segment(P995, P996)
P997: ((997 * dt), y(P996) + ((0.12 * (11 - y(P996))) * dt))
s997 = Segment(P996, P997)
P998: ((998 * dt), y(P997) + ((0.12 * (11 - y(P997))) * dt))
s998 = Segment(P997, P998)
P999: ((999 * dt), y(P998) + ((0.12 * (11 - y(P998))) * dt))
s999 = Segment(P998, P999)