GCC Code Coverage Report


Directory: .
File: main.cpp
Date: 0000-00-00 00:00:00
Exec Total Coverage
Lines: 2004 2005 99.9%
Functions: 2 2 100.0%
Branches: 1999 2000 99.9%
Conditions: 1999 2000 99.9%

Line Branch Condition Exec Source
1
2 void use_number_of_branches( int number );
3
4 1 int main() {
5
2/2
✓ Branch 0 (5→3) taken 999 times.
✓ Branch 1 (5→6) taken 1 times.
2/2
✓ Fully covered.
1000 for ( int x = 0; x < 999; ++x ) {
6 999 use_number_of_branches( x );
7 }
8 1 return 0;
9 }
10
11 999 void use_number_of_branches( int number ) {
12 999 int x = 0;
13
2/2
✓ Branch 0 (2→3) taken 1 times.
✓ Branch 1 (2→4) taken 998 times.
2/2
✓ Fully covered.
999 if ( ++x == number ) {
14 1 return;
15 }
16
2/2
✓ Branch 0 (4→5) taken 1 times.
✓ Branch 1 (4→6) taken 997 times.
2/2
✓ Fully covered.
998 else if ( ++x == number ) {
17 1 return;
18 }
19
2/2
✓ Branch 0 (6→7) taken 1 times.
✓ Branch 1 (6→8) taken 996 times.
2/2
✓ Fully covered.
997 else if ( ++x == number ) {
20 1 return;
21 }
22
2/2
✓ Branch 0 (8→9) taken 1 times.
✓ Branch 1 (8→10) taken 995 times.
2/2
✓ Fully covered.
996 else if ( ++x == number ) {
23 1 return;
24 }
25
2/2
✓ Branch 0 (10→11) taken 1 times.
✓ Branch 1 (10→12) taken 994 times.
2/2
✓ Fully covered.
995 else if ( ++x == number ) {
26 1 return;
27 }
28
2/2
✓ Branch 0 (12→13) taken 1 times.
✓ Branch 1 (12→14) taken 993 times.
2/2
✓ Fully covered.
994 else if ( ++x == number ) {
29 1 return;
30 }
31
2/2
✓ Branch 0 (14→15) taken 1 times.
✓ Branch 1 (14→16) taken 992 times.
2/2
✓ Fully covered.
993 else if ( ++x == number ) {
32 1 return;
33 }
34
2/2
✓ Branch 0 (16→17) taken 1 times.
✓ Branch 1 (16→18) taken 991 times.
2/2
✓ Fully covered.
992 else if ( ++x == number ) {
35 1 return;
36 }
37
2/2
✓ Branch 0 (18→19) taken 1 times.
✓ Branch 1 (18→20) taken 990 times.
2/2
✓ Fully covered.
991 else if ( ++x == number ) {
38 1 return;
39 }
40
2/2
✓ Branch 0 (20→21) taken 1 times.
✓ Branch 1 (20→22) taken 989 times.
2/2
✓ Fully covered.
990 else if ( ++x == number ) {
41 1 return;
42 }
43
2/2
✓ Branch 0 (22→23) taken 1 times.
✓ Branch 1 (22→24) taken 988 times.
2/2
✓ Fully covered.
989 else if ( ++x == number ) {
44 1 return;
45 }
46
2/2
✓ Branch 0 (24→25) taken 1 times.
✓ Branch 1 (24→26) taken 987 times.
2/2
✓ Fully covered.
988 else if ( ++x == number ) {
47 1 return;
48 }
49
2/2
✓ Branch 0 (26→27) taken 1 times.
✓ Branch 1 (26→28) taken 986 times.
2/2
✓ Fully covered.
987 else if ( ++x == number ) {
50 1 return;
51 }
52
2/2
✓ Branch 0 (28→29) taken 1 times.
✓ Branch 1 (28→30) taken 985 times.
2/2
✓ Fully covered.
986 else if ( ++x == number ) {
53 1 return;
54 }
55
2/2
✓ Branch 0 (30→31) taken 1 times.
✓ Branch 1 (30→32) taken 984 times.
2/2
✓ Fully covered.
985 else if ( ++x == number ) {
56 1 return;
57 }
58
2/2
✓ Branch 0 (32→33) taken 1 times.
✓ Branch 1 (32→34) taken 983 times.
2/2
✓ Fully covered.
984 else if ( ++x == number ) {
59 1 return;
60 }
61
2/2
✓ Branch 0 (34→35) taken 1 times.
✓ Branch 1 (34→36) taken 982 times.
2/2
✓ Fully covered.
983 else if ( ++x == number ) {
62 1 return;
63 }
64
2/2
✓ Branch 0 (36→37) taken 1 times.
✓ Branch 1 (36→38) taken 981 times.
2/2
✓ Fully covered.
982 else if ( ++x == number ) {
65 1 return;
66 }
67
2/2
✓ Branch 0 (38→39) taken 1 times.
✓ Branch 1 (38→40) taken 980 times.
2/2
✓ Fully covered.
981 else if ( ++x == number ) {
68 1 return;
69 }
70
2/2
✓ Branch 0 (40→41) taken 1 times.
✓ Branch 1 (40→42) taken 979 times.
2/2
✓ Fully covered.
980 else if ( ++x == number ) {
71 1 return;
72 }
73
2/2
✓ Branch 0 (42→43) taken 1 times.
✓ Branch 1 (42→44) taken 978 times.
2/2
✓ Fully covered.
979 else if ( ++x == number ) {
74 1 return;
75 }
76
2/2
✓ Branch 0 (44→45) taken 1 times.
✓ Branch 1 (44→46) taken 977 times.
2/2
✓ Fully covered.
978 else if ( ++x == number ) {
77 1 return;
78 }
79
2/2
✓ Branch 0 (46→47) taken 1 times.
✓ Branch 1 (46→48) taken 976 times.
2/2
✓ Fully covered.
977 else if ( ++x == number ) {
80 1 return;
81 }
82
2/2
✓ Branch 0 (48→49) taken 1 times.
✓ Branch 1 (48→50) taken 975 times.
2/2
✓ Fully covered.
976 else if ( ++x == number ) {
83 1 return;
84 }
85
2/2
✓ Branch 0 (50→51) taken 1 times.
✓ Branch 1 (50→52) taken 974 times.
2/2
✓ Fully covered.
975 else if ( ++x == number ) {
86 1 return;
87 }
88
2/2
✓ Branch 0 (52→53) taken 1 times.
✓ Branch 1 (52→54) taken 973 times.
2/2
✓ Fully covered.
974 else if ( ++x == number ) {
89 1 return;
90 }
91
2/2
✓ Branch 0 (54→55) taken 1 times.
✓ Branch 1 (54→56) taken 972 times.
2/2
✓ Fully covered.
973 else if ( ++x == number ) {
92 1 return;
93 }
94
2/2
✓ Branch 0 (56→57) taken 1 times.
✓ Branch 1 (56→58) taken 971 times.
2/2
✓ Fully covered.
972 else if ( ++x == number ) {
95 1 return;
96 }
97
2/2
✓ Branch 0 (58→59) taken 1 times.
✓ Branch 1 (58→60) taken 970 times.
2/2
✓ Fully covered.
971 else if ( ++x == number ) {
98 1 return;
99 }
100
2/2
✓ Branch 0 (60→61) taken 1 times.
✓ Branch 1 (60→62) taken 969 times.
2/2
✓ Fully covered.
970 else if ( ++x == number ) {
101 1 return;
102 }
103
2/2
✓ Branch 0 (62→63) taken 1 times.
✓ Branch 1 (62→64) taken 968 times.
2/2
✓ Fully covered.
969 else if ( ++x == number ) {
104 1 return;
105 }
106
2/2
✓ Branch 0 (64→65) taken 1 times.
✓ Branch 1 (64→66) taken 967 times.
2/2
✓ Fully covered.
968 else if ( ++x == number ) {
107 1 return;
108 }
109
2/2
✓ Branch 0 (66→67) taken 1 times.
✓ Branch 1 (66→68) taken 966 times.
2/2
✓ Fully covered.
967 else if ( ++x == number ) {
110 1 return;
111 }
112
2/2
✓ Branch 0 (68→69) taken 1 times.
✓ Branch 1 (68→70) taken 965 times.
2/2
✓ Fully covered.
966 else if ( ++x == number ) {
113 1 return;
114 }
115
2/2
✓ Branch 0 (70→71) taken 1 times.
✓ Branch 1 (70→72) taken 964 times.
2/2
✓ Fully covered.
965 else if ( ++x == number ) {
116 1 return;
117 }
118
2/2
✓ Branch 0 (72→73) taken 1 times.
✓ Branch 1 (72→74) taken 963 times.
2/2
✓ Fully covered.
964 else if ( ++x == number ) {
119 1 return;
120 }
121
2/2
✓ Branch 0 (74→75) taken 1 times.
✓ Branch 1 (74→76) taken 962 times.
2/2
✓ Fully covered.
963 else if ( ++x == number ) {
122 1 return;
123 }
124
2/2
✓ Branch 0 (76→77) taken 1 times.
✓ Branch 1 (76→78) taken 961 times.
2/2
✓ Fully covered.
962 else if ( ++x == number ) {
125 1 return;
126 }
127
2/2
✓ Branch 0 (78→79) taken 1 times.
✓ Branch 1 (78→80) taken 960 times.
2/2
✓ Fully covered.
961 else if ( ++x == number ) {
128 1 return;
129 }
130
2/2
✓ Branch 0 (80→81) taken 1 times.
✓ Branch 1 (80→82) taken 959 times.
2/2
✓ Fully covered.
960 else if ( ++x == number ) {
131 1 return;
132 }
133
2/2
✓ Branch 0 (82→83) taken 1 times.
✓ Branch 1 (82→84) taken 958 times.
2/2
✓ Fully covered.
959 else if ( ++x == number ) {
134 1 return;
135 }
136
2/2
✓ Branch 0 (84→85) taken 1 times.
✓ Branch 1 (84→86) taken 957 times.
2/2
✓ Fully covered.
958 else if ( ++x == number ) {
137 1 return;
138 }
139
2/2
✓ Branch 0 (86→87) taken 1 times.
✓ Branch 1 (86→88) taken 956 times.
2/2
✓ Fully covered.
957 else if ( ++x == number ) {
140 1 return;
141 }
142
2/2
✓ Branch 0 (88→89) taken 1 times.
✓ Branch 1 (88→90) taken 955 times.
2/2
✓ Fully covered.
956 else if ( ++x == number ) {
143 1 return;
144 }
145
2/2
✓ Branch 0 (90→91) taken 1 times.
✓ Branch 1 (90→92) taken 954 times.
2/2
✓ Fully covered.
955 else if ( ++x == number ) {
146 1 return;
147 }
148
2/2
✓ Branch 0 (92→93) taken 1 times.
✓ Branch 1 (92→94) taken 953 times.
2/2
✓ Fully covered.
954 else if ( ++x == number ) {
149 1 return;
150 }
151
2/2
✓ Branch 0 (94→95) taken 1 times.
✓ Branch 1 (94→96) taken 952 times.
2/2
✓ Fully covered.
953 else if ( ++x == number ) {
152 1 return;
153 }
154
2/2
✓ Branch 0 (96→97) taken 1 times.
✓ Branch 1 (96→98) taken 951 times.
2/2
✓ Fully covered.
952 else if ( ++x == number ) {
155 1 return;
156 }
157
2/2
✓ Branch 0 (98→99) taken 1 times.
✓ Branch 1 (98→100) taken 950 times.
2/2
✓ Fully covered.
951 else if ( ++x == number ) {
158 1 return;
159 }
160
2/2
✓ Branch 0 (100→101) taken 1 times.
✓ Branch 1 (100→102) taken 949 times.
2/2
✓ Fully covered.
950 else if ( ++x == number ) {
161 1 return;
162 }
163
2/2
✓ Branch 0 (102→103) taken 1 times.
✓ Branch 1 (102→104) taken 948 times.
2/2
✓ Fully covered.
949 else if ( ++x == number ) {
164 1 return;
165 }
166
2/2
✓ Branch 0 (104→105) taken 1 times.
✓ Branch 1 (104→106) taken 947 times.
2/2
✓ Fully covered.
948 else if ( ++x == number ) {
167 1 return;
168 }
169
2/2
✓ Branch 0 (106→107) taken 1 times.
✓ Branch 1 (106→108) taken 946 times.
2/2
✓ Fully covered.
947 else if ( ++x == number ) {
170 1 return;
171 }
172
2/2
✓ Branch 0 (108→109) taken 1 times.
✓ Branch 1 (108→110) taken 945 times.
2/2
✓ Fully covered.
946 else if ( ++x == number ) {
173 1 return;
174 }
175
2/2
✓ Branch 0 (110→111) taken 1 times.
✓ Branch 1 (110→112) taken 944 times.
2/2
✓ Fully covered.
945 else if ( ++x == number ) {
176 1 return;
177 }
178
2/2
✓ Branch 0 (112→113) taken 1 times.
✓ Branch 1 (112→114) taken 943 times.
2/2
✓ Fully covered.
944 else if ( ++x == number ) {
179 1 return;
180 }
181
2/2
✓ Branch 0 (114→115) taken 1 times.
✓ Branch 1 (114→116) taken 942 times.
2/2
✓ Fully covered.
943 else if ( ++x == number ) {
182 1 return;
183 }
184
2/2
✓ Branch 0 (116→117) taken 1 times.
✓ Branch 1 (116→118) taken 941 times.
2/2
✓ Fully covered.
942 else if ( ++x == number ) {
185 1 return;
186 }
187
2/2
✓ Branch 0 (118→119) taken 1 times.
✓ Branch 1 (118→120) taken 940 times.
2/2
✓ Fully covered.
941 else if ( ++x == number ) {
188 1 return;
189 }
190
2/2
✓ Branch 0 (120→121) taken 1 times.
✓ Branch 1 (120→122) taken 939 times.
2/2
✓ Fully covered.
940 else if ( ++x == number ) {
191 1 return;
192 }
193
2/2
✓ Branch 0 (122→123) taken 1 times.
✓ Branch 1 (122→124) taken 938 times.
2/2
✓ Fully covered.
939 else if ( ++x == number ) {
194 1 return;
195 }
196
2/2
✓ Branch 0 (124→125) taken 1 times.
✓ Branch 1 (124→126) taken 937 times.
2/2
✓ Fully covered.
938 else if ( ++x == number ) {
197 1 return;
198 }
199
2/2
✓ Branch 0 (126→127) taken 1 times.
✓ Branch 1 (126→128) taken 936 times.
2/2
✓ Fully covered.
937 else if ( ++x == number ) {
200 1 return;
201 }
202
2/2
✓ Branch 0 (128→129) taken 1 times.
✓ Branch 1 (128→130) taken 935 times.
2/2
✓ Fully covered.
936 else if ( ++x == number ) {
203 1 return;
204 }
205
2/2
✓ Branch 0 (130→131) taken 1 times.
✓ Branch 1 (130→132) taken 934 times.
2/2
✓ Fully covered.
935 else if ( ++x == number ) {
206 1 return;
207 }
208
2/2
✓ Branch 0 (132→133) taken 1 times.
✓ Branch 1 (132→134) taken 933 times.
2/2
✓ Fully covered.
934 else if ( ++x == number ) {
209 1 return;
210 }
211
2/2
✓ Branch 0 (134→135) taken 1 times.
✓ Branch 1 (134→136) taken 932 times.
2/2
✓ Fully covered.
933 else if ( ++x == number ) {
212 1 return;
213 }
214
2/2
✓ Branch 0 (136→137) taken 1 times.
✓ Branch 1 (136→138) taken 931 times.
2/2
✓ Fully covered.
932 else if ( ++x == number ) {
215 1 return;
216 }
217
2/2
✓ Branch 0 (138→139) taken 1 times.
✓ Branch 1 (138→140) taken 930 times.
2/2
✓ Fully covered.
931 else if ( ++x == number ) {
218 1 return;
219 }
220
2/2
✓ Branch 0 (140→141) taken 1 times.
✓ Branch 1 (140→142) taken 929 times.
2/2
✓ Fully covered.
930 else if ( ++x == number ) {
221 1 return;
222 }
223
2/2
✓ Branch 0 (142→143) taken 1 times.
✓ Branch 1 (142→144) taken 928 times.
2/2
✓ Fully covered.
929 else if ( ++x == number ) {
224 1 return;
225 }
226
2/2
✓ Branch 0 (144→145) taken 1 times.
✓ Branch 1 (144→146) taken 927 times.
2/2
✓ Fully covered.
928 else if ( ++x == number ) {
227 1 return;
228 }
229
2/2
✓ Branch 0 (146→147) taken 1 times.
✓ Branch 1 (146→148) taken 926 times.
2/2
✓ Fully covered.
927 else if ( ++x == number ) {
230 1 return;
231 }
232
2/2
✓ Branch 0 (148→149) taken 1 times.
✓ Branch 1 (148→150) taken 925 times.
2/2
✓ Fully covered.
926 else if ( ++x == number ) {
233 1 return;
234 }
235
2/2
✓ Branch 0 (150→151) taken 1 times.
✓ Branch 1 (150→152) taken 924 times.
2/2
✓ Fully covered.
925 else if ( ++x == number ) {
236 1 return;
237 }
238
2/2
✓ Branch 0 (152→153) taken 1 times.
✓ Branch 1 (152→154) taken 923 times.
2/2
✓ Fully covered.
924 else if ( ++x == number ) {
239 1 return;
240 }
241
2/2
✓ Branch 0 (154→155) taken 1 times.
✓ Branch 1 (154→156) taken 922 times.
2/2
✓ Fully covered.
923 else if ( ++x == number ) {
242 1 return;
243 }
244
2/2
✓ Branch 0 (156→157) taken 1 times.
✓ Branch 1 (156→158) taken 921 times.
2/2
✓ Fully covered.
922 else if ( ++x == number ) {
245 1 return;
246 }
247
2/2
✓ Branch 0 (158→159) taken 1 times.
✓ Branch 1 (158→160) taken 920 times.
2/2
✓ Fully covered.
921 else if ( ++x == number ) {
248 1 return;
249 }
250
2/2
✓ Branch 0 (160→161) taken 1 times.
✓ Branch 1 (160→162) taken 919 times.
2/2
✓ Fully covered.
920 else if ( ++x == number ) {
251 1 return;
252 }
253
2/2
✓ Branch 0 (162→163) taken 1 times.
✓ Branch 1 (162→164) taken 918 times.
2/2
✓ Fully covered.
919 else if ( ++x == number ) {
254 1 return;
255 }
256
2/2
✓ Branch 0 (164→165) taken 1 times.
✓ Branch 1 (164→166) taken 917 times.
2/2
✓ Fully covered.
918 else if ( ++x == number ) {
257 1 return;
258 }
259
2/2
✓ Branch 0 (166→167) taken 1 times.
✓ Branch 1 (166→168) taken 916 times.
2/2
✓ Fully covered.
917 else if ( ++x == number ) {
260 1 return;
261 }
262
2/2
✓ Branch 0 (168→169) taken 1 times.
✓ Branch 1 (168→170) taken 915 times.
2/2
✓ Fully covered.
916 else if ( ++x == number ) {
263 1 return;
264 }
265
2/2
✓ Branch 0 (170→171) taken 1 times.
✓ Branch 1 (170→172) taken 914 times.
2/2
✓ Fully covered.
915 else if ( ++x == number ) {
266 1 return;
267 }
268
2/2
✓ Branch 0 (172→173) taken 1 times.
✓ Branch 1 (172→174) taken 913 times.
2/2
✓ Fully covered.
914 else if ( ++x == number ) {
269 1 return;
270 }
271
2/2
✓ Branch 0 (174→175) taken 1 times.
✓ Branch 1 (174→176) taken 912 times.
2/2
✓ Fully covered.
913 else if ( ++x == number ) {
272 1 return;
273 }
274
2/2
✓ Branch 0 (176→177) taken 1 times.
✓ Branch 1 (176→178) taken 911 times.
2/2
✓ Fully covered.
912 else if ( ++x == number ) {
275 1 return;
276 }
277
2/2
✓ Branch 0 (178→179) taken 1 times.
✓ Branch 1 (178→180) taken 910 times.
2/2
✓ Fully covered.
911 else if ( ++x == number ) {
278 1 return;
279 }
280
2/2
✓ Branch 0 (180→181) taken 1 times.
✓ Branch 1 (180→182) taken 909 times.
2/2
✓ Fully covered.
910 else if ( ++x == number ) {
281 1 return;
282 }
283
2/2
✓ Branch 0 (182→183) taken 1 times.
✓ Branch 1 (182→184) taken 908 times.
2/2
✓ Fully covered.
909 else if ( ++x == number ) {
284 1 return;
285 }
286
2/2
✓ Branch 0 (184→185) taken 1 times.
✓ Branch 1 (184→186) taken 907 times.
2/2
✓ Fully covered.
908 else if ( ++x == number ) {
287 1 return;
288 }
289
2/2
✓ Branch 0 (186→187) taken 1 times.
✓ Branch 1 (186→188) taken 906 times.
2/2
✓ Fully covered.
907 else if ( ++x == number ) {
290 1 return;
291 }
292
2/2
✓ Branch 0 (188→189) taken 1 times.
✓ Branch 1 (188→190) taken 905 times.
2/2
✓ Fully covered.
906 else if ( ++x == number ) {
293 1 return;
294 }
295
2/2
✓ Branch 0 (190→191) taken 1 times.
✓ Branch 1 (190→192) taken 904 times.
2/2
✓ Fully covered.
905 else if ( ++x == number ) {
296 1 return;
297 }
298
2/2
✓ Branch 0 (192→193) taken 1 times.
✓ Branch 1 (192→194) taken 903 times.
2/2
✓ Fully covered.
904 else if ( ++x == number ) {
299 1 return;
300 }
301
2/2
✓ Branch 0 (194→195) taken 1 times.
✓ Branch 1 (194→196) taken 902 times.
2/2
✓ Fully covered.
903 else if ( ++x == number ) {
302 1 return;
303 }
304
2/2
✓ Branch 0 (196→197) taken 1 times.
✓ Branch 1 (196→198) taken 901 times.
2/2
✓ Fully covered.
902 else if ( ++x == number ) {
305 1 return;
306 }
307
2/2
✓ Branch 0 (198→199) taken 1 times.
✓ Branch 1 (198→200) taken 900 times.
2/2
✓ Fully covered.
901 else if ( ++x == number ) {
308 1 return;
309 }
310
2/2
✓ Branch 0 (200→201) taken 1 times.
✓ Branch 1 (200→202) taken 899 times.
2/2
✓ Fully covered.
900 else if ( ++x == number ) {
311 1 return;
312 }
313
2/2
✓ Branch 0 (202→203) taken 1 times.
✓ Branch 1 (202→204) taken 898 times.
2/2
✓ Fully covered.
899 else if ( ++x == number ) {
314 1 return;
315 }
316
2/2
✓ Branch 0 (204→205) taken 1 times.
✓ Branch 1 (204→206) taken 897 times.
2/2
✓ Fully covered.
898 else if ( ++x == number ) {
317 1 return;
318 }
319
2/2
✓ Branch 0 (206→207) taken 1 times.
✓ Branch 1 (206→208) taken 896 times.
2/2
✓ Fully covered.
897 else if ( ++x == number ) {
320 1 return;
321 }
322
2/2
✓ Branch 0 (208→209) taken 1 times.
✓ Branch 1 (208→210) taken 895 times.
2/2
✓ Fully covered.
896 else if ( ++x == number ) {
323 1 return;
324 }
325
2/2
✓ Branch 0 (210→211) taken 1 times.
✓ Branch 1 (210→212) taken 894 times.
2/2
✓ Fully covered.
895 else if ( ++x == number ) {
326 1 return;
327 }
328
2/2
✓ Branch 0 (212→213) taken 1 times.
✓ Branch 1 (212→214) taken 893 times.
2/2
✓ Fully covered.
894 else if ( ++x == number ) {
329 1 return;
330 }
331
2/2
✓ Branch 0 (214→215) taken 1 times.
✓ Branch 1 (214→216) taken 892 times.
2/2
✓ Fully covered.
893 else if ( ++x == number ) {
332 1 return;
333 }
334
2/2
✓ Branch 0 (216→217) taken 1 times.
✓ Branch 1 (216→218) taken 891 times.
2/2
✓ Fully covered.
892 else if ( ++x == number ) {
335 1 return;
336 }
337
2/2
✓ Branch 0 (218→219) taken 1 times.
✓ Branch 1 (218→220) taken 890 times.
2/2
✓ Fully covered.
891 else if ( ++x == number ) {
338 1 return;
339 }
340
2/2
✓ Branch 0 (220→221) taken 1 times.
✓ Branch 1 (220→222) taken 889 times.
2/2
✓ Fully covered.
890 else if ( ++x == number ) {
341 1 return;
342 }
343
2/2
✓ Branch 0 (222→223) taken 1 times.
✓ Branch 1 (222→224) taken 888 times.
2/2
✓ Fully covered.
889 else if ( ++x == number ) {
344 1 return;
345 }
346
2/2
✓ Branch 0 (224→225) taken 1 times.
✓ Branch 1 (224→226) taken 887 times.
2/2
✓ Fully covered.
888 else if ( ++x == number ) {
347 1 return;
348 }
349
2/2
✓ Branch 0 (226→227) taken 1 times.
✓ Branch 1 (226→228) taken 886 times.
2/2
✓ Fully covered.
887 else if ( ++x == number ) {
350 1 return;
351 }
352
2/2
✓ Branch 0 (228→229) taken 1 times.
✓ Branch 1 (228→230) taken 885 times.
2/2
✓ Fully covered.
886 else if ( ++x == number ) {
353 1 return;
354 }
355
2/2
✓ Branch 0 (230→231) taken 1 times.
✓ Branch 1 (230→232) taken 884 times.
2/2
✓ Fully covered.
885 else if ( ++x == number ) {
356 1 return;
357 }
358
2/2
✓ Branch 0 (232→233) taken 1 times.
✓ Branch 1 (232→234) taken 883 times.
2/2
✓ Fully covered.
884 else if ( ++x == number ) {
359 1 return;
360 }
361
2/2
✓ Branch 0 (234→235) taken 1 times.
✓ Branch 1 (234→236) taken 882 times.
2/2
✓ Fully covered.
883 else if ( ++x == number ) {
362 1 return;
363 }
364
2/2
✓ Branch 0 (236→237) taken 1 times.
✓ Branch 1 (236→238) taken 881 times.
2/2
✓ Fully covered.
882 else if ( ++x == number ) {
365 1 return;
366 }
367
2/2
✓ Branch 0 (238→239) taken 1 times.
✓ Branch 1 (238→240) taken 880 times.
2/2
✓ Fully covered.
881 else if ( ++x == number ) {
368 1 return;
369 }
370
2/2
✓ Branch 0 (240→241) taken 1 times.
✓ Branch 1 (240→242) taken 879 times.
2/2
✓ Fully covered.
880 else if ( ++x == number ) {
371 1 return;
372 }
373
2/2
✓ Branch 0 (242→243) taken 1 times.
✓ Branch 1 (242→244) taken 878 times.
2/2
✓ Fully covered.
879 else if ( ++x == number ) {
374 1 return;
375 }
376
2/2
✓ Branch 0 (244→245) taken 1 times.
✓ Branch 1 (244→246) taken 877 times.
2/2
✓ Fully covered.
878 else if ( ++x == number ) {
377 1 return;
378 }
379
2/2
✓ Branch 0 (246→247) taken 1 times.
✓ Branch 1 (246→248) taken 876 times.
2/2
✓ Fully covered.
877 else if ( ++x == number ) {
380 1 return;
381 }
382
2/2
✓ Branch 0 (248→249) taken 1 times.
✓ Branch 1 (248→250) taken 875 times.
2/2
✓ Fully covered.
876 else if ( ++x == number ) {
383 1 return;
384 }
385
2/2
✓ Branch 0 (250→251) taken 1 times.
✓ Branch 1 (250→252) taken 874 times.
2/2
✓ Fully covered.
875 else if ( ++x == number ) {
386 1 return;
387 }
388
2/2
✓ Branch 0 (252→253) taken 1 times.
✓ Branch 1 (252→254) taken 873 times.
2/2
✓ Fully covered.
874 else if ( ++x == number ) {
389 1 return;
390 }
391
2/2
✓ Branch 0 (254→255) taken 1 times.
✓ Branch 1 (254→256) taken 872 times.
2/2
✓ Fully covered.
873 else if ( ++x == number ) {
392 1 return;
393 }
394
2/2
✓ Branch 0 (256→257) taken 1 times.
✓ Branch 1 (256→258) taken 871 times.
2/2
✓ Fully covered.
872 else if ( ++x == number ) {
395 1 return;
396 }
397
2/2
✓ Branch 0 (258→259) taken 1 times.
✓ Branch 1 (258→260) taken 870 times.
2/2
✓ Fully covered.
871 else if ( ++x == number ) {
398 1 return;
399 }
400
2/2
✓ Branch 0 (260→261) taken 1 times.
✓ Branch 1 (260→262) taken 869 times.
2/2
✓ Fully covered.
870 else if ( ++x == number ) {
401 1 return;
402 }
403
2/2
✓ Branch 0 (262→263) taken 1 times.
✓ Branch 1 (262→264) taken 868 times.
2/2
✓ Fully covered.
869 else if ( ++x == number ) {
404 1 return;
405 }
406
2/2
✓ Branch 0 (264→265) taken 1 times.
✓ Branch 1 (264→266) taken 867 times.
2/2
✓ Fully covered.
868 else if ( ++x == number ) {
407 1 return;
408 }
409
2/2
✓ Branch 0 (266→267) taken 1 times.
✓ Branch 1 (266→268) taken 866 times.
2/2
✓ Fully covered.
867 else if ( ++x == number ) {
410 1 return;
411 }
412
2/2
✓ Branch 0 (268→269) taken 1 times.
✓ Branch 1 (268→270) taken 865 times.
2/2
✓ Fully covered.
866 else if ( ++x == number ) {
413 1 return;
414 }
415
2/2
✓ Branch 0 (270→271) taken 1 times.
✓ Branch 1 (270→272) taken 864 times.
2/2
✓ Fully covered.
865 else if ( ++x == number ) {
416 1 return;
417 }
418
2/2
✓ Branch 0 (272→273) taken 1 times.
✓ Branch 1 (272→274) taken 863 times.
2/2
✓ Fully covered.
864 else if ( ++x == number ) {
419 1 return;
420 }
421
2/2
✓ Branch 0 (274→275) taken 1 times.
✓ Branch 1 (274→276) taken 862 times.
2/2
✓ Fully covered.
863 else if ( ++x == number ) {
422 1 return;
423 }
424
2/2
✓ Branch 0 (276→277) taken 1 times.
✓ Branch 1 (276→278) taken 861 times.
2/2
✓ Fully covered.
862 else if ( ++x == number ) {
425 1 return;
426 }
427
2/2
✓ Branch 0 (278→279) taken 1 times.
✓ Branch 1 (278→280) taken 860 times.
2/2
✓ Fully covered.
861 else if ( ++x == number ) {
428 1 return;
429 }
430
2/2
✓ Branch 0 (280→281) taken 1 times.
✓ Branch 1 (280→282) taken 859 times.
2/2
✓ Fully covered.
860 else if ( ++x == number ) {
431 1 return;
432 }
433
2/2
✓ Branch 0 (282→283) taken 1 times.
✓ Branch 1 (282→284) taken 858 times.
2/2
✓ Fully covered.
859 else if ( ++x == number ) {
434 1 return;
435 }
436
2/2
✓ Branch 0 (284→285) taken 1 times.
✓ Branch 1 (284→286) taken 857 times.
2/2
✓ Fully covered.
858 else if ( ++x == number ) {
437 1 return;
438 }
439
2/2
✓ Branch 0 (286→287) taken 1 times.
✓ Branch 1 (286→288) taken 856 times.
2/2
✓ Fully covered.
857 else if ( ++x == number ) {
440 1 return;
441 }
442
2/2
✓ Branch 0 (288→289) taken 1 times.
✓ Branch 1 (288→290) taken 855 times.
2/2
✓ Fully covered.
856 else if ( ++x == number ) {
443 1 return;
444 }
445
2/2
✓ Branch 0 (290→291) taken 1 times.
✓ Branch 1 (290→292) taken 854 times.
2/2
✓ Fully covered.
855 else if ( ++x == number ) {
446 1 return;
447 }
448
2/2
✓ Branch 0 (292→293) taken 1 times.
✓ Branch 1 (292→294) taken 853 times.
2/2
✓ Fully covered.
854 else if ( ++x == number ) {
449 1 return;
450 }
451
2/2
✓ Branch 0 (294→295) taken 1 times.
✓ Branch 1 (294→296) taken 852 times.
2/2
✓ Fully covered.
853 else if ( ++x == number ) {
452 1 return;
453 }
454
2/2
✓ Branch 0 (296→297) taken 1 times.
✓ Branch 1 (296→298) taken 851 times.
2/2
✓ Fully covered.
852 else if ( ++x == number ) {
455 1 return;
456 }
457
2/2
✓ Branch 0 (298→299) taken 1 times.
✓ Branch 1 (298→300) taken 850 times.
2/2
✓ Fully covered.
851 else if ( ++x == number ) {
458 1 return;
459 }
460
2/2
✓ Branch 0 (300→301) taken 1 times.
✓ Branch 1 (300→302) taken 849 times.
2/2
✓ Fully covered.
850 else if ( ++x == number ) {
461 1 return;
462 }
463
2/2
✓ Branch 0 (302→303) taken 1 times.
✓ Branch 1 (302→304) taken 848 times.
2/2
✓ Fully covered.
849 else if ( ++x == number ) {
464 1 return;
465 }
466
2/2
✓ Branch 0 (304→305) taken 1 times.
✓ Branch 1 (304→306) taken 847 times.
2/2
✓ Fully covered.
848 else if ( ++x == number ) {
467 1 return;
468 }
469
2/2
✓ Branch 0 (306→307) taken 1 times.
✓ Branch 1 (306→308) taken 846 times.
2/2
✓ Fully covered.
847 else if ( ++x == number ) {
470 1 return;
471 }
472
2/2
✓ Branch 0 (308→309) taken 1 times.
✓ Branch 1 (308→310) taken 845 times.
2/2
✓ Fully covered.
846 else if ( ++x == number ) {
473 1 return;
474 }
475
2/2
✓ Branch 0 (310→311) taken 1 times.
✓ Branch 1 (310→312) taken 844 times.
2/2
✓ Fully covered.
845 else if ( ++x == number ) {
476 1 return;
477 }
478
2/2
✓ Branch 0 (312→313) taken 1 times.
✓ Branch 1 (312→314) taken 843 times.
2/2
✓ Fully covered.
844 else if ( ++x == number ) {
479 1 return;
480 }
481
2/2
✓ Branch 0 (314→315) taken 1 times.
✓ Branch 1 (314→316) taken 842 times.
2/2
✓ Fully covered.
843 else if ( ++x == number ) {
482 1 return;
483 }
484
2/2
✓ Branch 0 (316→317) taken 1 times.
✓ Branch 1 (316→318) taken 841 times.
2/2
✓ Fully covered.
842 else if ( ++x == number ) {
485 1 return;
486 }
487
2/2
✓ Branch 0 (318→319) taken 1 times.
✓ Branch 1 (318→320) taken 840 times.
2/2
✓ Fully covered.
841 else if ( ++x == number ) {
488 1 return;
489 }
490
2/2
✓ Branch 0 (320→321) taken 1 times.
✓ Branch 1 (320→322) taken 839 times.
2/2
✓ Fully covered.
840 else if ( ++x == number ) {
491 1 return;
492 }
493
2/2
✓ Branch 0 (322→323) taken 1 times.
✓ Branch 1 (322→324) taken 838 times.
2/2
✓ Fully covered.
839 else if ( ++x == number ) {
494 1 return;
495 }
496
2/2
✓ Branch 0 (324→325) taken 1 times.
✓ Branch 1 (324→326) taken 837 times.
2/2
✓ Fully covered.
838 else if ( ++x == number ) {
497 1 return;
498 }
499
2/2
✓ Branch 0 (326→327) taken 1 times.
✓ Branch 1 (326→328) taken 836 times.
2/2
✓ Fully covered.
837 else if ( ++x == number ) {
500 1 return;
501 }
502
2/2
✓ Branch 0 (328→329) taken 1 times.
✓ Branch 1 (328→330) taken 835 times.
2/2
✓ Fully covered.
836 else if ( ++x == number ) {
503 1 return;
504 }
505
2/2
✓ Branch 0 (330→331) taken 1 times.
✓ Branch 1 (330→332) taken 834 times.
2/2
✓ Fully covered.
835 else if ( ++x == number ) {
506 1 return;
507 }
508
2/2
✓ Branch 0 (332→333) taken 1 times.
✓ Branch 1 (332→334) taken 833 times.
2/2
✓ Fully covered.
834 else if ( ++x == number ) {
509 1 return;
510 }
511
2/2
✓ Branch 0 (334→335) taken 1 times.
✓ Branch 1 (334→336) taken 832 times.
2/2
✓ Fully covered.
833 else if ( ++x == number ) {
512 1 return;
513 }
514
2/2
✓ Branch 0 (336→337) taken 1 times.
✓ Branch 1 (336→338) taken 831 times.
2/2
✓ Fully covered.
832 else if ( ++x == number ) {
515 1 return;
516 }
517
2/2
✓ Branch 0 (338→339) taken 1 times.
✓ Branch 1 (338→340) taken 830 times.
2/2
✓ Fully covered.
831 else if ( ++x == number ) {
518 1 return;
519 }
520
2/2
✓ Branch 0 (340→341) taken 1 times.
✓ Branch 1 (340→342) taken 829 times.
2/2
✓ Fully covered.
830 else if ( ++x == number ) {
521 1 return;
522 }
523
2/2
✓ Branch 0 (342→343) taken 1 times.
✓ Branch 1 (342→344) taken 828 times.
2/2
✓ Fully covered.
829 else if ( ++x == number ) {
524 1 return;
525 }
526
2/2
✓ Branch 0 (344→345) taken 1 times.
✓ Branch 1 (344→346) taken 827 times.
2/2
✓ Fully covered.
828 else if ( ++x == number ) {
527 1 return;
528 }
529
2/2
✓ Branch 0 (346→347) taken 1 times.
✓ Branch 1 (346→348) taken 826 times.
2/2
✓ Fully covered.
827 else if ( ++x == number ) {
530 1 return;
531 }
532
2/2
✓ Branch 0 (348→349) taken 1 times.
✓ Branch 1 (348→350) taken 825 times.
2/2
✓ Fully covered.
826 else if ( ++x == number ) {
533 1 return;
534 }
535
2/2
✓ Branch 0 (350→351) taken 1 times.
✓ Branch 1 (350→352) taken 824 times.
2/2
✓ Fully covered.
825 else if ( ++x == number ) {
536 1 return;
537 }
538
2/2
✓ Branch 0 (352→353) taken 1 times.
✓ Branch 1 (352→354) taken 823 times.
2/2
✓ Fully covered.
824 else if ( ++x == number ) {
539 1 return;
540 }
541
2/2
✓ Branch 0 (354→355) taken 1 times.
✓ Branch 1 (354→356) taken 822 times.
2/2
✓ Fully covered.
823 else if ( ++x == number ) {
542 1 return;
543 }
544
2/2
✓ Branch 0 (356→357) taken 1 times.
✓ Branch 1 (356→358) taken 821 times.
2/2
✓ Fully covered.
822 else if ( ++x == number ) {
545 1 return;
546 }
547
2/2
✓ Branch 0 (358→359) taken 1 times.
✓ Branch 1 (358→360) taken 820 times.
2/2
✓ Fully covered.
821 else if ( ++x == number ) {
548 1 return;
549 }
550
2/2
✓ Branch 0 (360→361) taken 1 times.
✓ Branch 1 (360→362) taken 819 times.
2/2
✓ Fully covered.
820 else if ( ++x == number ) {
551 1 return;
552 }
553
2/2
✓ Branch 0 (362→363) taken 1 times.
✓ Branch 1 (362→364) taken 818 times.
2/2
✓ Fully covered.
819 else if ( ++x == number ) {
554 1 return;
555 }
556
2/2
✓ Branch 0 (364→365) taken 1 times.
✓ Branch 1 (364→366) taken 817 times.
2/2
✓ Fully covered.
818 else if ( ++x == number ) {
557 1 return;
558 }
559
2/2
✓ Branch 0 (366→367) taken 1 times.
✓ Branch 1 (366→368) taken 816 times.
2/2
✓ Fully covered.
817 else if ( ++x == number ) {
560 1 return;
561 }
562
2/2
✓ Branch 0 (368→369) taken 1 times.
✓ Branch 1 (368→370) taken 815 times.
2/2
✓ Fully covered.
816 else if ( ++x == number ) {
563 1 return;
564 }
565
2/2
✓ Branch 0 (370→371) taken 1 times.
✓ Branch 1 (370→372) taken 814 times.
2/2
✓ Fully covered.
815 else if ( ++x == number ) {
566 1 return;
567 }
568
2/2
✓ Branch 0 (372→373) taken 1 times.
✓ Branch 1 (372→374) taken 813 times.
2/2
✓ Fully covered.
814 else if ( ++x == number ) {
569 1 return;
570 }
571
2/2
✓ Branch 0 (374→375) taken 1 times.
✓ Branch 1 (374→376) taken 812 times.
2/2
✓ Fully covered.
813 else if ( ++x == number ) {
572 1 return;
573 }
574
2/2
✓ Branch 0 (376→377) taken 1 times.
✓ Branch 1 (376→378) taken 811 times.
2/2
✓ Fully covered.
812 else if ( ++x == number ) {
575 1 return;
576 }
577
2/2
✓ Branch 0 (378→379) taken 1 times.
✓ Branch 1 (378→380) taken 810 times.
2/2
✓ Fully covered.
811 else if ( ++x == number ) {
578 1 return;
579 }
580
2/2
✓ Branch 0 (380→381) taken 1 times.
✓ Branch 1 (380→382) taken 809 times.
2/2
✓ Fully covered.
810 else if ( ++x == number ) {
581 1 return;
582 }
583
2/2
✓ Branch 0 (382→383) taken 1 times.
✓ Branch 1 (382→384) taken 808 times.
2/2
✓ Fully covered.
809 else if ( ++x == number ) {
584 1 return;
585 }
586
2/2
✓ Branch 0 (384→385) taken 1 times.
✓ Branch 1 (384→386) taken 807 times.
2/2
✓ Fully covered.
808 else if ( ++x == number ) {
587 1 return;
588 }
589
2/2
✓ Branch 0 (386→387) taken 1 times.
✓ Branch 1 (386→388) taken 806 times.
2/2
✓ Fully covered.
807 else if ( ++x == number ) {
590 1 return;
591 }
592
2/2
✓ Branch 0 (388→389) taken 1 times.
✓ Branch 1 (388→390) taken 805 times.
2/2
✓ Fully covered.
806 else if ( ++x == number ) {
593 1 return;
594 }
595
2/2
✓ Branch 0 (390→391) taken 1 times.
✓ Branch 1 (390→392) taken 804 times.
2/2
✓ Fully covered.
805 else if ( ++x == number ) {
596 1 return;
597 }
598
2/2
✓ Branch 0 (392→393) taken 1 times.
✓ Branch 1 (392→394) taken 803 times.
2/2
✓ Fully covered.
804 else if ( ++x == number ) {
599 1 return;
600 }
601
2/2
✓ Branch 0 (394→395) taken 1 times.
✓ Branch 1 (394→396) taken 802 times.
2/2
✓ Fully covered.
803 else if ( ++x == number ) {
602 1 return;
603 }
604
2/2
✓ Branch 0 (396→397) taken 1 times.
✓ Branch 1 (396→398) taken 801 times.
2/2
✓ Fully covered.
802 else if ( ++x == number ) {
605 1 return;
606 }
607
2/2
✓ Branch 0 (398→399) taken 1 times.
✓ Branch 1 (398→400) taken 800 times.
2/2
✓ Fully covered.
801 else if ( ++x == number ) {
608 1 return;
609 }
610
2/2
✓ Branch 0 (400→401) taken 1 times.
✓ Branch 1 (400→402) taken 799 times.
2/2
✓ Fully covered.
800 else if ( ++x == number ) {
611 1 return;
612 }
613
2/2
✓ Branch 0 (402→403) taken 1 times.
✓ Branch 1 (402→404) taken 798 times.
2/2
✓ Fully covered.
799 else if ( ++x == number ) {
614 1 return;
615 }
616
2/2
✓ Branch 0 (404→405) taken 1 times.
✓ Branch 1 (404→406) taken 797 times.
2/2
✓ Fully covered.
798 else if ( ++x == number ) {
617 1 return;
618 }
619
2/2
✓ Branch 0 (406→407) taken 1 times.
✓ Branch 1 (406→408) taken 796 times.
2/2
✓ Fully covered.
797 else if ( ++x == number ) {
620 1 return;
621 }
622
2/2
✓ Branch 0 (408→409) taken 1 times.
✓ Branch 1 (408→410) taken 795 times.
2/2
✓ Fully covered.
796 else if ( ++x == number ) {
623 1 return;
624 }
625
2/2
✓ Branch 0 (410→411) taken 1 times.
✓ Branch 1 (410→412) taken 794 times.
2/2
✓ Fully covered.
795 else if ( ++x == number ) {
626 1 return;
627 }
628
2/2
✓ Branch 0 (412→413) taken 1 times.
✓ Branch 1 (412→414) taken 793 times.
2/2
✓ Fully covered.
794 else if ( ++x == number ) {
629 1 return;
630 }
631
2/2
✓ Branch 0 (414→415) taken 1 times.
✓ Branch 1 (414→416) taken 792 times.
2/2
✓ Fully covered.
793 else if ( ++x == number ) {
632 1 return;
633 }
634
2/2
✓ Branch 0 (416→417) taken 1 times.
✓ Branch 1 (416→418) taken 791 times.
2/2
✓ Fully covered.
792 else if ( ++x == number ) {
635 1 return;
636 }
637
2/2
✓ Branch 0 (418→419) taken 1 times.
✓ Branch 1 (418→420) taken 790 times.
2/2
✓ Fully covered.
791 else if ( ++x == number ) {
638 1 return;
639 }
640
2/2
✓ Branch 0 (420→421) taken 1 times.
✓ Branch 1 (420→422) taken 789 times.
2/2
✓ Fully covered.
790 else if ( ++x == number ) {
641 1 return;
642 }
643
2/2
✓ Branch 0 (422→423) taken 1 times.
✓ Branch 1 (422→424) taken 788 times.
2/2
✓ Fully covered.
789 else if ( ++x == number ) {
644 1 return;
645 }
646
2/2
✓ Branch 0 (424→425) taken 1 times.
✓ Branch 1 (424→426) taken 787 times.
2/2
✓ Fully covered.
788 else if ( ++x == number ) {
647 1 return;
648 }
649
2/2
✓ Branch 0 (426→427) taken 1 times.
✓ Branch 1 (426→428) taken 786 times.
2/2
✓ Fully covered.
787 else if ( ++x == number ) {
650 1 return;
651 }
652
2/2
✓ Branch 0 (428→429) taken 1 times.
✓ Branch 1 (428→430) taken 785 times.
2/2
✓ Fully covered.
786 else if ( ++x == number ) {
653 1 return;
654 }
655
2/2
✓ Branch 0 (430→431) taken 1 times.
✓ Branch 1 (430→432) taken 784 times.
2/2
✓ Fully covered.
785 else if ( ++x == number ) {
656 1 return;
657 }
658
2/2
✓ Branch 0 (432→433) taken 1 times.
✓ Branch 1 (432→434) taken 783 times.
2/2
✓ Fully covered.
784 else if ( ++x == number ) {
659 1 return;
660 }
661
2/2
✓ Branch 0 (434→435) taken 1 times.
✓ Branch 1 (434→436) taken 782 times.
2/2
✓ Fully covered.
783 else if ( ++x == number ) {
662 1 return;
663 }
664
2/2
✓ Branch 0 (436→437) taken 1 times.
✓ Branch 1 (436→438) taken 781 times.
2/2
✓ Fully covered.
782 else if ( ++x == number ) {
665 1 return;
666 }
667
2/2
✓ Branch 0 (438→439) taken 1 times.
✓ Branch 1 (438→440) taken 780 times.
2/2
✓ Fully covered.
781 else if ( ++x == number ) {
668 1 return;
669 }
670
2/2
✓ Branch 0 (440→441) taken 1 times.
✓ Branch 1 (440→442) taken 779 times.
2/2
✓ Fully covered.
780 else if ( ++x == number ) {
671 1 return;
672 }
673
2/2
✓ Branch 0 (442→443) taken 1 times.
✓ Branch 1 (442→444) taken 778 times.
2/2
✓ Fully covered.
779 else if ( ++x == number ) {
674 1 return;
675 }
676
2/2
✓ Branch 0 (444→445) taken 1 times.
✓ Branch 1 (444→446) taken 777 times.
2/2
✓ Fully covered.
778 else if ( ++x == number ) {
677 1 return;
678 }
679
2/2
✓ Branch 0 (446→447) taken 1 times.
✓ Branch 1 (446→448) taken 776 times.
2/2
✓ Fully covered.
777 else if ( ++x == number ) {
680 1 return;
681 }
682
2/2
✓ Branch 0 (448→449) taken 1 times.
✓ Branch 1 (448→450) taken 775 times.
2/2
✓ Fully covered.
776 else if ( ++x == number ) {
683 1 return;
684 }
685
2/2
✓ Branch 0 (450→451) taken 1 times.
✓ Branch 1 (450→452) taken 774 times.
2/2
✓ Fully covered.
775 else if ( ++x == number ) {
686 1 return;
687 }
688
2/2
✓ Branch 0 (452→453) taken 1 times.
✓ Branch 1 (452→454) taken 773 times.
2/2
✓ Fully covered.
774 else if ( ++x == number ) {
689 1 return;
690 }
691
2/2
✓ Branch 0 (454→455) taken 1 times.
✓ Branch 1 (454→456) taken 772 times.
2/2
✓ Fully covered.
773 else if ( ++x == number ) {
692 1 return;
693 }
694
2/2
✓ Branch 0 (456→457) taken 1 times.
✓ Branch 1 (456→458) taken 771 times.
2/2
✓ Fully covered.
772 else if ( ++x == number ) {
695 1 return;
696 }
697
2/2
✓ Branch 0 (458→459) taken 1 times.
✓ Branch 1 (458→460) taken 770 times.
2/2
✓ Fully covered.
771 else if ( ++x == number ) {
698 1 return;
699 }
700
2/2
✓ Branch 0 (460→461) taken 1 times.
✓ Branch 1 (460→462) taken 769 times.
2/2
✓ Fully covered.
770 else if ( ++x == number ) {
701 1 return;
702 }
703
2/2
✓ Branch 0 (462→463) taken 1 times.
✓ Branch 1 (462→464) taken 768 times.
2/2
✓ Fully covered.
769 else if ( ++x == number ) {
704 1 return;
705 }
706
2/2
✓ Branch 0 (464→465) taken 1 times.
✓ Branch 1 (464→466) taken 767 times.
2/2
✓ Fully covered.
768 else if ( ++x == number ) {
707 1 return;
708 }
709
2/2
✓ Branch 0 (466→467) taken 1 times.
✓ Branch 1 (466→468) taken 766 times.
2/2
✓ Fully covered.
767 else if ( ++x == number ) {
710 1 return;
711 }
712
2/2
✓ Branch 0 (468→469) taken 1 times.
✓ Branch 1 (468→470) taken 765 times.
2/2
✓ Fully covered.
766 else if ( ++x == number ) {
713 1 return;
714 }
715
2/2
✓ Branch 0 (470→471) taken 1 times.
✓ Branch 1 (470→472) taken 764 times.
2/2
✓ Fully covered.
765 else if ( ++x == number ) {
716 1 return;
717 }
718
2/2
✓ Branch 0 (472→473) taken 1 times.
✓ Branch 1 (472→474) taken 763 times.
2/2
✓ Fully covered.
764 else if ( ++x == number ) {
719 1 return;
720 }
721
2/2
✓ Branch 0 (474→475) taken 1 times.
✓ Branch 1 (474→476) taken 762 times.
2/2
✓ Fully covered.
763 else if ( ++x == number ) {
722 1 return;
723 }
724
2/2
✓ Branch 0 (476→477) taken 1 times.
✓ Branch 1 (476→478) taken 761 times.
2/2
✓ Fully covered.
762 else if ( ++x == number ) {
725 1 return;
726 }
727
2/2
✓ Branch 0 (478→479) taken 1 times.
✓ Branch 1 (478→480) taken 760 times.
2/2
✓ Fully covered.
761 else if ( ++x == number ) {
728 1 return;
729 }
730
2/2
✓ Branch 0 (480→481) taken 1 times.
✓ Branch 1 (480→482) taken 759 times.
2/2
✓ Fully covered.
760 else if ( ++x == number ) {
731 1 return;
732 }
733
2/2
✓ Branch 0 (482→483) taken 1 times.
✓ Branch 1 (482→484) taken 758 times.
2/2
✓ Fully covered.
759 else if ( ++x == number ) {
734 1 return;
735 }
736
2/2
✓ Branch 0 (484→485) taken 1 times.
✓ Branch 1 (484→486) taken 757 times.
2/2
✓ Fully covered.
758 else if ( ++x == number ) {
737 1 return;
738 }
739
2/2
✓ Branch 0 (486→487) taken 1 times.
✓ Branch 1 (486→488) taken 756 times.
2/2
✓ Fully covered.
757 else if ( ++x == number ) {
740 1 return;
741 }
742
2/2
✓ Branch 0 (488→489) taken 1 times.
✓ Branch 1 (488→490) taken 755 times.
2/2
✓ Fully covered.
756 else if ( ++x == number ) {
743 1 return;
744 }
745
2/2
✓ Branch 0 (490→491) taken 1 times.
✓ Branch 1 (490→492) taken 754 times.
2/2
✓ Fully covered.
755 else if ( ++x == number ) {
746 1 return;
747 }
748
2/2
✓ Branch 0 (492→493) taken 1 times.
✓ Branch 1 (492→494) taken 753 times.
2/2
✓ Fully covered.
754 else if ( ++x == number ) {
749 1 return;
750 }
751
2/2
✓ Branch 0 (494→495) taken 1 times.
✓ Branch 1 (494→496) taken 752 times.
2/2
✓ Fully covered.
753 else if ( ++x == number ) {
752 1 return;
753 }
754
2/2
✓ Branch 0 (496→497) taken 1 times.
✓ Branch 1 (496→498) taken 751 times.
2/2
✓ Fully covered.
752 else if ( ++x == number ) {
755 1 return;
756 }
757
2/2
✓ Branch 0 (498→499) taken 1 times.
✓ Branch 1 (498→500) taken 750 times.
2/2
✓ Fully covered.
751 else if ( ++x == number ) {
758 1 return;
759 }
760
2/2
✓ Branch 0 (500→501) taken 1 times.
✓ Branch 1 (500→502) taken 749 times.
2/2
✓ Fully covered.
750 else if ( ++x == number ) {
761 1 return;
762 }
763
2/2
✓ Branch 0 (502→503) taken 1 times.
✓ Branch 1 (502→504) taken 748 times.
2/2
✓ Fully covered.
749 else if ( ++x == number ) {
764 1 return;
765 }
766
2/2
✓ Branch 0 (504→505) taken 1 times.
✓ Branch 1 (504→506) taken 747 times.
2/2
✓ Fully covered.
748 else if ( ++x == number ) {
767 1 return;
768 }
769
2/2
✓ Branch 0 (506→507) taken 1 times.
✓ Branch 1 (506→508) taken 746 times.
2/2
✓ Fully covered.
747 else if ( ++x == number ) {
770 1 return;
771 }
772
2/2
✓ Branch 0 (508→509) taken 1 times.
✓ Branch 1 (508→510) taken 745 times.
2/2
✓ Fully covered.
746 else if ( ++x == number ) {
773 1 return;
774 }
775
2/2
✓ Branch 0 (510→511) taken 1 times.
✓ Branch 1 (510→512) taken 744 times.
2/2
✓ Fully covered.
745 else if ( ++x == number ) {
776 1 return;
777 }
778
2/2
✓ Branch 0 (512→513) taken 1 times.
✓ Branch 1 (512→514) taken 743 times.
2/2
✓ Fully covered.
744 else if ( ++x == number ) {
779 1 return;
780 }
781
2/2
✓ Branch 0 (514→515) taken 1 times.
✓ Branch 1 (514→516) taken 742 times.
2/2
✓ Fully covered.
743 else if ( ++x == number ) {
782 1 return;
783 }
784
2/2
✓ Branch 0 (516→517) taken 1 times.
✓ Branch 1 (516→518) taken 741 times.
2/2
✓ Fully covered.
742 else if ( ++x == number ) {
785 1 return;
786 }
787
2/2
✓ Branch 0 (518→519) taken 1 times.
✓ Branch 1 (518→520) taken 740 times.
2/2
✓ Fully covered.
741 else if ( ++x == number ) {
788 1 return;
789 }
790
2/2
✓ Branch 0 (520→521) taken 1 times.
✓ Branch 1 (520→522) taken 739 times.
2/2
✓ Fully covered.
740 else if ( ++x == number ) {
791 1 return;
792 }
793
2/2
✓ Branch 0 (522→523) taken 1 times.
✓ Branch 1 (522→524) taken 738 times.
2/2
✓ Fully covered.
739 else if ( ++x == number ) {
794 1 return;
795 }
796
2/2
✓ Branch 0 (524→525) taken 1 times.
✓ Branch 1 (524→526) taken 737 times.
2/2
✓ Fully covered.
738 else if ( ++x == number ) {
797 1 return;
798 }
799
2/2
✓ Branch 0 (526→527) taken 1 times.
✓ Branch 1 (526→528) taken 736 times.
2/2
✓ Fully covered.
737 else if ( ++x == number ) {
800 1 return;
801 }
802
2/2
✓ Branch 0 (528→529) taken 1 times.
✓ Branch 1 (528→530) taken 735 times.
2/2
✓ Fully covered.
736 else if ( ++x == number ) {
803 1 return;
804 }
805
2/2
✓ Branch 0 (530→531) taken 1 times.
✓ Branch 1 (530→532) taken 734 times.
2/2
✓ Fully covered.
735 else if ( ++x == number ) {
806 1 return;
807 }
808
2/2
✓ Branch 0 (532→533) taken 1 times.
✓ Branch 1 (532→534) taken 733 times.
2/2
✓ Fully covered.
734 else if ( ++x == number ) {
809 1 return;
810 }
811
2/2
✓ Branch 0 (534→535) taken 1 times.
✓ Branch 1 (534→536) taken 732 times.
2/2
✓ Fully covered.
733 else if ( ++x == number ) {
812 1 return;
813 }
814
2/2
✓ Branch 0 (536→537) taken 1 times.
✓ Branch 1 (536→538) taken 731 times.
2/2
✓ Fully covered.
732 else if ( ++x == number ) {
815 1 return;
816 }
817
2/2
✓ Branch 0 (538→539) taken 1 times.
✓ Branch 1 (538→540) taken 730 times.
2/2
✓ Fully covered.
731 else if ( ++x == number ) {
818 1 return;
819 }
820
2/2
✓ Branch 0 (540→541) taken 1 times.
✓ Branch 1 (540→542) taken 729 times.
2/2
✓ Fully covered.
730 else if ( ++x == number ) {
821 1 return;
822 }
823
2/2
✓ Branch 0 (542→543) taken 1 times.
✓ Branch 1 (542→544) taken 728 times.
2/2
✓ Fully covered.
729 else if ( ++x == number ) {
824 1 return;
825 }
826
2/2
✓ Branch 0 (544→545) taken 1 times.
✓ Branch 1 (544→546) taken 727 times.
2/2
✓ Fully covered.
728 else if ( ++x == number ) {
827 1 return;
828 }
829
2/2
✓ Branch 0 (546→547) taken 1 times.
✓ Branch 1 (546→548) taken 726 times.
2/2
✓ Fully covered.
727 else if ( ++x == number ) {
830 1 return;
831 }
832
2/2
✓ Branch 0 (548→549) taken 1 times.
✓ Branch 1 (548→550) taken 725 times.
2/2
✓ Fully covered.
726 else if ( ++x == number ) {
833 1 return;
834 }
835
2/2
✓ Branch 0 (550→551) taken 1 times.
✓ Branch 1 (550→552) taken 724 times.
2/2
✓ Fully covered.
725 else if ( ++x == number ) {
836 1 return;
837 }
838
2/2
✓ Branch 0 (552→553) taken 1 times.
✓ Branch 1 (552→554) taken 723 times.
2/2
✓ Fully covered.
724 else if ( ++x == number ) {
839 1 return;
840 }
841
2/2
✓ Branch 0 (554→555) taken 1 times.
✓ Branch 1 (554→556) taken 722 times.
2/2
✓ Fully covered.
723 else if ( ++x == number ) {
842 1 return;
843 }
844
2/2
✓ Branch 0 (556→557) taken 1 times.
✓ Branch 1 (556→558) taken 721 times.
2/2
✓ Fully covered.
722 else if ( ++x == number ) {
845 1 return;
846 }
847
2/2
✓ Branch 0 (558→559) taken 1 times.
✓ Branch 1 (558→560) taken 720 times.
2/2
✓ Fully covered.
721 else if ( ++x == number ) {
848 1 return;
849 }
850
2/2
✓ Branch 0 (560→561) taken 1 times.
✓ Branch 1 (560→562) taken 719 times.
2/2
✓ Fully covered.
720 else if ( ++x == number ) {
851 1 return;
852 }
853
2/2
✓ Branch 0 (562→563) taken 1 times.
✓ Branch 1 (562→564) taken 718 times.
2/2
✓ Fully covered.
719 else if ( ++x == number ) {
854 1 return;
855 }
856
2/2
✓ Branch 0 (564→565) taken 1 times.
✓ Branch 1 (564→566) taken 717 times.
2/2
✓ Fully covered.
718 else if ( ++x == number ) {
857 1 return;
858 }
859
2/2
✓ Branch 0 (566→567) taken 1 times.
✓ Branch 1 (566→568) taken 716 times.
2/2
✓ Fully covered.
717 else if ( ++x == number ) {
860 1 return;
861 }
862
2/2
✓ Branch 0 (568→569) taken 1 times.
✓ Branch 1 (568→570) taken 715 times.
2/2
✓ Fully covered.
716 else if ( ++x == number ) {
863 1 return;
864 }
865
2/2
✓ Branch 0 (570→571) taken 1 times.
✓ Branch 1 (570→572) taken 714 times.
2/2
✓ Fully covered.
715 else if ( ++x == number ) {
866 1 return;
867 }
868
2/2
✓ Branch 0 (572→573) taken 1 times.
✓ Branch 1 (572→574) taken 713 times.
2/2
✓ Fully covered.
714 else if ( ++x == number ) {
869 1 return;
870 }
871
2/2
✓ Branch 0 (574→575) taken 1 times.
✓ Branch 1 (574→576) taken 712 times.
2/2
✓ Fully covered.
713 else if ( ++x == number ) {
872 1 return;
873 }
874
2/2
✓ Branch 0 (576→577) taken 1 times.
✓ Branch 1 (576→578) taken 711 times.
2/2
✓ Fully covered.
712 else if ( ++x == number ) {
875 1 return;
876 }
877
2/2
✓ Branch 0 (578→579) taken 1 times.
✓ Branch 1 (578→580) taken 710 times.
2/2
✓ Fully covered.
711 else if ( ++x == number ) {
878 1 return;
879 }
880
2/2
✓ Branch 0 (580→581) taken 1 times.
✓ Branch 1 (580→582) taken 709 times.
2/2
✓ Fully covered.
710 else if ( ++x == number ) {
881 1 return;
882 }
883
2/2
✓ Branch 0 (582→583) taken 1 times.
✓ Branch 1 (582→584) taken 708 times.
2/2
✓ Fully covered.
709 else if ( ++x == number ) {
884 1 return;
885 }
886
2/2
✓ Branch 0 (584→585) taken 1 times.
✓ Branch 1 (584→586) taken 707 times.
2/2
✓ Fully covered.
708 else if ( ++x == number ) {
887 1 return;
888 }
889
2/2
✓ Branch 0 (586→587) taken 1 times.
✓ Branch 1 (586→588) taken 706 times.
2/2
✓ Fully covered.
707 else if ( ++x == number ) {
890 1 return;
891 }
892
2/2
✓ Branch 0 (588→589) taken 1 times.
✓ Branch 1 (588→590) taken 705 times.
2/2
✓ Fully covered.
706 else if ( ++x == number ) {
893 1 return;
894 }
895
2/2
✓ Branch 0 (590→591) taken 1 times.
✓ Branch 1 (590→592) taken 704 times.
2/2
✓ Fully covered.
705 else if ( ++x == number ) {
896 1 return;
897 }
898
2/2
✓ Branch 0 (592→593) taken 1 times.
✓ Branch 1 (592→594) taken 703 times.
2/2
✓ Fully covered.
704 else if ( ++x == number ) {
899 1 return;
900 }
901
2/2
✓ Branch 0 (594→595) taken 1 times.
✓ Branch 1 (594→596) taken 702 times.
2/2
✓ Fully covered.
703 else if ( ++x == number ) {
902 1 return;
903 }
904
2/2
✓ Branch 0 (596→597) taken 1 times.
✓ Branch 1 (596→598) taken 701 times.
2/2
✓ Fully covered.
702 else if ( ++x == number ) {
905 1 return;
906 }
907
2/2
✓ Branch 0 (598→599) taken 1 times.
✓ Branch 1 (598→600) taken 700 times.
2/2
✓ Fully covered.
701 else if ( ++x == number ) {
908 1 return;
909 }
910
2/2
✓ Branch 0 (600→601) taken 1 times.
✓ Branch 1 (600→602) taken 699 times.
2/2
✓ Fully covered.
700 else if ( ++x == number ) {
911 1 return;
912 }
913
2/2
✓ Branch 0 (602→603) taken 1 times.
✓ Branch 1 (602→604) taken 698 times.
2/2
✓ Fully covered.
699 else if ( ++x == number ) {
914 1 return;
915 }
916
2/2
✓ Branch 0 (604→605) taken 1 times.
✓ Branch 1 (604→606) taken 697 times.
2/2
✓ Fully covered.
698 else if ( ++x == number ) {
917 1 return;
918 }
919
2/2
✓ Branch 0 (606→607) taken 1 times.
✓ Branch 1 (606→608) taken 696 times.
2/2
✓ Fully covered.
697 else if ( ++x == number ) {
920 1 return;
921 }
922
2/2
✓ Branch 0 (608→609) taken 1 times.
✓ Branch 1 (608→610) taken 695 times.
2/2
✓ Fully covered.
696 else if ( ++x == number ) {
923 1 return;
924 }
925
2/2
✓ Branch 0 (610→611) taken 1 times.
✓ Branch 1 (610→612) taken 694 times.
2/2
✓ Fully covered.
695 else if ( ++x == number ) {
926 1 return;
927 }
928
2/2
✓ Branch 0 (612→613) taken 1 times.
✓ Branch 1 (612→614) taken 693 times.
2/2
✓ Fully covered.
694 else if ( ++x == number ) {
929 1 return;
930 }
931
2/2
✓ Branch 0 (614→615) taken 1 times.
✓ Branch 1 (614→616) taken 692 times.
2/2
✓ Fully covered.
693 else if ( ++x == number ) {
932 1 return;
933 }
934
2/2
✓ Branch 0 (616→617) taken 1 times.
✓ Branch 1 (616→618) taken 691 times.
2/2
✓ Fully covered.
692 else if ( ++x == number ) {
935 1 return;
936 }
937
2/2
✓ Branch 0 (618→619) taken 1 times.
✓ Branch 1 (618→620) taken 690 times.
2/2
✓ Fully covered.
691 else if ( ++x == number ) {
938 1 return;
939 }
940
2/2
✓ Branch 0 (620→621) taken 1 times.
✓ Branch 1 (620→622) taken 689 times.
2/2
✓ Fully covered.
690 else if ( ++x == number ) {
941 1 return;
942 }
943
2/2
✓ Branch 0 (622→623) taken 1 times.
✓ Branch 1 (622→624) taken 688 times.
2/2
✓ Fully covered.
689 else if ( ++x == number ) {
944 1 return;
945 }
946
2/2
✓ Branch 0 (624→625) taken 1 times.
✓ Branch 1 (624→626) taken 687 times.
2/2
✓ Fully covered.
688 else if ( ++x == number ) {
947 1 return;
948 }
949
2/2
✓ Branch 0 (626→627) taken 1 times.
✓ Branch 1 (626→628) taken 686 times.
2/2
✓ Fully covered.
687 else if ( ++x == number ) {
950 1 return;
951 }
952
2/2
✓ Branch 0 (628→629) taken 1 times.
✓ Branch 1 (628→630) taken 685 times.
2/2
✓ Fully covered.
686 else if ( ++x == number ) {
953 1 return;
954 }
955
2/2
✓ Branch 0 (630→631) taken 1 times.
✓ Branch 1 (630→632) taken 684 times.
2/2
✓ Fully covered.
685 else if ( ++x == number ) {
956 1 return;
957 }
958
2/2
✓ Branch 0 (632→633) taken 1 times.
✓ Branch 1 (632→634) taken 683 times.
2/2
✓ Fully covered.
684 else if ( ++x == number ) {
959 1 return;
960 }
961
2/2
✓ Branch 0 (634→635) taken 1 times.
✓ Branch 1 (634→636) taken 682 times.
2/2
✓ Fully covered.
683 else if ( ++x == number ) {
962 1 return;
963 }
964
2/2
✓ Branch 0 (636→637) taken 1 times.
✓ Branch 1 (636→638) taken 681 times.
2/2
✓ Fully covered.
682 else if ( ++x == number ) {
965 1 return;
966 }
967
2/2
✓ Branch 0 (638→639) taken 1 times.
✓ Branch 1 (638→640) taken 680 times.
2/2
✓ Fully covered.
681 else if ( ++x == number ) {
968 1 return;
969 }
970
2/2
✓ Branch 0 (640→641) taken 1 times.
✓ Branch 1 (640→642) taken 679 times.
2/2
✓ Fully covered.
680 else if ( ++x == number ) {
971 1 return;
972 }
973
2/2
✓ Branch 0 (642→643) taken 1 times.
✓ Branch 1 (642→644) taken 678 times.
2/2
✓ Fully covered.
679 else if ( ++x == number ) {
974 1 return;
975 }
976
2/2
✓ Branch 0 (644→645) taken 1 times.
✓ Branch 1 (644→646) taken 677 times.
2/2
✓ Fully covered.
678 else if ( ++x == number ) {
977 1 return;
978 }
979
2/2
✓ Branch 0 (646→647) taken 1 times.
✓ Branch 1 (646→648) taken 676 times.
2/2
✓ Fully covered.
677 else if ( ++x == number ) {
980 1 return;
981 }
982
2/2
✓ Branch 0 (648→649) taken 1 times.
✓ Branch 1 (648→650) taken 675 times.
2/2
✓ Fully covered.
676 else if ( ++x == number ) {
983 1 return;
984 }
985
2/2
✓ Branch 0 (650→651) taken 1 times.
✓ Branch 1 (650→652) taken 674 times.
2/2
✓ Fully covered.
675 else if ( ++x == number ) {
986 1 return;
987 }
988
2/2
✓ Branch 0 (652→653) taken 1 times.
✓ Branch 1 (652→654) taken 673 times.
2/2
✓ Fully covered.
674 else if ( ++x == number ) {
989 1 return;
990 }
991
2/2
✓ Branch 0 (654→655) taken 1 times.
✓ Branch 1 (654→656) taken 672 times.
2/2
✓ Fully covered.
673 else if ( ++x == number ) {
992 1 return;
993 }
994
2/2
✓ Branch 0 (656→657) taken 1 times.
✓ Branch 1 (656→658) taken 671 times.
2/2
✓ Fully covered.
672 else if ( ++x == number ) {
995 1 return;
996 }
997
2/2
✓ Branch 0 (658→659) taken 1 times.
✓ Branch 1 (658→660) taken 670 times.
2/2
✓ Fully covered.
671 else if ( ++x == number ) {
998 1 return;
999 }
1000
2/2
✓ Branch 0 (660→661) taken 1 times.
✓ Branch 1 (660→662) taken 669 times.
2/2
✓ Fully covered.
670 else if ( ++x == number ) {
1001 1 return;
1002 }
1003
2/2
✓ Branch 0 (662→663) taken 1 times.
✓ Branch 1 (662→664) taken 668 times.
2/2
✓ Fully covered.
669 else if ( ++x == number ) {
1004 1 return;
1005 }
1006
2/2
✓ Branch 0 (664→665) taken 1 times.
✓ Branch 1 (664→666) taken 667 times.
2/2
✓ Fully covered.
668 else if ( ++x == number ) {
1007 1 return;
1008 }
1009
2/2
✓ Branch 0 (666→667) taken 1 times.
✓ Branch 1 (666→668) taken 666 times.
2/2
✓ Fully covered.
667 else if ( ++x == number ) {
1010 1 return;
1011 }
1012
2/2
✓ Branch 0 (668→669) taken 1 times.
✓ Branch 1 (668→670) taken 665 times.
2/2
✓ Fully covered.
666 else if ( ++x == number ) {
1013 1 return;
1014 }
1015
2/2
✓ Branch 0 (670→671) taken 1 times.
✓ Branch 1 (670→672) taken 664 times.
2/2
✓ Fully covered.
665 else if ( ++x == number ) {
1016 1 return;
1017 }
1018
2/2
✓ Branch 0 (672→673) taken 1 times.
✓ Branch 1 (672→674) taken 663 times.
2/2
✓ Fully covered.
664 else if ( ++x == number ) {
1019 1 return;
1020 }
1021
2/2
✓ Branch 0 (674→675) taken 1 times.
✓ Branch 1 (674→676) taken 662 times.
2/2
✓ Fully covered.
663 else if ( ++x == number ) {
1022 1 return;
1023 }
1024
2/2
✓ Branch 0 (676→677) taken 1 times.
✓ Branch 1 (676→678) taken 661 times.
2/2
✓ Fully covered.
662 else if ( ++x == number ) {
1025 1 return;
1026 }
1027
2/2
✓ Branch 0 (678→679) taken 1 times.
✓ Branch 1 (678→680) taken 660 times.
2/2
✓ Fully covered.
661 else if ( ++x == number ) {
1028 1 return;
1029 }
1030
2/2
✓ Branch 0 (680→681) taken 1 times.
✓ Branch 1 (680→682) taken 659 times.
2/2
✓ Fully covered.
660 else if ( ++x == number ) {
1031 1 return;
1032 }
1033
2/2
✓ Branch 0 (682→683) taken 1 times.
✓ Branch 1 (682→684) taken 658 times.
2/2
✓ Fully covered.
659 else if ( ++x == number ) {
1034 1 return;
1035 }
1036
2/2
✓ Branch 0 (684→685) taken 1 times.
✓ Branch 1 (684→686) taken 657 times.
2/2
✓ Fully covered.
658 else if ( ++x == number ) {
1037 1 return;
1038 }
1039
2/2
✓ Branch 0 (686→687) taken 1 times.
✓ Branch 1 (686→688) taken 656 times.
2/2
✓ Fully covered.
657 else if ( ++x == number ) {
1040 1 return;
1041 }
1042
2/2
✓ Branch 0 (688→689) taken 1 times.
✓ Branch 1 (688→690) taken 655 times.
2/2
✓ Fully covered.
656 else if ( ++x == number ) {
1043 1 return;
1044 }
1045
2/2
✓ Branch 0 (690→691) taken 1 times.
✓ Branch 1 (690→692) taken 654 times.
2/2
✓ Fully covered.
655 else if ( ++x == number ) {
1046 1 return;
1047 }
1048
2/2
✓ Branch 0 (692→693) taken 1 times.
✓ Branch 1 (692→694) taken 653 times.
2/2
✓ Fully covered.
654 else if ( ++x == number ) {
1049 1 return;
1050 }
1051
2/2
✓ Branch 0 (694→695) taken 1 times.
✓ Branch 1 (694→696) taken 652 times.
2/2
✓ Fully covered.
653 else if ( ++x == number ) {
1052 1 return;
1053 }
1054
2/2
✓ Branch 0 (696→697) taken 1 times.
✓ Branch 1 (696→698) taken 651 times.
2/2
✓ Fully covered.
652 else if ( ++x == number ) {
1055 1 return;
1056 }
1057
2/2
✓ Branch 0 (698→699) taken 1 times.
✓ Branch 1 (698→700) taken 650 times.
2/2
✓ Fully covered.
651 else if ( ++x == number ) {
1058 1 return;
1059 }
1060
2/2
✓ Branch 0 (700→701) taken 1 times.
✓ Branch 1 (700→702) taken 649 times.
2/2
✓ Fully covered.
650 else if ( ++x == number ) {
1061 1 return;
1062 }
1063
2/2
✓ Branch 0 (702→703) taken 1 times.
✓ Branch 1 (702→704) taken 648 times.
2/2
✓ Fully covered.
649 else if ( ++x == number ) {
1064 1 return;
1065 }
1066
2/2
✓ Branch 0 (704→705) taken 1 times.
✓ Branch 1 (704→706) taken 647 times.
2/2
✓ Fully covered.
648 else if ( ++x == number ) {
1067 1 return;
1068 }
1069
2/2
✓ Branch 0 (706→707) taken 1 times.
✓ Branch 1 (706→708) taken 646 times.
2/2
✓ Fully covered.
647 else if ( ++x == number ) {
1070 1 return;
1071 }
1072
2/2
✓ Branch 0 (708→709) taken 1 times.
✓ Branch 1 (708→710) taken 645 times.
2/2
✓ Fully covered.
646 else if ( ++x == number ) {
1073 1 return;
1074 }
1075
2/2
✓ Branch 0 (710→711) taken 1 times.
✓ Branch 1 (710→712) taken 644 times.
2/2
✓ Fully covered.
645 else if ( ++x == number ) {
1076 1 return;
1077 }
1078
2/2
✓ Branch 0 (712→713) taken 1 times.
✓ Branch 1 (712→714) taken 643 times.
2/2
✓ Fully covered.
644 else if ( ++x == number ) {
1079 1 return;
1080 }
1081
2/2
✓ Branch 0 (714→715) taken 1 times.
✓ Branch 1 (714→716) taken 642 times.
2/2
✓ Fully covered.
643 else if ( ++x == number ) {
1082 1 return;
1083 }
1084
2/2
✓ Branch 0 (716→717) taken 1 times.
✓ Branch 1 (716→718) taken 641 times.
2/2
✓ Fully covered.
642 else if ( ++x == number ) {
1085 1 return;
1086 }
1087
2/2
✓ Branch 0 (718→719) taken 1 times.
✓ Branch 1 (718→720) taken 640 times.
2/2
✓ Fully covered.
641 else if ( ++x == number ) {
1088 1 return;
1089 }
1090
2/2
✓ Branch 0 (720→721) taken 1 times.
✓ Branch 1 (720→722) taken 639 times.
2/2
✓ Fully covered.
640 else if ( ++x == number ) {
1091 1 return;
1092 }
1093
2/2
✓ Branch 0 (722→723) taken 1 times.
✓ Branch 1 (722→724) taken 638 times.
2/2
✓ Fully covered.
639 else if ( ++x == number ) {
1094 1 return;
1095 }
1096
2/2
✓ Branch 0 (724→725) taken 1 times.
✓ Branch 1 (724→726) taken 637 times.
2/2
✓ Fully covered.
638 else if ( ++x == number ) {
1097 1 return;
1098 }
1099
2/2
✓ Branch 0 (726→727) taken 1 times.
✓ Branch 1 (726→728) taken 636 times.
2/2
✓ Fully covered.
637 else if ( ++x == number ) {
1100 1 return;
1101 }
1102
2/2
✓ Branch 0 (728→729) taken 1 times.
✓ Branch 1 (728→730) taken 635 times.
2/2
✓ Fully covered.
636 else if ( ++x == number ) {
1103 1 return;
1104 }
1105
2/2
✓ Branch 0 (730→731) taken 1 times.
✓ Branch 1 (730→732) taken 634 times.
2/2
✓ Fully covered.
635 else if ( ++x == number ) {
1106 1 return;
1107 }
1108
2/2
✓ Branch 0 (732→733) taken 1 times.
✓ Branch 1 (732→734) taken 633 times.
2/2
✓ Fully covered.
634 else if ( ++x == number ) {
1109 1 return;
1110 }
1111
2/2
✓ Branch 0 (734→735) taken 1 times.
✓ Branch 1 (734→736) taken 632 times.
2/2
✓ Fully covered.
633 else if ( ++x == number ) {
1112 1 return;
1113 }
1114
2/2
✓ Branch 0 (736→737) taken 1 times.
✓ Branch 1 (736→738) taken 631 times.
2/2
✓ Fully covered.
632 else if ( ++x == number ) {
1115 1 return;
1116 }
1117
2/2
✓ Branch 0 (738→739) taken 1 times.
✓ Branch 1 (738→740) taken 630 times.
2/2
✓ Fully covered.
631 else if ( ++x == number ) {
1118 1 return;
1119 }
1120
2/2
✓ Branch 0 (740→741) taken 1 times.
✓ Branch 1 (740→742) taken 629 times.
2/2
✓ Fully covered.
630 else if ( ++x == number ) {
1121 1 return;
1122 }
1123
2/2
✓ Branch 0 (742→743) taken 1 times.
✓ Branch 1 (742→744) taken 628 times.
2/2
✓ Fully covered.
629 else if ( ++x == number ) {
1124 1 return;
1125 }
1126
2/2
✓ Branch 0 (744→745) taken 1 times.
✓ Branch 1 (744→746) taken 627 times.
2/2
✓ Fully covered.
628 else if ( ++x == number ) {
1127 1 return;
1128 }
1129
2/2
✓ Branch 0 (746→747) taken 1 times.
✓ Branch 1 (746→748) taken 626 times.
2/2
✓ Fully covered.
627 else if ( ++x == number ) {
1130 1 return;
1131 }
1132
2/2
✓ Branch 0 (748→749) taken 1 times.
✓ Branch 1 (748→750) taken 625 times.
2/2
✓ Fully covered.
626 else if ( ++x == number ) {
1133 1 return;
1134 }
1135
2/2
✓ Branch 0 (750→751) taken 1 times.
✓ Branch 1 (750→752) taken 624 times.
2/2
✓ Fully covered.
625 else if ( ++x == number ) {
1136 1 return;
1137 }
1138
2/2
✓ Branch 0 (752→753) taken 1 times.
✓ Branch 1 (752→754) taken 623 times.
2/2
✓ Fully covered.
624 else if ( ++x == number ) {
1139 1 return;
1140 }
1141
2/2
✓ Branch 0 (754→755) taken 1 times.
✓ Branch 1 (754→756) taken 622 times.
2/2
✓ Fully covered.
623 else if ( ++x == number ) {
1142 1 return;
1143 }
1144
2/2
✓ Branch 0 (756→757) taken 1 times.
✓ Branch 1 (756→758) taken 621 times.
2/2
✓ Fully covered.
622 else if ( ++x == number ) {
1145 1 return;
1146 }
1147
2/2
✓ Branch 0 (758→759) taken 1 times.
✓ Branch 1 (758→760) taken 620 times.
2/2
✓ Fully covered.
621 else if ( ++x == number ) {
1148 1 return;
1149 }
1150
2/2
✓ Branch 0 (760→761) taken 1 times.
✓ Branch 1 (760→762) taken 619 times.
2/2
✓ Fully covered.
620 else if ( ++x == number ) {
1151 1 return;
1152 }
1153
2/2
✓ Branch 0 (762→763) taken 1 times.
✓ Branch 1 (762→764) taken 618 times.
2/2
✓ Fully covered.
619 else if ( ++x == number ) {
1154 1 return;
1155 }
1156
2/2
✓ Branch 0 (764→765) taken 1 times.
✓ Branch 1 (764→766) taken 617 times.
2/2
✓ Fully covered.
618 else if ( ++x == number ) {
1157 1 return;
1158 }
1159
2/2
✓ Branch 0 (766→767) taken 1 times.
✓ Branch 1 (766→768) taken 616 times.
2/2
✓ Fully covered.
617 else if ( ++x == number ) {
1160 1 return;
1161 }
1162
2/2
✓ Branch 0 (768→769) taken 1 times.
✓ Branch 1 (768→770) taken 615 times.
2/2
✓ Fully covered.
616 else if ( ++x == number ) {
1163 1 return;
1164 }
1165
2/2
✓ Branch 0 (770→771) taken 1 times.
✓ Branch 1 (770→772) taken 614 times.
2/2
✓ Fully covered.
615 else if ( ++x == number ) {
1166 1 return;
1167 }
1168
2/2
✓ Branch 0 (772→773) taken 1 times.
✓ Branch 1 (772→774) taken 613 times.
2/2
✓ Fully covered.
614 else if ( ++x == number ) {
1169 1 return;
1170 }
1171
2/2
✓ Branch 0 (774→775) taken 1 times.
✓ Branch 1 (774→776) taken 612 times.
2/2
✓ Fully covered.
613 else if ( ++x == number ) {
1172 1 return;
1173 }
1174
2/2
✓ Branch 0 (776→777) taken 1 times.
✓ Branch 1 (776→778) taken 611 times.
2/2
✓ Fully covered.
612 else if ( ++x == number ) {
1175 1 return;
1176 }
1177
2/2
✓ Branch 0 (778→779) taken 1 times.
✓ Branch 1 (778→780) taken 610 times.
2/2
✓ Fully covered.
611 else if ( ++x == number ) {
1178 1 return;
1179 }
1180
2/2
✓ Branch 0 (780→781) taken 1 times.
✓ Branch 1 (780→782) taken 609 times.
2/2
✓ Fully covered.
610 else if ( ++x == number ) {
1181 1 return;
1182 }
1183
2/2
✓ Branch 0 (782→783) taken 1 times.
✓ Branch 1 (782→784) taken 608 times.
2/2
✓ Fully covered.
609 else if ( ++x == number ) {
1184 1 return;
1185 }
1186
2/2
✓ Branch 0 (784→785) taken 1 times.
✓ Branch 1 (784→786) taken 607 times.
2/2
✓ Fully covered.
608 else if ( ++x == number ) {
1187 1 return;
1188 }
1189
2/2
✓ Branch 0 (786→787) taken 1 times.
✓ Branch 1 (786→788) taken 606 times.
2/2
✓ Fully covered.
607 else if ( ++x == number ) {
1190 1 return;
1191 }
1192
2/2
✓ Branch 0 (788→789) taken 1 times.
✓ Branch 1 (788→790) taken 605 times.
2/2
✓ Fully covered.
606 else if ( ++x == number ) {
1193 1 return;
1194 }
1195
2/2
✓ Branch 0 (790→791) taken 1 times.
✓ Branch 1 (790→792) taken 604 times.
2/2
✓ Fully covered.
605 else if ( ++x == number ) {
1196 1 return;
1197 }
1198
2/2
✓ Branch 0 (792→793) taken 1 times.
✓ Branch 1 (792→794) taken 603 times.
2/2
✓ Fully covered.
604 else if ( ++x == number ) {
1199 1 return;
1200 }
1201
2/2
✓ Branch 0 (794→795) taken 1 times.
✓ Branch 1 (794→796) taken 602 times.
2/2
✓ Fully covered.
603 else if ( ++x == number ) {
1202 1 return;
1203 }
1204
2/2
✓ Branch 0 (796→797) taken 1 times.
✓ Branch 1 (796→798) taken 601 times.
2/2
✓ Fully covered.
602 else if ( ++x == number ) {
1205 1 return;
1206 }
1207
2/2
✓ Branch 0 (798→799) taken 1 times.
✓ Branch 1 (798→800) taken 600 times.
2/2
✓ Fully covered.
601 else if ( ++x == number ) {
1208 1 return;
1209 }
1210
2/2
✓ Branch 0 (800→801) taken 1 times.
✓ Branch 1 (800→802) taken 599 times.
2/2
✓ Fully covered.
600 else if ( ++x == number ) {
1211 1 return;
1212 }
1213
2/2
✓ Branch 0 (802→803) taken 1 times.
✓ Branch 1 (802→804) taken 598 times.
2/2
✓ Fully covered.
599 else if ( ++x == number ) {
1214 1 return;
1215 }
1216
2/2
✓ Branch 0 (804→805) taken 1 times.
✓ Branch 1 (804→806) taken 597 times.
2/2
✓ Fully covered.
598 else if ( ++x == number ) {
1217 1 return;
1218 }
1219
2/2
✓ Branch 0 (806→807) taken 1 times.
✓ Branch 1 (806→808) taken 596 times.
2/2
✓ Fully covered.
597 else if ( ++x == number ) {
1220 1 return;
1221 }
1222
2/2
✓ Branch 0 (808→809) taken 1 times.
✓ Branch 1 (808→810) taken 595 times.
2/2
✓ Fully covered.
596 else if ( ++x == number ) {
1223 1 return;
1224 }
1225
2/2
✓ Branch 0 (810→811) taken 1 times.
✓ Branch 1 (810→812) taken 594 times.
2/2
✓ Fully covered.
595 else if ( ++x == number ) {
1226 1 return;
1227 }
1228
2/2
✓ Branch 0 (812→813) taken 1 times.
✓ Branch 1 (812→814) taken 593 times.
2/2
✓ Fully covered.
594 else if ( ++x == number ) {
1229 1 return;
1230 }
1231
2/2
✓ Branch 0 (814→815) taken 1 times.
✓ Branch 1 (814→816) taken 592 times.
2/2
✓ Fully covered.
593 else if ( ++x == number ) {
1232 1 return;
1233 }
1234
2/2
✓ Branch 0 (816→817) taken 1 times.
✓ Branch 1 (816→818) taken 591 times.
2/2
✓ Fully covered.
592 else if ( ++x == number ) {
1235 1 return;
1236 }
1237
2/2
✓ Branch 0 (818→819) taken 1 times.
✓ Branch 1 (818→820) taken 590 times.
2/2
✓ Fully covered.
591 else if ( ++x == number ) {
1238 1 return;
1239 }
1240
2/2
✓ Branch 0 (820→821) taken 1 times.
✓ Branch 1 (820→822) taken 589 times.
2/2
✓ Fully covered.
590 else if ( ++x == number ) {
1241 1 return;
1242 }
1243
2/2
✓ Branch 0 (822→823) taken 1 times.
✓ Branch 1 (822→824) taken 588 times.
2/2
✓ Fully covered.
589 else if ( ++x == number ) {
1244 1 return;
1245 }
1246
2/2
✓ Branch 0 (824→825) taken 1 times.
✓ Branch 1 (824→826) taken 587 times.
2/2
✓ Fully covered.
588 else if ( ++x == number ) {
1247 1 return;
1248 }
1249
2/2
✓ Branch 0 (826→827) taken 1 times.
✓ Branch 1 (826→828) taken 586 times.
2/2
✓ Fully covered.
587 else if ( ++x == number ) {
1250 1 return;
1251 }
1252
2/2
✓ Branch 0 (828→829) taken 1 times.
✓ Branch 1 (828→830) taken 585 times.
2/2
✓ Fully covered.
586 else if ( ++x == number ) {
1253 1 return;
1254 }
1255
2/2
✓ Branch 0 (830→831) taken 1 times.
✓ Branch 1 (830→832) taken 584 times.
2/2
✓ Fully covered.
585 else if ( ++x == number ) {
1256 1 return;
1257 }
1258
2/2
✓ Branch 0 (832→833) taken 1 times.
✓ Branch 1 (832→834) taken 583 times.
2/2
✓ Fully covered.
584 else if ( ++x == number ) {
1259 1 return;
1260 }
1261
2/2
✓ Branch 0 (834→835) taken 1 times.
✓ Branch 1 (834→836) taken 582 times.
2/2
✓ Fully covered.
583 else if ( ++x == number ) {
1262 1 return;
1263 }
1264
2/2
✓ Branch 0 (836→837) taken 1 times.
✓ Branch 1 (836→838) taken 581 times.
2/2
✓ Fully covered.
582 else if ( ++x == number ) {
1265 1 return;
1266 }
1267
2/2
✓ Branch 0 (838→839) taken 1 times.
✓ Branch 1 (838→840) taken 580 times.
2/2
✓ Fully covered.
581 else if ( ++x == number ) {
1268 1 return;
1269 }
1270
2/2
✓ Branch 0 (840→841) taken 1 times.
✓ Branch 1 (840→842) taken 579 times.
2/2
✓ Fully covered.
580 else if ( ++x == number ) {
1271 1 return;
1272 }
1273
2/2
✓ Branch 0 (842→843) taken 1 times.
✓ Branch 1 (842→844) taken 578 times.
2/2
✓ Fully covered.
579 else if ( ++x == number ) {
1274 1 return;
1275 }
1276
2/2
✓ Branch 0 (844→845) taken 1 times.
✓ Branch 1 (844→846) taken 577 times.
2/2
✓ Fully covered.
578 else if ( ++x == number ) {
1277 1 return;
1278 }
1279
2/2
✓ Branch 0 (846→847) taken 1 times.
✓ Branch 1 (846→848) taken 576 times.
2/2
✓ Fully covered.
577 else if ( ++x == number ) {
1280 1 return;
1281 }
1282
2/2
✓ Branch 0 (848→849) taken 1 times.
✓ Branch 1 (848→850) taken 575 times.
2/2
✓ Fully covered.
576 else if ( ++x == number ) {
1283 1 return;
1284 }
1285
2/2
✓ Branch 0 (850→851) taken 1 times.
✓ Branch 1 (850→852) taken 574 times.
2/2
✓ Fully covered.
575 else if ( ++x == number ) {
1286 1 return;
1287 }
1288
2/2
✓ Branch 0 (852→853) taken 1 times.
✓ Branch 1 (852→854) taken 573 times.
2/2
✓ Fully covered.
574 else if ( ++x == number ) {
1289 1 return;
1290 }
1291
2/2
✓ Branch 0 (854→855) taken 1 times.
✓ Branch 1 (854→856) taken 572 times.
2/2
✓ Fully covered.
573 else if ( ++x == number ) {
1292 1 return;
1293 }
1294
2/2
✓ Branch 0 (856→857) taken 1 times.
✓ Branch 1 (856→858) taken 571 times.
2/2
✓ Fully covered.
572 else if ( ++x == number ) {
1295 1 return;
1296 }
1297
2/2
✓ Branch 0 (858→859) taken 1 times.
✓ Branch 1 (858→860) taken 570 times.
2/2
✓ Fully covered.
571 else if ( ++x == number ) {
1298 1 return;
1299 }
1300
2/2
✓ Branch 0 (860→861) taken 1 times.
✓ Branch 1 (860→862) taken 569 times.
2/2
✓ Fully covered.
570 else if ( ++x == number ) {
1301 1 return;
1302 }
1303
2/2
✓ Branch 0 (862→863) taken 1 times.
✓ Branch 1 (862→864) taken 568 times.
2/2
✓ Fully covered.
569 else if ( ++x == number ) {
1304 1 return;
1305 }
1306
2/2
✓ Branch 0 (864→865) taken 1 times.
✓ Branch 1 (864→866) taken 567 times.
2/2
✓ Fully covered.
568 else if ( ++x == number ) {
1307 1 return;
1308 }
1309
2/2
✓ Branch 0 (866→867) taken 1 times.
✓ Branch 1 (866→868) taken 566 times.
2/2
✓ Fully covered.
567 else if ( ++x == number ) {
1310 1 return;
1311 }
1312
2/2
✓ Branch 0 (868→869) taken 1 times.
✓ Branch 1 (868→870) taken 565 times.
2/2
✓ Fully covered.
566 else if ( ++x == number ) {
1313 1 return;
1314 }
1315
2/2
✓ Branch 0 (870→871) taken 1 times.
✓ Branch 1 (870→872) taken 564 times.
2/2
✓ Fully covered.
565 else if ( ++x == number ) {
1316 1 return;
1317 }
1318
2/2
✓ Branch 0 (872→873) taken 1 times.
✓ Branch 1 (872→874) taken 563 times.
2/2
✓ Fully covered.
564 else if ( ++x == number ) {
1319 1 return;
1320 }
1321
2/2
✓ Branch 0 (874→875) taken 1 times.
✓ Branch 1 (874→876) taken 562 times.
2/2
✓ Fully covered.
563 else if ( ++x == number ) {
1322 1 return;
1323 }
1324
2/2
✓ Branch 0 (876→877) taken 1 times.
✓ Branch 1 (876→878) taken 561 times.
2/2
✓ Fully covered.
562 else if ( ++x == number ) {
1325 1 return;
1326 }
1327
2/2
✓ Branch 0 (878→879) taken 1 times.
✓ Branch 1 (878→880) taken 560 times.
2/2
✓ Fully covered.
561 else if ( ++x == number ) {
1328 1 return;
1329 }
1330
2/2
✓ Branch 0 (880→881) taken 1 times.
✓ Branch 1 (880→882) taken 559 times.
2/2
✓ Fully covered.
560 else if ( ++x == number ) {
1331 1 return;
1332 }
1333
2/2
✓ Branch 0 (882→883) taken 1 times.
✓ Branch 1 (882→884) taken 558 times.
2/2
✓ Fully covered.
559 else if ( ++x == number ) {
1334 1 return;
1335 }
1336
2/2
✓ Branch 0 (884→885) taken 1 times.
✓ Branch 1 (884→886) taken 557 times.
2/2
✓ Fully covered.
558 else if ( ++x == number ) {
1337 1 return;
1338 }
1339
2/2
✓ Branch 0 (886→887) taken 1 times.
✓ Branch 1 (886→888) taken 556 times.
2/2
✓ Fully covered.
557 else if ( ++x == number ) {
1340 1 return;
1341 }
1342
2/2
✓ Branch 0 (888→889) taken 1 times.
✓ Branch 1 (888→890) taken 555 times.
2/2
✓ Fully covered.
556 else if ( ++x == number ) {
1343 1 return;
1344 }
1345
2/2
✓ Branch 0 (890→891) taken 1 times.
✓ Branch 1 (890→892) taken 554 times.
2/2
✓ Fully covered.
555 else if ( ++x == number ) {
1346 1 return;
1347 }
1348
2/2
✓ Branch 0 (892→893) taken 1 times.
✓ Branch 1 (892→894) taken 553 times.
2/2
✓ Fully covered.
554 else if ( ++x == number ) {
1349 1 return;
1350 }
1351
2/2
✓ Branch 0 (894→895) taken 1 times.
✓ Branch 1 (894→896) taken 552 times.
2/2
✓ Fully covered.
553 else if ( ++x == number ) {
1352 1 return;
1353 }
1354
2/2
✓ Branch 0 (896→897) taken 1 times.
✓ Branch 1 (896→898) taken 551 times.
2/2
✓ Fully covered.
552 else if ( ++x == number ) {
1355 1 return;
1356 }
1357
2/2
✓ Branch 0 (898→899) taken 1 times.
✓ Branch 1 (898→900) taken 550 times.
2/2
✓ Fully covered.
551 else if ( ++x == number ) {
1358 1 return;
1359 }
1360
2/2
✓ Branch 0 (900→901) taken 1 times.
✓ Branch 1 (900→902) taken 549 times.
2/2
✓ Fully covered.
550 else if ( ++x == number ) {
1361 1 return;
1362 }
1363
2/2
✓ Branch 0 (902→903) taken 1 times.
✓ Branch 1 (902→904) taken 548 times.
2/2
✓ Fully covered.
549 else if ( ++x == number ) {
1364 1 return;
1365 }
1366
2/2
✓ Branch 0 (904→905) taken 1 times.
✓ Branch 1 (904→906) taken 547 times.
2/2
✓ Fully covered.
548 else if ( ++x == number ) {
1367 1 return;
1368 }
1369
2/2
✓ Branch 0 (906→907) taken 1 times.
✓ Branch 1 (906→908) taken 546 times.
2/2
✓ Fully covered.
547 else if ( ++x == number ) {
1370 1 return;
1371 }
1372
2/2
✓ Branch 0 (908→909) taken 1 times.
✓ Branch 1 (908→910) taken 545 times.
2/2
✓ Fully covered.
546 else if ( ++x == number ) {
1373 1 return;
1374 }
1375
2/2
✓ Branch 0 (910→911) taken 1 times.
✓ Branch 1 (910→912) taken 544 times.
2/2
✓ Fully covered.
545 else if ( ++x == number ) {
1376 1 return;
1377 }
1378
2/2
✓ Branch 0 (912→913) taken 1 times.
✓ Branch 1 (912→914) taken 543 times.
2/2
✓ Fully covered.
544 else if ( ++x == number ) {
1379 1 return;
1380 }
1381
2/2
✓ Branch 0 (914→915) taken 1 times.
✓ Branch 1 (914→916) taken 542 times.
2/2
✓ Fully covered.
543 else if ( ++x == number ) {
1382 1 return;
1383 }
1384
2/2
✓ Branch 0 (916→917) taken 1 times.
✓ Branch 1 (916→918) taken 541 times.
2/2
✓ Fully covered.
542 else if ( ++x == number ) {
1385 1 return;
1386 }
1387
2/2
✓ Branch 0 (918→919) taken 1 times.
✓ Branch 1 (918→920) taken 540 times.
2/2
✓ Fully covered.
541 else if ( ++x == number ) {
1388 1 return;
1389 }
1390
2/2
✓ Branch 0 (920→921) taken 1 times.
✓ Branch 1 (920→922) taken 539 times.
2/2
✓ Fully covered.
540 else if ( ++x == number ) {
1391 1 return;
1392 }
1393
2/2
✓ Branch 0 (922→923) taken 1 times.
✓ Branch 1 (922→924) taken 538 times.
2/2
✓ Fully covered.
539 else if ( ++x == number ) {
1394 1 return;
1395 }
1396
2/2
✓ Branch 0 (924→925) taken 1 times.
✓ Branch 1 (924→926) taken 537 times.
2/2
✓ Fully covered.
538 else if ( ++x == number ) {
1397 1 return;
1398 }
1399
2/2
✓ Branch 0 (926→927) taken 1 times.
✓ Branch 1 (926→928) taken 536 times.
2/2
✓ Fully covered.
537 else if ( ++x == number ) {
1400 1 return;
1401 }
1402
2/2
✓ Branch 0 (928→929) taken 1 times.
✓ Branch 1 (928→930) taken 535 times.
2/2
✓ Fully covered.
536 else if ( ++x == number ) {
1403 1 return;
1404 }
1405
2/2
✓ Branch 0 (930→931) taken 1 times.
✓ Branch 1 (930→932) taken 534 times.
2/2
✓ Fully covered.
535 else if ( ++x == number ) {
1406 1 return;
1407 }
1408
2/2
✓ Branch 0 (932→933) taken 1 times.
✓ Branch 1 (932→934) taken 533 times.
2/2
✓ Fully covered.
534 else if ( ++x == number ) {
1409 1 return;
1410 }
1411
2/2
✓ Branch 0 (934→935) taken 1 times.
✓ Branch 1 (934→936) taken 532 times.
2/2
✓ Fully covered.
533 else if ( ++x == number ) {
1412 1 return;
1413 }
1414
2/2
✓ Branch 0 (936→937) taken 1 times.
✓ Branch 1 (936→938) taken 531 times.
2/2
✓ Fully covered.
532 else if ( ++x == number ) {
1415 1 return;
1416 }
1417
2/2
✓ Branch 0 (938→939) taken 1 times.
✓ Branch 1 (938→940) taken 530 times.
2/2
✓ Fully covered.
531 else if ( ++x == number ) {
1418 1 return;
1419 }
1420
2/2
✓ Branch 0 (940→941) taken 1 times.
✓ Branch 1 (940→942) taken 529 times.
2/2
✓ Fully covered.
530 else if ( ++x == number ) {
1421 1 return;
1422 }
1423
2/2
✓ Branch 0 (942→943) taken 1 times.
✓ Branch 1 (942→944) taken 528 times.
2/2
✓ Fully covered.
529 else if ( ++x == number ) {
1424 1 return;
1425 }
1426
2/2
✓ Branch 0 (944→945) taken 1 times.
✓ Branch 1 (944→946) taken 527 times.
2/2
✓ Fully covered.
528 else if ( ++x == number ) {
1427 1 return;
1428 }
1429
2/2
✓ Branch 0 (946→947) taken 1 times.
✓ Branch 1 (946→948) taken 526 times.
2/2
✓ Fully covered.
527 else if ( ++x == number ) {
1430 1 return;
1431 }
1432
2/2
✓ Branch 0 (948→949) taken 1 times.
✓ Branch 1 (948→950) taken 525 times.
2/2
✓ Fully covered.
526 else if ( ++x == number ) {
1433 1 return;
1434 }
1435
2/2
✓ Branch 0 (950→951) taken 1 times.
✓ Branch 1 (950→952) taken 524 times.
2/2
✓ Fully covered.
525 else if ( ++x == number ) {
1436 1 return;
1437 }
1438
2/2
✓ Branch 0 (952→953) taken 1 times.
✓ Branch 1 (952→954) taken 523 times.
2/2
✓ Fully covered.
524 else if ( ++x == number ) {
1439 1 return;
1440 }
1441
2/2
✓ Branch 0 (954→955) taken 1 times.
✓ Branch 1 (954→956) taken 522 times.
2/2
✓ Fully covered.
523 else if ( ++x == number ) {
1442 1 return;
1443 }
1444
2/2
✓ Branch 0 (956→957) taken 1 times.
✓ Branch 1 (956→958) taken 521 times.
2/2
✓ Fully covered.
522 else if ( ++x == number ) {
1445 1 return;
1446 }
1447
2/2
✓ Branch 0 (958→959) taken 1 times.
✓ Branch 1 (958→960) taken 520 times.
2/2
✓ Fully covered.
521 else if ( ++x == number ) {
1448 1 return;
1449 }
1450
2/2
✓ Branch 0 (960→961) taken 1 times.
✓ Branch 1 (960→962) taken 519 times.
2/2
✓ Fully covered.
520 else if ( ++x == number ) {
1451 1 return;
1452 }
1453
2/2
✓ Branch 0 (962→963) taken 1 times.
✓ Branch 1 (962→964) taken 518 times.
2/2
✓ Fully covered.
519 else if ( ++x == number ) {
1454 1 return;
1455 }
1456
2/2
✓ Branch 0 (964→965) taken 1 times.
✓ Branch 1 (964→966) taken 517 times.
2/2
✓ Fully covered.
518 else if ( ++x == number ) {
1457 1 return;
1458 }
1459
2/2
✓ Branch 0 (966→967) taken 1 times.
✓ Branch 1 (966→968) taken 516 times.
2/2
✓ Fully covered.
517 else if ( ++x == number ) {
1460 1 return;
1461 }
1462
2/2
✓ Branch 0 (968→969) taken 1 times.
✓ Branch 1 (968→970) taken 515 times.
2/2
✓ Fully covered.
516 else if ( ++x == number ) {
1463 1 return;
1464 }
1465
2/2
✓ Branch 0 (970→971) taken 1 times.
✓ Branch 1 (970→972) taken 514 times.
2/2
✓ Fully covered.
515 else if ( ++x == number ) {
1466 1 return;
1467 }
1468
2/2
✓ Branch 0 (972→973) taken 1 times.
✓ Branch 1 (972→974) taken 513 times.
2/2
✓ Fully covered.
514 else if ( ++x == number ) {
1469 1 return;
1470 }
1471
2/2
✓ Branch 0 (974→975) taken 1 times.
✓ Branch 1 (974→976) taken 512 times.
2/2
✓ Fully covered.
513 else if ( ++x == number ) {
1472 1 return;
1473 }
1474
2/2
✓ Branch 0 (976→977) taken 1 times.
✓ Branch 1 (976→978) taken 511 times.
2/2
✓ Fully covered.
512 else if ( ++x == number ) {
1475 1 return;
1476 }
1477
2/2
✓ Branch 0 (978→979) taken 1 times.
✓ Branch 1 (978→980) taken 510 times.
2/2
✓ Fully covered.
511 else if ( ++x == number ) {
1478 1 return;
1479 }
1480
2/2
✓ Branch 0 (980→981) taken 1 times.
✓ Branch 1 (980→982) taken 509 times.
2/2
✓ Fully covered.
510 else if ( ++x == number ) {
1481 1 return;
1482 }
1483
2/2
✓ Branch 0 (982→983) taken 1 times.
✓ Branch 1 (982→984) taken 508 times.
2/2
✓ Fully covered.
509 else if ( ++x == number ) {
1484 1 return;
1485 }
1486
2/2
✓ Branch 0 (984→985) taken 1 times.
✓ Branch 1 (984→986) taken 507 times.
2/2
✓ Fully covered.
508 else if ( ++x == number ) {
1487 1 return;
1488 }
1489
2/2
✓ Branch 0 (986→987) taken 1 times.
✓ Branch 1 (986→988) taken 506 times.
2/2
✓ Fully covered.
507 else if ( ++x == number ) {
1490 1 return;
1491 }
1492
2/2
✓ Branch 0 (988→989) taken 1 times.
✓ Branch 1 (988→990) taken 505 times.
2/2
✓ Fully covered.
506 else if ( ++x == number ) {
1493 1 return;
1494 }
1495
2/2
✓ Branch 0 (990→991) taken 1 times.
✓ Branch 1 (990→992) taken 504 times.
2/2
✓ Fully covered.
505 else if ( ++x == number ) {
1496 1 return;
1497 }
1498
2/2
✓ Branch 0 (992→993) taken 1 times.
✓ Branch 1 (992→994) taken 503 times.
2/2
✓ Fully covered.
504 else if ( ++x == number ) {
1499 1 return;
1500 }
1501
2/2
✓ Branch 0 (994→995) taken 1 times.
✓ Branch 1 (994→996) taken 502 times.
2/2
✓ Fully covered.
503 else if ( ++x == number ) {
1502 1 return;
1503 }
1504
2/2
✓ Branch 0 (996→997) taken 1 times.
✓ Branch 1 (996→998) taken 501 times.
2/2
✓ Fully covered.
502 else if ( ++x == number ) {
1505 1 return;
1506 }
1507
2/2
✓ Branch 0 (998→999) taken 1 times.
✓ Branch 1 (998→1000) taken 500 times.
2/2
✓ Fully covered.
501 else if ( ++x == number ) {
1508 1 return;
1509 }
1510
2/2
✓ Branch 0 (1000→1001) taken 1 times.
✓ Branch 1 (1000→1002) taken 499 times.
2/2
✓ Fully covered.
500 else if ( ++x == number ) {
1511 1 return;
1512 }
1513
2/2
✓ Branch 0 (1002→1003) taken 1 times.
✓ Branch 1 (1002→1004) taken 498 times.
2/2
✓ Fully covered.
499 else if ( ++x == number ) {
1514 1 return;
1515 }
1516
2/2
✓ Branch 0 (1004→1005) taken 1 times.
✓ Branch 1 (1004→1006) taken 497 times.
2/2
✓ Fully covered.
498 else if ( ++x == number ) {
1517 1 return;
1518 }
1519
2/2
✓ Branch 0 (1006→1007) taken 1 times.
✓ Branch 1 (1006→1008) taken 496 times.
2/2
✓ Fully covered.
497 else if ( ++x == number ) {
1520 1 return;
1521 }
1522
2/2
✓ Branch 0 (1008→1009) taken 1 times.
✓ Branch 1 (1008→1010) taken 495 times.
2/2
✓ Fully covered.
496 else if ( ++x == number ) {
1523 1 return;
1524 }
1525
2/2
✓ Branch 0 (1010→1011) taken 1 times.
✓ Branch 1 (1010→1012) taken 494 times.
2/2
✓ Fully covered.
495 else if ( ++x == number ) {
1526 1 return;
1527 }
1528
2/2
✓ Branch 0 (1012→1013) taken 1 times.
✓ Branch 1 (1012→1014) taken 493 times.
2/2
✓ Fully covered.
494 else if ( ++x == number ) {
1529 1 return;
1530 }
1531
2/2
✓ Branch 0 (1014→1015) taken 1 times.
✓ Branch 1 (1014→1016) taken 492 times.
2/2
✓ Fully covered.
493 else if ( ++x == number ) {
1532 1 return;
1533 }
1534
2/2
✓ Branch 0 (1016→1017) taken 1 times.
✓ Branch 1 (1016→1018) taken 491 times.
2/2
✓ Fully covered.
492 else if ( ++x == number ) {
1535 1 return;
1536 }
1537
2/2
✓ Branch 0 (1018→1019) taken 1 times.
✓ Branch 1 (1018→1020) taken 490 times.
2/2
✓ Fully covered.
491 else if ( ++x == number ) {
1538 1 return;
1539 }
1540
2/2
✓ Branch 0 (1020→1021) taken 1 times.
✓ Branch 1 (1020→1022) taken 489 times.
2/2
✓ Fully covered.
490 else if ( ++x == number ) {
1541 1 return;
1542 }
1543
2/2
✓ Branch 0 (1022→1023) taken 1 times.
✓ Branch 1 (1022→1024) taken 488 times.
2/2
✓ Fully covered.
489 else if ( ++x == number ) {
1544 1 return;
1545 }
1546
2/2
✓ Branch 0 (1024→1025) taken 1 times.
✓ Branch 1 (1024→1026) taken 487 times.
2/2
✓ Fully covered.
488 else if ( ++x == number ) {
1547 1 return;
1548 }
1549
2/2
✓ Branch 0 (1026→1027) taken 1 times.
✓ Branch 1 (1026→1028) taken 486 times.
2/2
✓ Fully covered.
487 else if ( ++x == number ) {
1550 1 return;
1551 }
1552
2/2
✓ Branch 0 (1028→1029) taken 1 times.
✓ Branch 1 (1028→1030) taken 485 times.
2/2
✓ Fully covered.
486 else if ( ++x == number ) {
1553 1 return;
1554 }
1555
2/2
✓ Branch 0 (1030→1031) taken 1 times.
✓ Branch 1 (1030→1032) taken 484 times.
2/2
✓ Fully covered.
485 else if ( ++x == number ) {
1556 1 return;
1557 }
1558
2/2
✓ Branch 0 (1032→1033) taken 1 times.
✓ Branch 1 (1032→1034) taken 483 times.
2/2
✓ Fully covered.
484 else if ( ++x == number ) {
1559 1 return;
1560 }
1561
2/2
✓ Branch 0 (1034→1035) taken 1 times.
✓ Branch 1 (1034→1036) taken 482 times.
2/2
✓ Fully covered.
483 else if ( ++x == number ) {
1562 1 return;
1563 }
1564
2/2
✓ Branch 0 (1036→1037) taken 1 times.
✓ Branch 1 (1036→1038) taken 481 times.
2/2
✓ Fully covered.
482 else if ( ++x == number ) {
1565 1 return;
1566 }
1567
2/2
✓ Branch 0 (1038→1039) taken 1 times.
✓ Branch 1 (1038→1040) taken 480 times.
2/2
✓ Fully covered.
481 else if ( ++x == number ) {
1568 1 return;
1569 }
1570
2/2
✓ Branch 0 (1040→1041) taken 1 times.
✓ Branch 1 (1040→1042) taken 479 times.
2/2
✓ Fully covered.
480 else if ( ++x == number ) {
1571 1 return;
1572 }
1573
2/2
✓ Branch 0 (1042→1043) taken 1 times.
✓ Branch 1 (1042→1044) taken 478 times.
2/2
✓ Fully covered.
479 else if ( ++x == number ) {
1574 1 return;
1575 }
1576
2/2
✓ Branch 0 (1044→1045) taken 1 times.
✓ Branch 1 (1044→1046) taken 477 times.
2/2
✓ Fully covered.
478 else if ( ++x == number ) {
1577 1 return;
1578 }
1579
2/2
✓ Branch 0 (1046→1047) taken 1 times.
✓ Branch 1 (1046→1048) taken 476 times.
2/2
✓ Fully covered.
477 else if ( ++x == number ) {
1580 1 return;
1581 }
1582
2/2
✓ Branch 0 (1048→1049) taken 1 times.
✓ Branch 1 (1048→1050) taken 475 times.
2/2
✓ Fully covered.
476 else if ( ++x == number ) {
1583 1 return;
1584 }
1585
2/2
✓ Branch 0 (1050→1051) taken 1 times.
✓ Branch 1 (1050→1052) taken 474 times.
2/2
✓ Fully covered.
475 else if ( ++x == number ) {
1586 1 return;
1587 }
1588
2/2
✓ Branch 0 (1052→1053) taken 1 times.
✓ Branch 1 (1052→1054) taken 473 times.
2/2
✓ Fully covered.
474 else if ( ++x == number ) {
1589 1 return;
1590 }
1591
2/2
✓ Branch 0 (1054→1055) taken 1 times.
✓ Branch 1 (1054→1056) taken 472 times.
2/2
✓ Fully covered.
473 else if ( ++x == number ) {
1592 1 return;
1593 }
1594
2/2
✓ Branch 0 (1056→1057) taken 1 times.
✓ Branch 1 (1056→1058) taken 471 times.
2/2
✓ Fully covered.
472 else if ( ++x == number ) {
1595 1 return;
1596 }
1597
2/2
✓ Branch 0 (1058→1059) taken 1 times.
✓ Branch 1 (1058→1060) taken 470 times.
2/2
✓ Fully covered.
471 else if ( ++x == number ) {
1598 1 return;
1599 }
1600
2/2
✓ Branch 0 (1060→1061) taken 1 times.
✓ Branch 1 (1060→1062) taken 469 times.
2/2
✓ Fully covered.
470 else if ( ++x == number ) {
1601 1 return;
1602 }
1603
2/2
✓ Branch 0 (1062→1063) taken 1 times.
✓ Branch 1 (1062→1064) taken 468 times.
2/2
✓ Fully covered.
469 else if ( ++x == number ) {
1604 1 return;
1605 }
1606
2/2
✓ Branch 0 (1064→1065) taken 1 times.
✓ Branch 1 (1064→1066) taken 467 times.
2/2
✓ Fully covered.
468 else if ( ++x == number ) {
1607 1 return;
1608 }
1609
2/2
✓ Branch 0 (1066→1067) taken 1 times.
✓ Branch 1 (1066→1068) taken 466 times.
2/2
✓ Fully covered.
467 else if ( ++x == number ) {
1610 1 return;
1611 }
1612
2/2
✓ Branch 0 (1068→1069) taken 1 times.
✓ Branch 1 (1068→1070) taken 465 times.
2/2
✓ Fully covered.
466 else if ( ++x == number ) {
1613 1 return;
1614 }
1615
2/2
✓ Branch 0 (1070→1071) taken 1 times.
✓ Branch 1 (1070→1072) taken 464 times.
2/2
✓ Fully covered.
465 else if ( ++x == number ) {
1616 1 return;
1617 }
1618
2/2
✓ Branch 0 (1072→1073) taken 1 times.
✓ Branch 1 (1072→1074) taken 463 times.
2/2
✓ Fully covered.
464 else if ( ++x == number ) {
1619 1 return;
1620 }
1621
2/2
✓ Branch 0 (1074→1075) taken 1 times.
✓ Branch 1 (1074→1076) taken 462 times.
2/2
✓ Fully covered.
463 else if ( ++x == number ) {
1622 1 return;
1623 }
1624
2/2
✓ Branch 0 (1076→1077) taken 1 times.
✓ Branch 1 (1076→1078) taken 461 times.
2/2
✓ Fully covered.
462 else if ( ++x == number ) {
1625 1 return;
1626 }
1627
2/2
✓ Branch 0 (1078→1079) taken 1 times.
✓ Branch 1 (1078→1080) taken 460 times.
2/2
✓ Fully covered.
461 else if ( ++x == number ) {
1628 1 return;
1629 }
1630
2/2
✓ Branch 0 (1080→1081) taken 1 times.
✓ Branch 1 (1080→1082) taken 459 times.
2/2
✓ Fully covered.
460 else if ( ++x == number ) {
1631 1 return;
1632 }
1633
2/2
✓ Branch 0 (1082→1083) taken 1 times.
✓ Branch 1 (1082→1084) taken 458 times.
2/2
✓ Fully covered.
459 else if ( ++x == number ) {
1634 1 return;
1635 }
1636
2/2
✓ Branch 0 (1084→1085) taken 1 times.
✓ Branch 1 (1084→1086) taken 457 times.
2/2
✓ Fully covered.
458 else if ( ++x == number ) {
1637 1 return;
1638 }
1639
2/2
✓ Branch 0 (1086→1087) taken 1 times.
✓ Branch 1 (1086→1088) taken 456 times.
2/2
✓ Fully covered.
457 else if ( ++x == number ) {
1640 1 return;
1641 }
1642
2/2
✓ Branch 0 (1088→1089) taken 1 times.
✓ Branch 1 (1088→1090) taken 455 times.
2/2
✓ Fully covered.
456 else if ( ++x == number ) {
1643 1 return;
1644 }
1645
2/2
✓ Branch 0 (1090→1091) taken 1 times.
✓ Branch 1 (1090→1092) taken 454 times.
2/2
✓ Fully covered.
455 else if ( ++x == number ) {
1646 1 return;
1647 }
1648
2/2
✓ Branch 0 (1092→1093) taken 1 times.
✓ Branch 1 (1092→1094) taken 453 times.
2/2
✓ Fully covered.
454 else if ( ++x == number ) {
1649 1 return;
1650 }
1651
2/2
✓ Branch 0 (1094→1095) taken 1 times.
✓ Branch 1 (1094→1096) taken 452 times.
2/2
✓ Fully covered.
453 else if ( ++x == number ) {
1652 1 return;
1653 }
1654
2/2
✓ Branch 0 (1096→1097) taken 1 times.
✓ Branch 1 (1096→1098) taken 451 times.
2/2
✓ Fully covered.
452 else if ( ++x == number ) {
1655 1 return;
1656 }
1657
2/2
✓ Branch 0 (1098→1099) taken 1 times.
✓ Branch 1 (1098→1100) taken 450 times.
2/2
✓ Fully covered.
451 else if ( ++x == number ) {
1658 1 return;
1659 }
1660
2/2
✓ Branch 0 (1100→1101) taken 1 times.
✓ Branch 1 (1100→1102) taken 449 times.
2/2
✓ Fully covered.
450 else if ( ++x == number ) {
1661 1 return;
1662 }
1663
2/2
✓ Branch 0 (1102→1103) taken 1 times.
✓ Branch 1 (1102→1104) taken 448 times.
2/2
✓ Fully covered.
449 else if ( ++x == number ) {
1664 1 return;
1665 }
1666
2/2
✓ Branch 0 (1104→1105) taken 1 times.
✓ Branch 1 (1104→1106) taken 447 times.
2/2
✓ Fully covered.
448 else if ( ++x == number ) {
1667 1 return;
1668 }
1669
2/2
✓ Branch 0 (1106→1107) taken 1 times.
✓ Branch 1 (1106→1108) taken 446 times.
2/2
✓ Fully covered.
447 else if ( ++x == number ) {
1670 1 return;
1671 }
1672
2/2
✓ Branch 0 (1108→1109) taken 1 times.
✓ Branch 1 (1108→1110) taken 445 times.
2/2
✓ Fully covered.
446 else if ( ++x == number ) {
1673 1 return;
1674 }
1675
2/2
✓ Branch 0 (1110→1111) taken 1 times.
✓ Branch 1 (1110→1112) taken 444 times.
2/2
✓ Fully covered.
445 else if ( ++x == number ) {
1676 1 return;
1677 }
1678
2/2
✓ Branch 0 (1112→1113) taken 1 times.
✓ Branch 1 (1112→1114) taken 443 times.
2/2
✓ Fully covered.
444 else if ( ++x == number ) {
1679 1 return;
1680 }
1681
2/2
✓ Branch 0 (1114→1115) taken 1 times.
✓ Branch 1 (1114→1116) taken 442 times.
2/2
✓ Fully covered.
443 else if ( ++x == number ) {
1682 1 return;
1683 }
1684
2/2
✓ Branch 0 (1116→1117) taken 1 times.
✓ Branch 1 (1116→1118) taken 441 times.
2/2
✓ Fully covered.
442 else if ( ++x == number ) {
1685 1 return;
1686 }
1687
2/2
✓ Branch 0 (1118→1119) taken 1 times.
✓ Branch 1 (1118→1120) taken 440 times.
2/2
✓ Fully covered.
441 else if ( ++x == number ) {
1688 1 return;
1689 }
1690
2/2
✓ Branch 0 (1120→1121) taken 1 times.
✓ Branch 1 (1120→1122) taken 439 times.
2/2
✓ Fully covered.
440 else if ( ++x == number ) {
1691 1 return;
1692 }
1693
2/2
✓ Branch 0 (1122→1123) taken 1 times.
✓ Branch 1 (1122→1124) taken 438 times.
2/2
✓ Fully covered.
439 else if ( ++x == number ) {
1694 1 return;
1695 }
1696
2/2
✓ Branch 0 (1124→1125) taken 1 times.
✓ Branch 1 (1124→1126) taken 437 times.
2/2
✓ Fully covered.
438 else if ( ++x == number ) {
1697 1 return;
1698 }
1699
2/2
✓ Branch 0 (1126→1127) taken 1 times.
✓ Branch 1 (1126→1128) taken 436 times.
2/2
✓ Fully covered.
437 else if ( ++x == number ) {
1700 1 return;
1701 }
1702
2/2
✓ Branch 0 (1128→1129) taken 1 times.
✓ Branch 1 (1128→1130) taken 435 times.
2/2
✓ Fully covered.
436 else if ( ++x == number ) {
1703 1 return;
1704 }
1705
2/2
✓ Branch 0 (1130→1131) taken 1 times.
✓ Branch 1 (1130→1132) taken 434 times.
2/2
✓ Fully covered.
435 else if ( ++x == number ) {
1706 1 return;
1707 }
1708
2/2
✓ Branch 0 (1132→1133) taken 1 times.
✓ Branch 1 (1132→1134) taken 433 times.
2/2
✓ Fully covered.
434 else if ( ++x == number ) {
1709 1 return;
1710 }
1711
2/2
✓ Branch 0 (1134→1135) taken 1 times.
✓ Branch 1 (1134→1136) taken 432 times.
2/2
✓ Fully covered.
433 else if ( ++x == number ) {
1712 1 return;
1713 }
1714
2/2
✓ Branch 0 (1136→1137) taken 1 times.
✓ Branch 1 (1136→1138) taken 431 times.
2/2
✓ Fully covered.
432 else if ( ++x == number ) {
1715 1 return;
1716 }
1717
2/2
✓ Branch 0 (1138→1139) taken 1 times.
✓ Branch 1 (1138→1140) taken 430 times.
2/2
✓ Fully covered.
431 else if ( ++x == number ) {
1718 1 return;
1719 }
1720
2/2
✓ Branch 0 (1140→1141) taken 1 times.
✓ Branch 1 (1140→1142) taken 429 times.
2/2
✓ Fully covered.
430 else if ( ++x == number ) {
1721 1 return;
1722 }
1723
2/2
✓ Branch 0 (1142→1143) taken 1 times.
✓ Branch 1 (1142→1144) taken 428 times.
2/2
✓ Fully covered.
429 else if ( ++x == number ) {
1724 1 return;
1725 }
1726
2/2
✓ Branch 0 (1144→1145) taken 1 times.
✓ Branch 1 (1144→1146) taken 427 times.
2/2
✓ Fully covered.
428 else if ( ++x == number ) {
1727 1 return;
1728 }
1729
2/2
✓ Branch 0 (1146→1147) taken 1 times.
✓ Branch 1 (1146→1148) taken 426 times.
2/2
✓ Fully covered.
427 else if ( ++x == number ) {
1730 1 return;
1731 }
1732
2/2
✓ Branch 0 (1148→1149) taken 1 times.
✓ Branch 1 (1148→1150) taken 425 times.
2/2
✓ Fully covered.
426 else if ( ++x == number ) {
1733 1 return;
1734 }
1735
2/2
✓ Branch 0 (1150→1151) taken 1 times.
✓ Branch 1 (1150→1152) taken 424 times.
2/2
✓ Fully covered.
425 else if ( ++x == number ) {
1736 1 return;
1737 }
1738
2/2
✓ Branch 0 (1152→1153) taken 1 times.
✓ Branch 1 (1152→1154) taken 423 times.
2/2
✓ Fully covered.
424 else if ( ++x == number ) {
1739 1 return;
1740 }
1741
2/2
✓ Branch 0 (1154→1155) taken 1 times.
✓ Branch 1 (1154→1156) taken 422 times.
2/2
✓ Fully covered.
423 else if ( ++x == number ) {
1742 1 return;
1743 }
1744
2/2
✓ Branch 0 (1156→1157) taken 1 times.
✓ Branch 1 (1156→1158) taken 421 times.
2/2
✓ Fully covered.
422 else if ( ++x == number ) {
1745 1 return;
1746 }
1747
2/2
✓ Branch 0 (1158→1159) taken 1 times.
✓ Branch 1 (1158→1160) taken 420 times.
2/2
✓ Fully covered.
421 else if ( ++x == number ) {
1748 1 return;
1749 }
1750
2/2
✓ Branch 0 (1160→1161) taken 1 times.
✓ Branch 1 (1160→1162) taken 419 times.
2/2
✓ Fully covered.
420 else if ( ++x == number ) {
1751 1 return;
1752 }
1753
2/2
✓ Branch 0 (1162→1163) taken 1 times.
✓ Branch 1 (1162→1164) taken 418 times.
2/2
✓ Fully covered.
419 else if ( ++x == number ) {
1754 1 return;
1755 }
1756
2/2
✓ Branch 0 (1164→1165) taken 1 times.
✓ Branch 1 (1164→1166) taken 417 times.
2/2
✓ Fully covered.
418 else if ( ++x == number ) {
1757 1 return;
1758 }
1759
2/2
✓ Branch 0 (1166→1167) taken 1 times.
✓ Branch 1 (1166→1168) taken 416 times.
2/2
✓ Fully covered.
417 else if ( ++x == number ) {
1760 1 return;
1761 }
1762
2/2
✓ Branch 0 (1168→1169) taken 1 times.
✓ Branch 1 (1168→1170) taken 415 times.
2/2
✓ Fully covered.
416 else if ( ++x == number ) {
1763 1 return;
1764 }
1765
2/2
✓ Branch 0 (1170→1171) taken 1 times.
✓ Branch 1 (1170→1172) taken 414 times.
2/2
✓ Fully covered.
415 else if ( ++x == number ) {
1766 1 return;
1767 }
1768
2/2
✓ Branch 0 (1172→1173) taken 1 times.
✓ Branch 1 (1172→1174) taken 413 times.
2/2
✓ Fully covered.
414 else if ( ++x == number ) {
1769 1 return;
1770 }
1771
2/2
✓ Branch 0 (1174→1175) taken 1 times.
✓ Branch 1 (1174→1176) taken 412 times.
2/2
✓ Fully covered.
413 else if ( ++x == number ) {
1772 1 return;
1773 }
1774
2/2
✓ Branch 0 (1176→1177) taken 1 times.
✓ Branch 1 (1176→1178) taken 411 times.
2/2
✓ Fully covered.
412 else if ( ++x == number ) {
1775 1 return;
1776 }
1777
2/2
✓ Branch 0 (1178→1179) taken 1 times.
✓ Branch 1 (1178→1180) taken 410 times.
2/2
✓ Fully covered.
411 else if ( ++x == number ) {
1778 1 return;
1779 }
1780
2/2
✓ Branch 0 (1180→1181) taken 1 times.
✓ Branch 1 (1180→1182) taken 409 times.
2/2
✓ Fully covered.
410 else if ( ++x == number ) {
1781 1 return;
1782 }
1783
2/2
✓ Branch 0 (1182→1183) taken 1 times.
✓ Branch 1 (1182→1184) taken 408 times.
2/2
✓ Fully covered.
409 else if ( ++x == number ) {
1784 1 return;
1785 }
1786
2/2
✓ Branch 0 (1184→1185) taken 1 times.
✓ Branch 1 (1184→1186) taken 407 times.
2/2
✓ Fully covered.
408 else if ( ++x == number ) {
1787 1 return;
1788 }
1789
2/2
✓ Branch 0 (1186→1187) taken 1 times.
✓ Branch 1 (1186→1188) taken 406 times.
2/2
✓ Fully covered.
407 else if ( ++x == number ) {
1790 1 return;
1791 }
1792
2/2
✓ Branch 0 (1188→1189) taken 1 times.
✓ Branch 1 (1188→1190) taken 405 times.
2/2
✓ Fully covered.
406 else if ( ++x == number ) {
1793 1 return;
1794 }
1795
2/2
✓ Branch 0 (1190→1191) taken 1 times.
✓ Branch 1 (1190→1192) taken 404 times.
2/2
✓ Fully covered.
405 else if ( ++x == number ) {
1796 1 return;
1797 }
1798
2/2
✓ Branch 0 (1192→1193) taken 1 times.
✓ Branch 1 (1192→1194) taken 403 times.
2/2
✓ Fully covered.
404 else if ( ++x == number ) {
1799 1 return;
1800 }
1801
2/2
✓ Branch 0 (1194→1195) taken 1 times.
✓ Branch 1 (1194→1196) taken 402 times.
2/2
✓ Fully covered.
403 else if ( ++x == number ) {
1802 1 return;
1803 }
1804
2/2
✓ Branch 0 (1196→1197) taken 1 times.
✓ Branch 1 (1196→1198) taken 401 times.
2/2
✓ Fully covered.
402 else if ( ++x == number ) {
1805 1 return;
1806 }
1807
2/2
✓ Branch 0 (1198→1199) taken 1 times.
✓ Branch 1 (1198→1200) taken 400 times.
2/2
✓ Fully covered.
401 else if ( ++x == number ) {
1808 1 return;
1809 }
1810
2/2
✓ Branch 0 (1200→1201) taken 1 times.
✓ Branch 1 (1200→1202) taken 399 times.
2/2
✓ Fully covered.
400 else if ( ++x == number ) {
1811 1 return;
1812 }
1813
2/2
✓ Branch 0 (1202→1203) taken 1 times.
✓ Branch 1 (1202→1204) taken 398 times.
2/2
✓ Fully covered.
399 else if ( ++x == number ) {
1814 1 return;
1815 }
1816
2/2
✓ Branch 0 (1204→1205) taken 1 times.
✓ Branch 1 (1204→1206) taken 397 times.
2/2
✓ Fully covered.
398 else if ( ++x == number ) {
1817 1 return;
1818 }
1819
2/2
✓ Branch 0 (1206→1207) taken 1 times.
✓ Branch 1 (1206→1208) taken 396 times.
2/2
✓ Fully covered.
397 else if ( ++x == number ) {
1820 1 return;
1821 }
1822
2/2
✓ Branch 0 (1208→1209) taken 1 times.
✓ Branch 1 (1208→1210) taken 395 times.
2/2
✓ Fully covered.
396 else if ( ++x == number ) {
1823 1 return;
1824 }
1825
2/2
✓ Branch 0 (1210→1211) taken 1 times.
✓ Branch 1 (1210→1212) taken 394 times.
2/2
✓ Fully covered.
395 else if ( ++x == number ) {
1826 1 return;
1827 }
1828
2/2
✓ Branch 0 (1212→1213) taken 1 times.
✓ Branch 1 (1212→1214) taken 393 times.
2/2
✓ Fully covered.
394 else if ( ++x == number ) {
1829 1 return;
1830 }
1831
2/2
✓ Branch 0 (1214→1215) taken 1 times.
✓ Branch 1 (1214→1216) taken 392 times.
2/2
✓ Fully covered.
393 else if ( ++x == number ) {
1832 1 return;
1833 }
1834
2/2
✓ Branch 0 (1216→1217) taken 1 times.
✓ Branch 1 (1216→1218) taken 391 times.
2/2
✓ Fully covered.
392 else if ( ++x == number ) {
1835 1 return;
1836 }
1837
2/2
✓ Branch 0 (1218→1219) taken 1 times.
✓ Branch 1 (1218→1220) taken 390 times.
2/2
✓ Fully covered.
391 else if ( ++x == number ) {
1838 1 return;
1839 }
1840
2/2
✓ Branch 0 (1220→1221) taken 1 times.
✓ Branch 1 (1220→1222) taken 389 times.
2/2
✓ Fully covered.
390 else if ( ++x == number ) {
1841 1 return;
1842 }
1843
2/2
✓ Branch 0 (1222→1223) taken 1 times.
✓ Branch 1 (1222→1224) taken 388 times.
2/2
✓ Fully covered.
389 else if ( ++x == number ) {
1844 1 return;
1845 }
1846
2/2
✓ Branch 0 (1224→1225) taken 1 times.
✓ Branch 1 (1224→1226) taken 387 times.
2/2
✓ Fully covered.
388 else if ( ++x == number ) {
1847 1 return;
1848 }
1849
2/2
✓ Branch 0 (1226→1227) taken 1 times.
✓ Branch 1 (1226→1228) taken 386 times.
2/2
✓ Fully covered.
387 else if ( ++x == number ) {
1850 1 return;
1851 }
1852
2/2
✓ Branch 0 (1228→1229) taken 1 times.
✓ Branch 1 (1228→1230) taken 385 times.
2/2
✓ Fully covered.
386 else if ( ++x == number ) {
1853 1 return;
1854 }
1855
2/2
✓ Branch 0 (1230→1231) taken 1 times.
✓ Branch 1 (1230→1232) taken 384 times.
2/2
✓ Fully covered.
385 else if ( ++x == number ) {
1856 1 return;
1857 }
1858
2/2
✓ Branch 0 (1232→1233) taken 1 times.
✓ Branch 1 (1232→1234) taken 383 times.
2/2
✓ Fully covered.
384 else if ( ++x == number ) {
1859 1 return;
1860 }
1861
2/2
✓ Branch 0 (1234→1235) taken 1 times.
✓ Branch 1 (1234→1236) taken 382 times.
2/2
✓ Fully covered.
383 else if ( ++x == number ) {
1862 1 return;
1863 }
1864
2/2
✓ Branch 0 (1236→1237) taken 1 times.
✓ Branch 1 (1236→1238) taken 381 times.
2/2
✓ Fully covered.
382 else if ( ++x == number ) {
1865 1 return;
1866 }
1867
2/2
✓ Branch 0 (1238→1239) taken 1 times.
✓ Branch 1 (1238→1240) taken 380 times.
2/2
✓ Fully covered.
381 else if ( ++x == number ) {
1868 1 return;
1869 }
1870
2/2
✓ Branch 0 (1240→1241) taken 1 times.
✓ Branch 1 (1240→1242) taken 379 times.
2/2
✓ Fully covered.
380 else if ( ++x == number ) {
1871 1 return;
1872 }
1873
2/2
✓ Branch 0 (1242→1243) taken 1 times.
✓ Branch 1 (1242→1244) taken 378 times.
2/2
✓ Fully covered.
379 else if ( ++x == number ) {
1874 1 return;
1875 }
1876
2/2
✓ Branch 0 (1244→1245) taken 1 times.
✓ Branch 1 (1244→1246) taken 377 times.
2/2
✓ Fully covered.
378 else if ( ++x == number ) {
1877 1 return;
1878 }
1879
2/2
✓ Branch 0 (1246→1247) taken 1 times.
✓ Branch 1 (1246→1248) taken 376 times.
2/2
✓ Fully covered.
377 else if ( ++x == number ) {
1880 1 return;
1881 }
1882
2/2
✓ Branch 0 (1248→1249) taken 1 times.
✓ Branch 1 (1248→1250) taken 375 times.
2/2
✓ Fully covered.
376 else if ( ++x == number ) {
1883 1 return;
1884 }
1885
2/2
✓ Branch 0 (1250→1251) taken 1 times.
✓ Branch 1 (1250→1252) taken 374 times.
2/2
✓ Fully covered.
375 else if ( ++x == number ) {
1886 1 return;
1887 }
1888
2/2
✓ Branch 0 (1252→1253) taken 1 times.
✓ Branch 1 (1252→1254) taken 373 times.
2/2
✓ Fully covered.
374 else if ( ++x == number ) {
1889 1 return;
1890 }
1891
2/2
✓ Branch 0 (1254→1255) taken 1 times.
✓ Branch 1 (1254→1256) taken 372 times.
2/2
✓ Fully covered.
373 else if ( ++x == number ) {
1892 1 return;
1893 }
1894
2/2
✓ Branch 0 (1256→1257) taken 1 times.
✓ Branch 1 (1256→1258) taken 371 times.
2/2
✓ Fully covered.
372 else if ( ++x == number ) {
1895 1 return;
1896 }
1897
2/2
✓ Branch 0 (1258→1259) taken 1 times.
✓ Branch 1 (1258→1260) taken 370 times.
2/2
✓ Fully covered.
371 else if ( ++x == number ) {
1898 1 return;
1899 }
1900
2/2
✓ Branch 0 (1260→1261) taken 1 times.
✓ Branch 1 (1260→1262) taken 369 times.
2/2
✓ Fully covered.
370 else if ( ++x == number ) {
1901 1 return;
1902 }
1903
2/2
✓ Branch 0 (1262→1263) taken 1 times.
✓ Branch 1 (1262→1264) taken 368 times.
2/2
✓ Fully covered.
369 else if ( ++x == number ) {
1904 1 return;
1905 }
1906
2/2
✓ Branch 0 (1264→1265) taken 1 times.
✓ Branch 1 (1264→1266) taken 367 times.
2/2
✓ Fully covered.
368 else if ( ++x == number ) {
1907 1 return;
1908 }
1909
2/2
✓ Branch 0 (1266→1267) taken 1 times.
✓ Branch 1 (1266→1268) taken 366 times.
2/2
✓ Fully covered.
367 else if ( ++x == number ) {
1910 1 return;
1911 }
1912
2/2
✓ Branch 0 (1268→1269) taken 1 times.
✓ Branch 1 (1268→1270) taken 365 times.
2/2
✓ Fully covered.
366 else if ( ++x == number ) {
1913 1 return;
1914 }
1915
2/2
✓ Branch 0 (1270→1271) taken 1 times.
✓ Branch 1 (1270→1272) taken 364 times.
2/2
✓ Fully covered.
365 else if ( ++x == number ) {
1916 1 return;
1917 }
1918
2/2
✓ Branch 0 (1272→1273) taken 1 times.
✓ Branch 1 (1272→1274) taken 363 times.
2/2
✓ Fully covered.
364 else if ( ++x == number ) {
1919 1 return;
1920 }
1921
2/2
✓ Branch 0 (1274→1275) taken 1 times.
✓ Branch 1 (1274→1276) taken 362 times.
2/2
✓ Fully covered.
363 else if ( ++x == number ) {
1922 1 return;
1923 }
1924
2/2
✓ Branch 0 (1276→1277) taken 1 times.
✓ Branch 1 (1276→1278) taken 361 times.
2/2
✓ Fully covered.
362 else if ( ++x == number ) {
1925 1 return;
1926 }
1927
2/2
✓ Branch 0 (1278→1279) taken 1 times.
✓ Branch 1 (1278→1280) taken 360 times.
2/2
✓ Fully covered.
361 else if ( ++x == number ) {
1928 1 return;
1929 }
1930
2/2
✓ Branch 0 (1280→1281) taken 1 times.
✓ Branch 1 (1280→1282) taken 359 times.
2/2
✓ Fully covered.
360 else if ( ++x == number ) {
1931 1 return;
1932 }
1933
2/2
✓ Branch 0 (1282→1283) taken 1 times.
✓ Branch 1 (1282→1284) taken 358 times.
2/2
✓ Fully covered.
359 else if ( ++x == number ) {
1934 1 return;
1935 }
1936
2/2
✓ Branch 0 (1284→1285) taken 1 times.
✓ Branch 1 (1284→1286) taken 357 times.
2/2
✓ Fully covered.
358 else if ( ++x == number ) {
1937 1 return;
1938 }
1939
2/2
✓ Branch 0 (1286→1287) taken 1 times.
✓ Branch 1 (1286→1288) taken 356 times.
2/2
✓ Fully covered.
357 else if ( ++x == number ) {
1940 1 return;
1941 }
1942
2/2
✓ Branch 0 (1288→1289) taken 1 times.
✓ Branch 1 (1288→1290) taken 355 times.
2/2
✓ Fully covered.
356 else if ( ++x == number ) {
1943 1 return;
1944 }
1945
2/2
✓ Branch 0 (1290→1291) taken 1 times.
✓ Branch 1 (1290→1292) taken 354 times.
2/2
✓ Fully covered.
355 else if ( ++x == number ) {
1946 1 return;
1947 }
1948
2/2
✓ Branch 0 (1292→1293) taken 1 times.
✓ Branch 1 (1292→1294) taken 353 times.
2/2
✓ Fully covered.
354 else if ( ++x == number ) {
1949 1 return;
1950 }
1951
2/2
✓ Branch 0 (1294→1295) taken 1 times.
✓ Branch 1 (1294→1296) taken 352 times.
2/2
✓ Fully covered.
353 else if ( ++x == number ) {
1952 1 return;
1953 }
1954
2/2
✓ Branch 0 (1296→1297) taken 1 times.
✓ Branch 1 (1296→1298) taken 351 times.
2/2
✓ Fully covered.
352 else if ( ++x == number ) {
1955 1 return;
1956 }
1957
2/2
✓ Branch 0 (1298→1299) taken 1 times.
✓ Branch 1 (1298→1300) taken 350 times.
2/2
✓ Fully covered.
351 else if ( ++x == number ) {
1958 1 return;
1959 }
1960
2/2
✓ Branch 0 (1300→1301) taken 1 times.
✓ Branch 1 (1300→1302) taken 349 times.
2/2
✓ Fully covered.
350 else if ( ++x == number ) {
1961 1 return;
1962 }
1963
2/2
✓ Branch 0 (1302→1303) taken 1 times.
✓ Branch 1 (1302→1304) taken 348 times.
2/2
✓ Fully covered.
349 else if ( ++x == number ) {
1964 1 return;
1965 }
1966
2/2
✓ Branch 0 (1304→1305) taken 1 times.
✓ Branch 1 (1304→1306) taken 347 times.
2/2
✓ Fully covered.
348 else if ( ++x == number ) {
1967 1 return;
1968 }
1969
2/2
✓ Branch 0 (1306→1307) taken 1 times.
✓ Branch 1 (1306→1308) taken 346 times.
2/2
✓ Fully covered.
347 else if ( ++x == number ) {
1970 1 return;
1971 }
1972
2/2
✓ Branch 0 (1308→1309) taken 1 times.
✓ Branch 1 (1308→1310) taken 345 times.
2/2
✓ Fully covered.
346 else if ( ++x == number ) {
1973 1 return;
1974 }
1975
2/2
✓ Branch 0 (1310→1311) taken 1 times.
✓ Branch 1 (1310→1312) taken 344 times.
2/2
✓ Fully covered.
345 else if ( ++x == number ) {
1976 1 return;
1977 }
1978
2/2
✓ Branch 0 (1312→1313) taken 1 times.
✓ Branch 1 (1312→1314) taken 343 times.
2/2
✓ Fully covered.
344 else if ( ++x == number ) {
1979 1 return;
1980 }
1981
2/2
✓ Branch 0 (1314→1315) taken 1 times.
✓ Branch 1 (1314→1316) taken 342 times.
2/2
✓ Fully covered.
343 else if ( ++x == number ) {
1982 1 return;
1983 }
1984
2/2
✓ Branch 0 (1316→1317) taken 1 times.
✓ Branch 1 (1316→1318) taken 341 times.
2/2
✓ Fully covered.
342 else if ( ++x == number ) {
1985 1 return;
1986 }
1987
2/2
✓ Branch 0 (1318→1319) taken 1 times.
✓ Branch 1 (1318→1320) taken 340 times.
2/2
✓ Fully covered.
341 else if ( ++x == number ) {
1988 1 return;
1989 }
1990
2/2
✓ Branch 0 (1320→1321) taken 1 times.
✓ Branch 1 (1320→1322) taken 339 times.
2/2
✓ Fully covered.
340 else if ( ++x == number ) {
1991 1 return;
1992 }
1993
2/2
✓ Branch 0 (1322→1323) taken 1 times.
✓ Branch 1 (1322→1324) taken 338 times.
2/2
✓ Fully covered.
339 else if ( ++x == number ) {
1994 1 return;
1995 }
1996
2/2
✓ Branch 0 (1324→1325) taken 1 times.
✓ Branch 1 (1324→1326) taken 337 times.
2/2
✓ Fully covered.
338 else if ( ++x == number ) {
1997 1 return;
1998 }
1999
2/2
✓ Branch 0 (1326→1327) taken 1 times.
✓ Branch 1 (1326→1328) taken 336 times.
2/2
✓ Fully covered.
337 else if ( ++x == number ) {
2000 1 return;
2001 }
2002
2/2
✓ Branch 0 (1328→1329) taken 1 times.
✓ Branch 1 (1328→1330) taken 335 times.
2/2
✓ Fully covered.
336 else if ( ++x == number ) {
2003 1 return;
2004 }
2005
2/2
✓ Branch 0 (1330→1331) taken 1 times.
✓ Branch 1 (1330→1332) taken 334 times.
2/2
✓ Fully covered.
335 else if ( ++x == number ) {
2006 1 return;
2007 }
2008
2/2
✓ Branch 0 (1332→1333) taken 1 times.
✓ Branch 1 (1332→1334) taken 333 times.
2/2
✓ Fully covered.
334 else if ( ++x == number ) {
2009 1 return;
2010 }
2011
2/2
✓ Branch 0 (1334→1335) taken 1 times.
✓ Branch 1 (1334→1336) taken 332 times.
2/2
✓ Fully covered.
333 else if ( ++x == number ) {
2012 1 return;
2013 }
2014
2/2
✓ Branch 0 (1336→1337) taken 1 times.
✓ Branch 1 (1336→1338) taken 331 times.
2/2
✓ Fully covered.
332 else if ( ++x == number ) {
2015 1 return;
2016 }
2017
2/2
✓ Branch 0 (1338→1339) taken 1 times.
✓ Branch 1 (1338→1340) taken 330 times.
2/2
✓ Fully covered.
331 else if ( ++x == number ) {
2018 1 return;
2019 }
2020
2/2
✓ Branch 0 (1340→1341) taken 1 times.
✓ Branch 1 (1340→1342) taken 329 times.
2/2
✓ Fully covered.
330 else if ( ++x == number ) {
2021 1 return;
2022 }
2023
2/2
✓ Branch 0 (1342→1343) taken 1 times.
✓ Branch 1 (1342→1344) taken 328 times.
2/2
✓ Fully covered.
329 else if ( ++x == number ) {
2024 1 return;
2025 }
2026
2/2
✓ Branch 0 (1344→1345) taken 1 times.
✓ Branch 1 (1344→1346) taken 327 times.
2/2
✓ Fully covered.
328 else if ( ++x == number ) {
2027 1 return;
2028 }
2029
2/2
✓ Branch 0 (1346→1347) taken 1 times.
✓ Branch 1 (1346→1348) taken 326 times.
2/2
✓ Fully covered.
327 else if ( ++x == number ) {
2030 1 return;
2031 }
2032
2/2
✓ Branch 0 (1348→1349) taken 1 times.
✓ Branch 1 (1348→1350) taken 325 times.
2/2
✓ Fully covered.
326 else if ( ++x == number ) {
2033 1 return;
2034 }
2035
2/2
✓ Branch 0 (1350→1351) taken 1 times.
✓ Branch 1 (1350→1352) taken 324 times.
2/2
✓ Fully covered.
325 else if ( ++x == number ) {
2036 1 return;
2037 }
2038
2/2
✓ Branch 0 (1352→1353) taken 1 times.
✓ Branch 1 (1352→1354) taken 323 times.
2/2
✓ Fully covered.
324 else if ( ++x == number ) {
2039 1 return;
2040 }
2041
2/2
✓ Branch 0 (1354→1355) taken 1 times.
✓ Branch 1 (1354→1356) taken 322 times.
2/2
✓ Fully covered.
323 else if ( ++x == number ) {
2042 1 return;
2043 }
2044
2/2
✓ Branch 0 (1356→1357) taken 1 times.
✓ Branch 1 (1356→1358) taken 321 times.
2/2
✓ Fully covered.
322 else if ( ++x == number ) {
2045 1 return;
2046 }
2047
2/2
✓ Branch 0 (1358→1359) taken 1 times.
✓ Branch 1 (1358→1360) taken 320 times.
2/2
✓ Fully covered.
321 else if ( ++x == number ) {
2048 1 return;
2049 }
2050
2/2
✓ Branch 0 (1360→1361) taken 1 times.
✓ Branch 1 (1360→1362) taken 319 times.
2/2
✓ Fully covered.
320 else if ( ++x == number ) {
2051 1 return;
2052 }
2053
2/2
✓ Branch 0 (1362→1363) taken 1 times.
✓ Branch 1 (1362→1364) taken 318 times.
2/2
✓ Fully covered.
319 else if ( ++x == number ) {
2054 1 return;
2055 }
2056
2/2
✓ Branch 0 (1364→1365) taken 1 times.
✓ Branch 1 (1364→1366) taken 317 times.
2/2
✓ Fully covered.
318 else if ( ++x == number ) {
2057 1 return;
2058 }
2059
2/2
✓ Branch 0 (1366→1367) taken 1 times.
✓ Branch 1 (1366→1368) taken 316 times.
2/2
✓ Fully covered.
317 else if ( ++x == number ) {
2060 1 return;
2061 }
2062
2/2
✓ Branch 0 (1368→1369) taken 1 times.
✓ Branch 1 (1368→1370) taken 315 times.
2/2
✓ Fully covered.
316 else if ( ++x == number ) {
2063 1 return;
2064 }
2065
2/2
✓ Branch 0 (1370→1371) taken 1 times.
✓ Branch 1 (1370→1372) taken 314 times.
2/2
✓ Fully covered.
315 else if ( ++x == number ) {
2066 1 return;
2067 }
2068
2/2
✓ Branch 0 (1372→1373) taken 1 times.
✓ Branch 1 (1372→1374) taken 313 times.
2/2
✓ Fully covered.
314 else if ( ++x == number ) {
2069 1 return;
2070 }
2071
2/2
✓ Branch 0 (1374→1375) taken 1 times.
✓ Branch 1 (1374→1376) taken 312 times.
2/2
✓ Fully covered.
313 else if ( ++x == number ) {
2072 1 return;
2073 }
2074
2/2
✓ Branch 0 (1376→1377) taken 1 times.
✓ Branch 1 (1376→1378) taken 311 times.
2/2
✓ Fully covered.
312 else if ( ++x == number ) {
2075 1 return;
2076 }
2077
2/2
✓ Branch 0 (1378→1379) taken 1 times.
✓ Branch 1 (1378→1380) taken 310 times.
2/2
✓ Fully covered.
311 else if ( ++x == number ) {
2078 1 return;
2079 }
2080
2/2
✓ Branch 0 (1380→1381) taken 1 times.
✓ Branch 1 (1380→1382) taken 309 times.
2/2
✓ Fully covered.
310 else if ( ++x == number ) {
2081 1 return;
2082 }
2083
2/2
✓ Branch 0 (1382→1383) taken 1 times.
✓ Branch 1 (1382→1384) taken 308 times.
2/2
✓ Fully covered.
309 else if ( ++x == number ) {
2084 1 return;
2085 }
2086
2/2
✓ Branch 0 (1384→1385) taken 1 times.
✓ Branch 1 (1384→1386) taken 307 times.
2/2
✓ Fully covered.
308 else if ( ++x == number ) {
2087 1 return;
2088 }
2089
2/2
✓ Branch 0 (1386→1387) taken 1 times.
✓ Branch 1 (1386→1388) taken 306 times.
2/2
✓ Fully covered.
307 else if ( ++x == number ) {
2090 1 return;
2091 }
2092
2/2
✓ Branch 0 (1388→1389) taken 1 times.
✓ Branch 1 (1388→1390) taken 305 times.
2/2
✓ Fully covered.
306 else if ( ++x == number ) {
2093 1 return;
2094 }
2095
2/2
✓ Branch 0 (1390→1391) taken 1 times.
✓ Branch 1 (1390→1392) taken 304 times.
2/2
✓ Fully covered.
305 else if ( ++x == number ) {
2096 1 return;
2097 }
2098
2/2
✓ Branch 0 (1392→1393) taken 1 times.
✓ Branch 1 (1392→1394) taken 303 times.
2/2
✓ Fully covered.
304 else if ( ++x == number ) {
2099 1 return;
2100 }
2101
2/2
✓ Branch 0 (1394→1395) taken 1 times.
✓ Branch 1 (1394→1396) taken 302 times.
2/2
✓ Fully covered.
303 else if ( ++x == number ) {
2102 1 return;
2103 }
2104
2/2
✓ Branch 0 (1396→1397) taken 1 times.
✓ Branch 1 (1396→1398) taken 301 times.
2/2
✓ Fully covered.
302 else if ( ++x == number ) {
2105 1 return;
2106 }
2107
2/2
✓ Branch 0 (1398→1399) taken 1 times.
✓ Branch 1 (1398→1400) taken 300 times.
2/2
✓ Fully covered.
301 else if ( ++x == number ) {
2108 1 return;
2109 }
2110
2/2
✓ Branch 0 (1400→1401) taken 1 times.
✓ Branch 1 (1400→1402) taken 299 times.
2/2
✓ Fully covered.
300 else if ( ++x == number ) {
2111 1 return;
2112 }
2113
2/2
✓ Branch 0 (1402→1403) taken 1 times.
✓ Branch 1 (1402→1404) taken 298 times.
2/2
✓ Fully covered.
299 else if ( ++x == number ) {
2114 1 return;
2115 }
2116
2/2
✓ Branch 0 (1404→1405) taken 1 times.
✓ Branch 1 (1404→1406) taken 297 times.
2/2
✓ Fully covered.
298 else if ( ++x == number ) {
2117 1 return;
2118 }
2119
2/2
✓ Branch 0 (1406→1407) taken 1 times.
✓ Branch 1 (1406→1408) taken 296 times.
2/2
✓ Fully covered.
297 else if ( ++x == number ) {
2120 1 return;
2121 }
2122
2/2
✓ Branch 0 (1408→1409) taken 1 times.
✓ Branch 1 (1408→1410) taken 295 times.
2/2
✓ Fully covered.
296 else if ( ++x == number ) {
2123 1 return;
2124 }
2125
2/2
✓ Branch 0 (1410→1411) taken 1 times.
✓ Branch 1 (1410→1412) taken 294 times.
2/2
✓ Fully covered.
295 else if ( ++x == number ) {
2126 1 return;
2127 }
2128
2/2
✓ Branch 0 (1412→1413) taken 1 times.
✓ Branch 1 (1412→1414) taken 293 times.
2/2
✓ Fully covered.
294 else if ( ++x == number ) {
2129 1 return;
2130 }
2131
2/2
✓ Branch 0 (1414→1415) taken 1 times.
✓ Branch 1 (1414→1416) taken 292 times.
2/2
✓ Fully covered.
293 else if ( ++x == number ) {
2132 1 return;
2133 }
2134
2/2
✓ Branch 0 (1416→1417) taken 1 times.
✓ Branch 1 (1416→1418) taken 291 times.
2/2
✓ Fully covered.
292 else if ( ++x == number ) {
2135 1 return;
2136 }
2137
2/2
✓ Branch 0 (1418→1419) taken 1 times.
✓ Branch 1 (1418→1420) taken 290 times.
2/2
✓ Fully covered.
291 else if ( ++x == number ) {
2138 1 return;
2139 }
2140
2/2
✓ Branch 0 (1420→1421) taken 1 times.
✓ Branch 1 (1420→1422) taken 289 times.
2/2
✓ Fully covered.
290 else if ( ++x == number ) {
2141 1 return;
2142 }
2143
2/2
✓ Branch 0 (1422→1423) taken 1 times.
✓ Branch 1 (1422→1424) taken 288 times.
2/2
✓ Fully covered.
289 else if ( ++x == number ) {
2144 1 return;
2145 }
2146
2/2
✓ Branch 0 (1424→1425) taken 1 times.
✓ Branch 1 (1424→1426) taken 287 times.
2/2
✓ Fully covered.
288 else if ( ++x == number ) {
2147 1 return;
2148 }
2149
2/2
✓ Branch 0 (1426→1427) taken 1 times.
✓ Branch 1 (1426→1428) taken 286 times.
2/2
✓ Fully covered.
287 else if ( ++x == number ) {
2150 1 return;
2151 }
2152
2/2
✓ Branch 0 (1428→1429) taken 1 times.
✓ Branch 1 (1428→1430) taken 285 times.
2/2
✓ Fully covered.
286 else if ( ++x == number ) {
2153 1 return;
2154 }
2155
2/2
✓ Branch 0 (1430→1431) taken 1 times.
✓ Branch 1 (1430→1432) taken 284 times.
2/2
✓ Fully covered.
285 else if ( ++x == number ) {
2156 1 return;
2157 }
2158
2/2
✓ Branch 0 (1432→1433) taken 1 times.
✓ Branch 1 (1432→1434) taken 283 times.
2/2
✓ Fully covered.
284 else if ( ++x == number ) {
2159 1 return;
2160 }
2161
2/2
✓ Branch 0 (1434→1435) taken 1 times.
✓ Branch 1 (1434→1436) taken 282 times.
2/2
✓ Fully covered.
283 else if ( ++x == number ) {
2162 1 return;
2163 }
2164
2/2
✓ Branch 0 (1436→1437) taken 1 times.
✓ Branch 1 (1436→1438) taken 281 times.
2/2
✓ Fully covered.
282 else if ( ++x == number ) {
2165 1 return;
2166 }
2167
2/2
✓ Branch 0 (1438→1439) taken 1 times.
✓ Branch 1 (1438→1440) taken 280 times.
2/2
✓ Fully covered.
281 else if ( ++x == number ) {
2168 1 return;
2169 }
2170
2/2
✓ Branch 0 (1440→1441) taken 1 times.
✓ Branch 1 (1440→1442) taken 279 times.
2/2
✓ Fully covered.
280 else if ( ++x == number ) {
2171 1 return;
2172 }
2173
2/2
✓ Branch 0 (1442→1443) taken 1 times.
✓ Branch 1 (1442→1444) taken 278 times.
2/2
✓ Fully covered.
279 else if ( ++x == number ) {
2174 1 return;
2175 }
2176
2/2
✓ Branch 0 (1444→1445) taken 1 times.
✓ Branch 1 (1444→1446) taken 277 times.
2/2
✓ Fully covered.
278 else if ( ++x == number ) {
2177 1 return;
2178 }
2179
2/2
✓ Branch 0 (1446→1447) taken 1 times.
✓ Branch 1 (1446→1448) taken 276 times.
2/2
✓ Fully covered.
277 else if ( ++x == number ) {
2180 1 return;
2181 }
2182
2/2
✓ Branch 0 (1448→1449) taken 1 times.
✓ Branch 1 (1448→1450) taken 275 times.
2/2
✓ Fully covered.
276 else if ( ++x == number ) {
2183 1 return;
2184 }
2185
2/2
✓ Branch 0 (1450→1451) taken 1 times.
✓ Branch 1 (1450→1452) taken 274 times.
2/2
✓ Fully covered.
275 else if ( ++x == number ) {
2186 1 return;
2187 }
2188
2/2
✓ Branch 0 (1452→1453) taken 1 times.
✓ Branch 1 (1452→1454) taken 273 times.
2/2
✓ Fully covered.
274 else if ( ++x == number ) {
2189 1 return;
2190 }
2191
2/2
✓ Branch 0 (1454→1455) taken 1 times.
✓ Branch 1 (1454→1456) taken 272 times.
2/2
✓ Fully covered.
273 else if ( ++x == number ) {
2192 1 return;
2193 }
2194
2/2
✓ Branch 0 (1456→1457) taken 1 times.
✓ Branch 1 (1456→1458) taken 271 times.
2/2
✓ Fully covered.
272 else if ( ++x == number ) {
2195 1 return;
2196 }
2197
2/2
✓ Branch 0 (1458→1459) taken 1 times.
✓ Branch 1 (1458→1460) taken 270 times.
2/2
✓ Fully covered.
271 else if ( ++x == number ) {
2198 1 return;
2199 }
2200
2/2
✓ Branch 0 (1460→1461) taken 1 times.
✓ Branch 1 (1460→1462) taken 269 times.
2/2
✓ Fully covered.
270 else if ( ++x == number ) {
2201 1 return;
2202 }
2203
2/2
✓ Branch 0 (1462→1463) taken 1 times.
✓ Branch 1 (1462→1464) taken 268 times.
2/2
✓ Fully covered.
269 else if ( ++x == number ) {
2204 1 return;
2205 }
2206
2/2
✓ Branch 0 (1464→1465) taken 1 times.
✓ Branch 1 (1464→1466) taken 267 times.
2/2
✓ Fully covered.
268 else if ( ++x == number ) {
2207 1 return;
2208 }
2209
2/2
✓ Branch 0 (1466→1467) taken 1 times.
✓ Branch 1 (1466→1468) taken 266 times.
2/2
✓ Fully covered.
267 else if ( ++x == number ) {
2210 1 return;
2211 }
2212
2/2
✓ Branch 0 (1468→1469) taken 1 times.
✓ Branch 1 (1468→1470) taken 265 times.
2/2
✓ Fully covered.
266 else if ( ++x == number ) {
2213 1 return;
2214 }
2215
2/2
✓ Branch 0 (1470→1471) taken 1 times.
✓ Branch 1 (1470→1472) taken 264 times.
2/2
✓ Fully covered.
265 else if ( ++x == number ) {
2216 1 return;
2217 }
2218
2/2
✓ Branch 0 (1472→1473) taken 1 times.
✓ Branch 1 (1472→1474) taken 263 times.
2/2
✓ Fully covered.
264 else if ( ++x == number ) {
2219 1 return;
2220 }
2221
2/2
✓ Branch 0 (1474→1475) taken 1 times.
✓ Branch 1 (1474→1476) taken 262 times.
2/2
✓ Fully covered.
263 else if ( ++x == number ) {
2222 1 return;
2223 }
2224
2/2
✓ Branch 0 (1476→1477) taken 1 times.
✓ Branch 1 (1476→1478) taken 261 times.
2/2
✓ Fully covered.
262 else if ( ++x == number ) {
2225 1 return;
2226 }
2227
2/2
✓ Branch 0 (1478→1479) taken 1 times.
✓ Branch 1 (1478→1480) taken 260 times.
2/2
✓ Fully covered.
261 else if ( ++x == number ) {
2228 1 return;
2229 }
2230
2/2
✓ Branch 0 (1480→1481) taken 1 times.
✓ Branch 1 (1480→1482) taken 259 times.
2/2
✓ Fully covered.
260 else if ( ++x == number ) {
2231 1 return;
2232 }
2233
2/2
✓ Branch 0 (1482→1483) taken 1 times.
✓ Branch 1 (1482→1484) taken 258 times.
2/2
✓ Fully covered.
259 else if ( ++x == number ) {
2234 1 return;
2235 }
2236
2/2
✓ Branch 0 (1484→1485) taken 1 times.
✓ Branch 1 (1484→1486) taken 257 times.
2/2
✓ Fully covered.
258 else if ( ++x == number ) {
2237 1 return;
2238 }
2239
2/2
✓ Branch 0 (1486→1487) taken 1 times.
✓ Branch 1 (1486→1488) taken 256 times.
2/2
✓ Fully covered.
257 else if ( ++x == number ) {
2240 1 return;
2241 }
2242
2/2
✓ Branch 0 (1488→1489) taken 1 times.
✓ Branch 1 (1488→1490) taken 255 times.
2/2
✓ Fully covered.
256 else if ( ++x == number ) {
2243 1 return;
2244 }
2245
2/2
✓ Branch 0 (1490→1491) taken 1 times.
✓ Branch 1 (1490→1492) taken 254 times.
2/2
✓ Fully covered.
255 else if ( ++x == number ) {
2246 1 return;
2247 }
2248
2/2
✓ Branch 0 (1492→1493) taken 1 times.
✓ Branch 1 (1492→1494) taken 253 times.
2/2
✓ Fully covered.
254 else if ( ++x == number ) {
2249 1 return;
2250 }
2251
2/2
✓ Branch 0 (1494→1495) taken 1 times.
✓ Branch 1 (1494→1496) taken 252 times.
2/2
✓ Fully covered.
253 else if ( ++x == number ) {
2252 1 return;
2253 }
2254
2/2
✓ Branch 0 (1496→1497) taken 1 times.
✓ Branch 1 (1496→1498) taken 251 times.
2/2
✓ Fully covered.
252 else if ( ++x == number ) {
2255 1 return;
2256 }
2257
2/2
✓ Branch 0 (1498→1499) taken 1 times.
✓ Branch 1 (1498→1500) taken 250 times.
2/2
✓ Fully covered.
251 else if ( ++x == number ) {
2258 1 return;
2259 }
2260
2/2
✓ Branch 0 (1500→1501) taken 1 times.
✓ Branch 1 (1500→1502) taken 249 times.
2/2
✓ Fully covered.
250 else if ( ++x == number ) {
2261 1 return;
2262 }
2263
2/2
✓ Branch 0 (1502→1503) taken 1 times.
✓ Branch 1 (1502→1504) taken 248 times.
2/2
✓ Fully covered.
249 else if ( ++x == number ) {
2264 1 return;
2265 }
2266
2/2
✓ Branch 0 (1504→1505) taken 1 times.
✓ Branch 1 (1504→1506) taken 247 times.
2/2
✓ Fully covered.
248 else if ( ++x == number ) {
2267 1 return;
2268 }
2269
2/2
✓ Branch 0 (1506→1507) taken 1 times.
✓ Branch 1 (1506→1508) taken 246 times.
2/2
✓ Fully covered.
247 else if ( ++x == number ) {
2270 1 return;
2271 }
2272
2/2
✓ Branch 0 (1508→1509) taken 1 times.
✓ Branch 1 (1508→1510) taken 245 times.
2/2
✓ Fully covered.
246 else if ( ++x == number ) {
2273 1 return;
2274 }
2275
2/2
✓ Branch 0 (1510→1511) taken 1 times.
✓ Branch 1 (1510→1512) taken 244 times.
2/2
✓ Fully covered.
245 else if ( ++x == number ) {
2276 1 return;
2277 }
2278
2/2
✓ Branch 0 (1512→1513) taken 1 times.
✓ Branch 1 (1512→1514) taken 243 times.
2/2
✓ Fully covered.
244 else if ( ++x == number ) {
2279 1 return;
2280 }
2281
2/2
✓ Branch 0 (1514→1515) taken 1 times.
✓ Branch 1 (1514→1516) taken 242 times.
2/2
✓ Fully covered.
243 else if ( ++x == number ) {
2282 1 return;
2283 }
2284
2/2
✓ Branch 0 (1516→1517) taken 1 times.
✓ Branch 1 (1516→1518) taken 241 times.
2/2
✓ Fully covered.
242 else if ( ++x == number ) {
2285 1 return;
2286 }
2287
2/2
✓ Branch 0 (1518→1519) taken 1 times.
✓ Branch 1 (1518→1520) taken 240 times.
2/2
✓ Fully covered.
241 else if ( ++x == number ) {
2288 1 return;
2289 }
2290
2/2
✓ Branch 0 (1520→1521) taken 1 times.
✓ Branch 1 (1520→1522) taken 239 times.
2/2
✓ Fully covered.
240 else if ( ++x == number ) {
2291 1 return;
2292 }
2293
2/2
✓ Branch 0 (1522→1523) taken 1 times.
✓ Branch 1 (1522→1524) taken 238 times.
2/2
✓ Fully covered.
239 else if ( ++x == number ) {
2294 1 return;
2295 }
2296
2/2
✓ Branch 0 (1524→1525) taken 1 times.
✓ Branch 1 (1524→1526) taken 237 times.
2/2
✓ Fully covered.
238 else if ( ++x == number ) {
2297 1 return;
2298 }
2299
2/2
✓ Branch 0 (1526→1527) taken 1 times.
✓ Branch 1 (1526→1528) taken 236 times.
2/2
✓ Fully covered.
237 else if ( ++x == number ) {
2300 1 return;
2301 }
2302
2/2
✓ Branch 0 (1528→1529) taken 1 times.
✓ Branch 1 (1528→1530) taken 235 times.
2/2
✓ Fully covered.
236 else if ( ++x == number ) {
2303 1 return;
2304 }
2305
2/2
✓ Branch 0 (1530→1531) taken 1 times.
✓ Branch 1 (1530→1532) taken 234 times.
2/2
✓ Fully covered.
235 else if ( ++x == number ) {
2306 1 return;
2307 }
2308
2/2
✓ Branch 0 (1532→1533) taken 1 times.
✓ Branch 1 (1532→1534) taken 233 times.
2/2
✓ Fully covered.
234 else if ( ++x == number ) {
2309 1 return;
2310 }
2311
2/2
✓ Branch 0 (1534→1535) taken 1 times.
✓ Branch 1 (1534→1536) taken 232 times.
2/2
✓ Fully covered.
233 else if ( ++x == number ) {
2312 1 return;
2313 }
2314
2/2
✓ Branch 0 (1536→1537) taken 1 times.
✓ Branch 1 (1536→1538) taken 231 times.
2/2
✓ Fully covered.
232 else if ( ++x == number ) {
2315 1 return;
2316 }
2317
2/2
✓ Branch 0 (1538→1539) taken 1 times.
✓ Branch 1 (1538→1540) taken 230 times.
2/2
✓ Fully covered.
231 else if ( ++x == number ) {
2318 1 return;
2319 }
2320
2/2
✓ Branch 0 (1540→1541) taken 1 times.
✓ Branch 1 (1540→1542) taken 229 times.
2/2
✓ Fully covered.
230 else if ( ++x == number ) {
2321 1 return;
2322 }
2323
2/2
✓ Branch 0 (1542→1543) taken 1 times.
✓ Branch 1 (1542→1544) taken 228 times.
2/2
✓ Fully covered.
229 else if ( ++x == number ) {
2324 1 return;
2325 }
2326
2/2
✓ Branch 0 (1544→1545) taken 1 times.
✓ Branch 1 (1544→1546) taken 227 times.
2/2
✓ Fully covered.
228 else if ( ++x == number ) {
2327 1 return;
2328 }
2329
2/2
✓ Branch 0 (1546→1547) taken 1 times.
✓ Branch 1 (1546→1548) taken 226 times.
2/2
✓ Fully covered.
227 else if ( ++x == number ) {
2330 1 return;
2331 }
2332
2/2
✓ Branch 0 (1548→1549) taken 1 times.
✓ Branch 1 (1548→1550) taken 225 times.
2/2
✓ Fully covered.
226 else if ( ++x == number ) {
2333 1 return;
2334 }
2335
2/2
✓ Branch 0 (1550→1551) taken 1 times.
✓ Branch 1 (1550→1552) taken 224 times.
2/2
✓ Fully covered.
225 else if ( ++x == number ) {
2336 1 return;
2337 }
2338
2/2
✓ Branch 0 (1552→1553) taken 1 times.
✓ Branch 1 (1552→1554) taken 223 times.
2/2
✓ Fully covered.
224 else if ( ++x == number ) {
2339 1 return;
2340 }
2341
2/2
✓ Branch 0 (1554→1555) taken 1 times.
✓ Branch 1 (1554→1556) taken 222 times.
2/2
✓ Fully covered.
223 else if ( ++x == number ) {
2342 1 return;
2343 }
2344
2/2
✓ Branch 0 (1556→1557) taken 1 times.
✓ Branch 1 (1556→1558) taken 221 times.
2/2
✓ Fully covered.
222 else if ( ++x == number ) {
2345 1 return;
2346 }
2347
2/2
✓ Branch 0 (1558→1559) taken 1 times.
✓ Branch 1 (1558→1560) taken 220 times.
2/2
✓ Fully covered.
221 else if ( ++x == number ) {
2348 1 return;
2349 }
2350
2/2
✓ Branch 0 (1560→1561) taken 1 times.
✓ Branch 1 (1560→1562) taken 219 times.
2/2
✓ Fully covered.
220 else if ( ++x == number ) {
2351 1 return;
2352 }
2353
2/2
✓ Branch 0 (1562→1563) taken 1 times.
✓ Branch 1 (1562→1564) taken 218 times.
2/2
✓ Fully covered.
219 else if ( ++x == number ) {
2354 1 return;
2355 }
2356
2/2
✓ Branch 0 (1564→1565) taken 1 times.
✓ Branch 1 (1564→1566) taken 217 times.
2/2
✓ Fully covered.
218 else if ( ++x == number ) {
2357 1 return;
2358 }
2359
2/2
✓ Branch 0 (1566→1567) taken 1 times.
✓ Branch 1 (1566→1568) taken 216 times.
2/2
✓ Fully covered.
217 else if ( ++x == number ) {
2360 1 return;
2361 }
2362
2/2
✓ Branch 0 (1568→1569) taken 1 times.
✓ Branch 1 (1568→1570) taken 215 times.
2/2
✓ Fully covered.
216 else if ( ++x == number ) {
2363 1 return;
2364 }
2365
2/2
✓ Branch 0 (1570→1571) taken 1 times.
✓ Branch 1 (1570→1572) taken 214 times.
2/2
✓ Fully covered.
215 else if ( ++x == number ) {
2366 1 return;
2367 }
2368
2/2
✓ Branch 0 (1572→1573) taken 1 times.
✓ Branch 1 (1572→1574) taken 213 times.
2/2
✓ Fully covered.
214 else if ( ++x == number ) {
2369 1 return;
2370 }
2371
2/2
✓ Branch 0 (1574→1575) taken 1 times.
✓ Branch 1 (1574→1576) taken 212 times.
2/2
✓ Fully covered.
213 else if ( ++x == number ) {
2372 1 return;
2373 }
2374
2/2
✓ Branch 0 (1576→1577) taken 1 times.
✓ Branch 1 (1576→1578) taken 211 times.
2/2
✓ Fully covered.
212 else if ( ++x == number ) {
2375 1 return;
2376 }
2377
2/2
✓ Branch 0 (1578→1579) taken 1 times.
✓ Branch 1 (1578→1580) taken 210 times.
2/2
✓ Fully covered.
211 else if ( ++x == number ) {
2378 1 return;
2379 }
2380
2/2
✓ Branch 0 (1580→1581) taken 1 times.
✓ Branch 1 (1580→1582) taken 209 times.
2/2
✓ Fully covered.
210 else if ( ++x == number ) {
2381 1 return;
2382 }
2383
2/2
✓ Branch 0 (1582→1583) taken 1 times.
✓ Branch 1 (1582→1584) taken 208 times.
2/2
✓ Fully covered.
209 else if ( ++x == number ) {
2384 1 return;
2385 }
2386
2/2
✓ Branch 0 (1584→1585) taken 1 times.
✓ Branch 1 (1584→1586) taken 207 times.
2/2
✓ Fully covered.
208 else if ( ++x == number ) {
2387 1 return;
2388 }
2389
2/2
✓ Branch 0 (1586→1587) taken 1 times.
✓ Branch 1 (1586→1588) taken 206 times.
2/2
✓ Fully covered.
207 else if ( ++x == number ) {
2390 1 return;
2391 }
2392
2/2
✓ Branch 0 (1588→1589) taken 1 times.
✓ Branch 1 (1588→1590) taken 205 times.
2/2
✓ Fully covered.
206 else if ( ++x == number ) {
2393 1 return;
2394 }
2395
2/2
✓ Branch 0 (1590→1591) taken 1 times.
✓ Branch 1 (1590→1592) taken 204 times.
2/2
✓ Fully covered.
205 else if ( ++x == number ) {
2396 1 return;
2397 }
2398
2/2
✓ Branch 0 (1592→1593) taken 1 times.
✓ Branch 1 (1592→1594) taken 203 times.
2/2
✓ Fully covered.
204 else if ( ++x == number ) {
2399 1 return;
2400 }
2401
2/2
✓ Branch 0 (1594→1595) taken 1 times.
✓ Branch 1 (1594→1596) taken 202 times.
2/2
✓ Fully covered.
203 else if ( ++x == number ) {
2402 1 return;
2403 }
2404
2/2
✓ Branch 0 (1596→1597) taken 1 times.
✓ Branch 1 (1596→1598) taken 201 times.
2/2
✓ Fully covered.
202 else if ( ++x == number ) {
2405 1 return;
2406 }
2407
2/2
✓ Branch 0 (1598→1599) taken 1 times.
✓ Branch 1 (1598→1600) taken 200 times.
2/2
✓ Fully covered.
201 else if ( ++x == number ) {
2408 1 return;
2409 }
2410
2/2
✓ Branch 0 (1600→1601) taken 1 times.
✓ Branch 1 (1600→1602) taken 199 times.
2/2
✓ Fully covered.
200 else if ( ++x == number ) {
2411 1 return;
2412 }
2413
2/2
✓ Branch 0 (1602→1603) taken 1 times.
✓ Branch 1 (1602→1604) taken 198 times.
2/2
✓ Fully covered.
199 else if ( ++x == number ) {
2414 1 return;
2415 }
2416
2/2
✓ Branch 0 (1604→1605) taken 1 times.
✓ Branch 1 (1604→1606) taken 197 times.
2/2
✓ Fully covered.
198 else if ( ++x == number ) {
2417 1 return;
2418 }
2419
2/2
✓ Branch 0 (1606→1607) taken 1 times.
✓ Branch 1 (1606→1608) taken 196 times.
2/2
✓ Fully covered.
197 else if ( ++x == number ) {
2420 1 return;
2421 }
2422
2/2
✓ Branch 0 (1608→1609) taken 1 times.
✓ Branch 1 (1608→1610) taken 195 times.
2/2
✓ Fully covered.
196 else if ( ++x == number ) {
2423 1 return;
2424 }
2425
2/2
✓ Branch 0 (1610→1611) taken 1 times.
✓ Branch 1 (1610→1612) taken 194 times.
2/2
✓ Fully covered.
195 else if ( ++x == number ) {
2426 1 return;
2427 }
2428
2/2
✓ Branch 0 (1612→1613) taken 1 times.
✓ Branch 1 (1612→1614) taken 193 times.
2/2
✓ Fully covered.
194 else if ( ++x == number ) {
2429 1 return;
2430 }
2431
2/2
✓ Branch 0 (1614→1615) taken 1 times.
✓ Branch 1 (1614→1616) taken 192 times.
2/2
✓ Fully covered.
193 else if ( ++x == number ) {
2432 1 return;
2433 }
2434
2/2
✓ Branch 0 (1616→1617) taken 1 times.
✓ Branch 1 (1616→1618) taken 191 times.
2/2
✓ Fully covered.
192 else if ( ++x == number ) {
2435 1 return;
2436 }
2437
2/2
✓ Branch 0 (1618→1619) taken 1 times.
✓ Branch 1 (1618→1620) taken 190 times.
2/2
✓ Fully covered.
191 else if ( ++x == number ) {
2438 1 return;
2439 }
2440
2/2
✓ Branch 0 (1620→1621) taken 1 times.
✓ Branch 1 (1620→1622) taken 189 times.
2/2
✓ Fully covered.
190 else if ( ++x == number ) {
2441 1 return;
2442 }
2443
2/2
✓ Branch 0 (1622→1623) taken 1 times.
✓ Branch 1 (1622→1624) taken 188 times.
2/2
✓ Fully covered.
189 else if ( ++x == number ) {
2444 1 return;
2445 }
2446
2/2
✓ Branch 0 (1624→1625) taken 1 times.
✓ Branch 1 (1624→1626) taken 187 times.
2/2
✓ Fully covered.
188 else if ( ++x == number ) {
2447 1 return;
2448 }
2449
2/2
✓ Branch 0 (1626→1627) taken 1 times.
✓ Branch 1 (1626→1628) taken 186 times.
2/2
✓ Fully covered.
187 else if ( ++x == number ) {
2450 1 return;
2451 }
2452
2/2
✓ Branch 0 (1628→1629) taken 1 times.
✓ Branch 1 (1628→1630) taken 185 times.
2/2
✓ Fully covered.
186 else if ( ++x == number ) {
2453 1 return;
2454 }
2455
2/2
✓ Branch 0 (1630→1631) taken 1 times.
✓ Branch 1 (1630→1632) taken 184 times.
2/2
✓ Fully covered.
185 else if ( ++x == number ) {
2456 1 return;
2457 }
2458
2/2
✓ Branch 0 (1632→1633) taken 1 times.
✓ Branch 1 (1632→1634) taken 183 times.
2/2
✓ Fully covered.
184 else if ( ++x == number ) {
2459 1 return;
2460 }
2461
2/2
✓ Branch 0 (1634→1635) taken 1 times.
✓ Branch 1 (1634→1636) taken 182 times.
2/2
✓ Fully covered.
183 else if ( ++x == number ) {
2462 1 return;
2463 }
2464
2/2
✓ Branch 0 (1636→1637) taken 1 times.
✓ Branch 1 (1636→1638) taken 181 times.
2/2
✓ Fully covered.
182 else if ( ++x == number ) {
2465 1 return;
2466 }
2467
2/2
✓ Branch 0 (1638→1639) taken 1 times.
✓ Branch 1 (1638→1640) taken 180 times.
2/2
✓ Fully covered.
181 else if ( ++x == number ) {
2468 1 return;
2469 }
2470
2/2
✓ Branch 0 (1640→1641) taken 1 times.
✓ Branch 1 (1640→1642) taken 179 times.
2/2
✓ Fully covered.
180 else if ( ++x == number ) {
2471 1 return;
2472 }
2473
2/2
✓ Branch 0 (1642→1643) taken 1 times.
✓ Branch 1 (1642→1644) taken 178 times.
2/2
✓ Fully covered.
179 else if ( ++x == number ) {
2474 1 return;
2475 }
2476
2/2
✓ Branch 0 (1644→1645) taken 1 times.
✓ Branch 1 (1644→1646) taken 177 times.
2/2
✓ Fully covered.
178 else if ( ++x == number ) {
2477 1 return;
2478 }
2479
2/2
✓ Branch 0 (1646→1647) taken 1 times.
✓ Branch 1 (1646→1648) taken 176 times.
2/2
✓ Fully covered.
177 else if ( ++x == number ) {
2480 1 return;
2481 }
2482
2/2
✓ Branch 0 (1648→1649) taken 1 times.
✓ Branch 1 (1648→1650) taken 175 times.
2/2
✓ Fully covered.
176 else if ( ++x == number ) {
2483 1 return;
2484 }
2485
2/2
✓ Branch 0 (1650→1651) taken 1 times.
✓ Branch 1 (1650→1652) taken 174 times.
2/2
✓ Fully covered.
175 else if ( ++x == number ) {
2486 1 return;
2487 }
2488
2/2
✓ Branch 0 (1652→1653) taken 1 times.
✓ Branch 1 (1652→1654) taken 173 times.
2/2
✓ Fully covered.
174 else if ( ++x == number ) {
2489 1 return;
2490 }
2491
2/2
✓ Branch 0 (1654→1655) taken 1 times.
✓ Branch 1 (1654→1656) taken 172 times.
2/2
✓ Fully covered.
173 else if ( ++x == number ) {
2492 1 return;
2493 }
2494
2/2
✓ Branch 0 (1656→1657) taken 1 times.
✓ Branch 1 (1656→1658) taken 171 times.
2/2
✓ Fully covered.
172 else if ( ++x == number ) {
2495 1 return;
2496 }
2497
2/2
✓ Branch 0 (1658→1659) taken 1 times.
✓ Branch 1 (1658→1660) taken 170 times.
2/2
✓ Fully covered.
171 else if ( ++x == number ) {
2498 1 return;
2499 }
2500
2/2
✓ Branch 0 (1660→1661) taken 1 times.
✓ Branch 1 (1660→1662) taken 169 times.
2/2
✓ Fully covered.
170 else if ( ++x == number ) {
2501 1 return;
2502 }
2503
2/2
✓ Branch 0 (1662→1663) taken 1 times.
✓ Branch 1 (1662→1664) taken 168 times.
2/2
✓ Fully covered.
169 else if ( ++x == number ) {
2504 1 return;
2505 }
2506
2/2
✓ Branch 0 (1664→1665) taken 1 times.
✓ Branch 1 (1664→1666) taken 167 times.
2/2
✓ Fully covered.
168 else if ( ++x == number ) {
2507 1 return;
2508 }
2509
2/2
✓ Branch 0 (1666→1667) taken 1 times.
✓ Branch 1 (1666→1668) taken 166 times.
2/2
✓ Fully covered.
167 else if ( ++x == number ) {
2510 1 return;
2511 }
2512
2/2
✓ Branch 0 (1668→1669) taken 1 times.
✓ Branch 1 (1668→1670) taken 165 times.
2/2
✓ Fully covered.
166 else if ( ++x == number ) {
2513 1 return;
2514 }
2515
2/2
✓ Branch 0 (1670→1671) taken 1 times.
✓ Branch 1 (1670→1672) taken 164 times.
2/2
✓ Fully covered.
165 else if ( ++x == number ) {
2516 1 return;
2517 }
2518
2/2
✓ Branch 0 (1672→1673) taken 1 times.
✓ Branch 1 (1672→1674) taken 163 times.
2/2
✓ Fully covered.
164 else if ( ++x == number ) {
2519 1 return;
2520 }
2521
2/2
✓ Branch 0 (1674→1675) taken 1 times.
✓ Branch 1 (1674→1676) taken 162 times.
2/2
✓ Fully covered.
163 else if ( ++x == number ) {
2522 1 return;
2523 }
2524
2/2
✓ Branch 0 (1676→1677) taken 1 times.
✓ Branch 1 (1676→1678) taken 161 times.
2/2
✓ Fully covered.
162 else if ( ++x == number ) {
2525 1 return;
2526 }
2527
2/2
✓ Branch 0 (1678→1679) taken 1 times.
✓ Branch 1 (1678→1680) taken 160 times.
2/2
✓ Fully covered.
161 else if ( ++x == number ) {
2528 1 return;
2529 }
2530
2/2
✓ Branch 0 (1680→1681) taken 1 times.
✓ Branch 1 (1680→1682) taken 159 times.
2/2
✓ Fully covered.
160 else if ( ++x == number ) {
2531 1 return;
2532 }
2533
2/2
✓ Branch 0 (1682→1683) taken 1 times.
✓ Branch 1 (1682→1684) taken 158 times.
2/2
✓ Fully covered.
159 else if ( ++x == number ) {
2534 1 return;
2535 }
2536
2/2
✓ Branch 0 (1684→1685) taken 1 times.
✓ Branch 1 (1684→1686) taken 157 times.
2/2
✓ Fully covered.
158 else if ( ++x == number ) {
2537 1 return;
2538 }
2539
2/2
✓ Branch 0 (1686→1687) taken 1 times.
✓ Branch 1 (1686→1688) taken 156 times.
2/2
✓ Fully covered.
157 else if ( ++x == number ) {
2540 1 return;
2541 }
2542
2/2
✓ Branch 0 (1688→1689) taken 1 times.
✓ Branch 1 (1688→1690) taken 155 times.
2/2
✓ Fully covered.
156 else if ( ++x == number ) {
2543 1 return;
2544 }
2545
2/2
✓ Branch 0 (1690→1691) taken 1 times.
✓ Branch 1 (1690→1692) taken 154 times.
2/2
✓ Fully covered.
155 else if ( ++x == number ) {
2546 1 return;
2547 }
2548
2/2
✓ Branch 0 (1692→1693) taken 1 times.
✓ Branch 1 (1692→1694) taken 153 times.
2/2
✓ Fully covered.
154 else if ( ++x == number ) {
2549 1 return;
2550 }
2551
2/2
✓ Branch 0 (1694→1695) taken 1 times.
✓ Branch 1 (1694→1696) taken 152 times.
2/2
✓ Fully covered.
153 else if ( ++x == number ) {
2552 1 return;
2553 }
2554
2/2
✓ Branch 0 (1696→1697) taken 1 times.
✓ Branch 1 (1696→1698) taken 151 times.
2/2
✓ Fully covered.
152 else if ( ++x == number ) {
2555 1 return;
2556 }
2557
2/2
✓ Branch 0 (1698→1699) taken 1 times.
✓ Branch 1 (1698→1700) taken 150 times.
2/2
✓ Fully covered.
151 else if ( ++x == number ) {
2558 1 return;
2559 }
2560
2/2
✓ Branch 0 (1700→1701) taken 1 times.
✓ Branch 1 (1700→1702) taken 149 times.
2/2
✓ Fully covered.
150 else if ( ++x == number ) {
2561 1 return;
2562 }
2563
2/2
✓ Branch 0 (1702→1703) taken 1 times.
✓ Branch 1 (1702→1704) taken 148 times.
2/2
✓ Fully covered.
149 else if ( ++x == number ) {
2564 1 return;
2565 }
2566
2/2
✓ Branch 0 (1704→1705) taken 1 times.
✓ Branch 1 (1704→1706) taken 147 times.
2/2
✓ Fully covered.
148 else if ( ++x == number ) {
2567 1 return;
2568 }
2569
2/2
✓ Branch 0 (1706→1707) taken 1 times.
✓ Branch 1 (1706→1708) taken 146 times.
2/2
✓ Fully covered.
147 else if ( ++x == number ) {
2570 1 return;
2571 }
2572
2/2
✓ Branch 0 (1708→1709) taken 1 times.
✓ Branch 1 (1708→1710) taken 145 times.
2/2
✓ Fully covered.
146 else if ( ++x == number ) {
2573 1 return;
2574 }
2575
2/2
✓ Branch 0 (1710→1711) taken 1 times.
✓ Branch 1 (1710→1712) taken 144 times.
2/2
✓ Fully covered.
145 else if ( ++x == number ) {
2576 1 return;
2577 }
2578
2/2
✓ Branch 0 (1712→1713) taken 1 times.
✓ Branch 1 (1712→1714) taken 143 times.
2/2
✓ Fully covered.
144 else if ( ++x == number ) {
2579 1 return;
2580 }
2581
2/2
✓ Branch 0 (1714→1715) taken 1 times.
✓ Branch 1 (1714→1716) taken 142 times.
2/2
✓ Fully covered.
143 else if ( ++x == number ) {
2582 1 return;
2583 }
2584
2/2
✓ Branch 0 (1716→1717) taken 1 times.
✓ Branch 1 (1716→1718) taken 141 times.
2/2
✓ Fully covered.
142 else if ( ++x == number ) {
2585 1 return;
2586 }
2587
2/2
✓ Branch 0 (1718→1719) taken 1 times.
✓ Branch 1 (1718→1720) taken 140 times.
2/2
✓ Fully covered.
141 else if ( ++x == number ) {
2588 1 return;
2589 }
2590
2/2
✓ Branch 0 (1720→1721) taken 1 times.
✓ Branch 1 (1720→1722) taken 139 times.
2/2
✓ Fully covered.
140 else if ( ++x == number ) {
2591 1 return;
2592 }
2593
2/2
✓ Branch 0 (1722→1723) taken 1 times.
✓ Branch 1 (1722→1724) taken 138 times.
2/2
✓ Fully covered.
139 else if ( ++x == number ) {
2594 1 return;
2595 }
2596
2/2
✓ Branch 0 (1724→1725) taken 1 times.
✓ Branch 1 (1724→1726) taken 137 times.
2/2
✓ Fully covered.
138 else if ( ++x == number ) {
2597 1 return;
2598 }
2599
2/2
✓ Branch 0 (1726→1727) taken 1 times.
✓ Branch 1 (1726→1728) taken 136 times.
2/2
✓ Fully covered.
137 else if ( ++x == number ) {
2600 1 return;
2601 }
2602
2/2
✓ Branch 0 (1728→1729) taken 1 times.
✓ Branch 1 (1728→1730) taken 135 times.
2/2
✓ Fully covered.
136 else if ( ++x == number ) {
2603 1 return;
2604 }
2605
2/2
✓ Branch 0 (1730→1731) taken 1 times.
✓ Branch 1 (1730→1732) taken 134 times.
2/2
✓ Fully covered.
135 else if ( ++x == number ) {
2606 1 return;
2607 }
2608
2/2
✓ Branch 0 (1732→1733) taken 1 times.
✓ Branch 1 (1732→1734) taken 133 times.
2/2
✓ Fully covered.
134 else if ( ++x == number ) {
2609 1 return;
2610 }
2611
2/2
✓ Branch 0 (1734→1735) taken 1 times.
✓ Branch 1 (1734→1736) taken 132 times.
2/2
✓ Fully covered.
133 else if ( ++x == number ) {
2612 1 return;
2613 }
2614
2/2
✓ Branch 0 (1736→1737) taken 1 times.
✓ Branch 1 (1736→1738) taken 131 times.
2/2
✓ Fully covered.
132 else if ( ++x == number ) {
2615 1 return;
2616 }
2617
2/2
✓ Branch 0 (1738→1739) taken 1 times.
✓ Branch 1 (1738→1740) taken 130 times.
2/2
✓ Fully covered.
131 else if ( ++x == number ) {
2618 1 return;
2619 }
2620
2/2
✓ Branch 0 (1740→1741) taken 1 times.
✓ Branch 1 (1740→1742) taken 129 times.
2/2
✓ Fully covered.
130 else if ( ++x == number ) {
2621 1 return;
2622 }
2623
2/2
✓ Branch 0 (1742→1743) taken 1 times.
✓ Branch 1 (1742→1744) taken 128 times.
2/2
✓ Fully covered.
129 else if ( ++x == number ) {
2624 1 return;
2625 }
2626
2/2
✓ Branch 0 (1744→1745) taken 1 times.
✓ Branch 1 (1744→1746) taken 127 times.
2/2
✓ Fully covered.
128 else if ( ++x == number ) {
2627 1 return;
2628 }
2629
2/2
✓ Branch 0 (1746→1747) taken 1 times.
✓ Branch 1 (1746→1748) taken 126 times.
2/2
✓ Fully covered.
127 else if ( ++x == number ) {
2630 1 return;
2631 }
2632
2/2
✓ Branch 0 (1748→1749) taken 1 times.
✓ Branch 1 (1748→1750) taken 125 times.
2/2
✓ Fully covered.
126 else if ( ++x == number ) {
2633 1 return;
2634 }
2635
2/2
✓ Branch 0 (1750→1751) taken 1 times.
✓ Branch 1 (1750→1752) taken 124 times.
2/2
✓ Fully covered.
125 else if ( ++x == number ) {
2636 1 return;
2637 }
2638
2/2
✓ Branch 0 (1752→1753) taken 1 times.
✓ Branch 1 (1752→1754) taken 123 times.
2/2
✓ Fully covered.
124 else if ( ++x == number ) {
2639 1 return;
2640 }
2641
2/2
✓ Branch 0 (1754→1755) taken 1 times.
✓ Branch 1 (1754→1756) taken 122 times.
2/2
✓ Fully covered.
123 else if ( ++x == number ) {
2642 1 return;
2643 }
2644
2/2
✓ Branch 0 (1756→1757) taken 1 times.
✓ Branch 1 (1756→1758) taken 121 times.
2/2
✓ Fully covered.
122 else if ( ++x == number ) {
2645 1 return;
2646 }
2647
2/2
✓ Branch 0 (1758→1759) taken 1 times.
✓ Branch 1 (1758→1760) taken 120 times.
2/2
✓ Fully covered.
121 else if ( ++x == number ) {
2648 1 return;
2649 }
2650
2/2
✓ Branch 0 (1760→1761) taken 1 times.
✓ Branch 1 (1760→1762) taken 119 times.
2/2
✓ Fully covered.
120 else if ( ++x == number ) {
2651 1 return;
2652 }
2653
2/2
✓ Branch 0 (1762→1763) taken 1 times.
✓ Branch 1 (1762→1764) taken 118 times.
2/2
✓ Fully covered.
119 else if ( ++x == number ) {
2654 1 return;
2655 }
2656
2/2
✓ Branch 0 (1764→1765) taken 1 times.
✓ Branch 1 (1764→1766) taken 117 times.
2/2
✓ Fully covered.
118 else if ( ++x == number ) {
2657 1 return;
2658 }
2659
2/2
✓ Branch 0 (1766→1767) taken 1 times.
✓ Branch 1 (1766→1768) taken 116 times.
2/2
✓ Fully covered.
117 else if ( ++x == number ) {
2660 1 return;
2661 }
2662
2/2
✓ Branch 0 (1768→1769) taken 1 times.
✓ Branch 1 (1768→1770) taken 115 times.
2/2
✓ Fully covered.
116 else if ( ++x == number ) {
2663 1 return;
2664 }
2665
2/2
✓ Branch 0 (1770→1771) taken 1 times.
✓ Branch 1 (1770→1772) taken 114 times.
2/2
✓ Fully covered.
115 else if ( ++x == number ) {
2666 1 return;
2667 }
2668
2/2
✓ Branch 0 (1772→1773) taken 1 times.
✓ Branch 1 (1772→1774) taken 113 times.
2/2
✓ Fully covered.
114 else if ( ++x == number ) {
2669 1 return;
2670 }
2671
2/2
✓ Branch 0 (1774→1775) taken 1 times.
✓ Branch 1 (1774→1776) taken 112 times.
2/2
✓ Fully covered.
113 else if ( ++x == number ) {
2672 1 return;
2673 }
2674
2/2
✓ Branch 0 (1776→1777) taken 1 times.
✓ Branch 1 (1776→1778) taken 111 times.
2/2
✓ Fully covered.
112 else if ( ++x == number ) {
2675 1 return;
2676 }
2677
2/2
✓ Branch 0 (1778→1779) taken 1 times.
✓ Branch 1 (1778→1780) taken 110 times.
2/2
✓ Fully covered.
111 else if ( ++x == number ) {
2678 1 return;
2679 }
2680
2/2
✓ Branch 0 (1780→1781) taken 1 times.
✓ Branch 1 (1780→1782) taken 109 times.
2/2
✓ Fully covered.
110 else if ( ++x == number ) {
2681 1 return;
2682 }
2683
2/2
✓ Branch 0 (1782→1783) taken 1 times.
✓ Branch 1 (1782→1784) taken 108 times.
2/2
✓ Fully covered.
109 else if ( ++x == number ) {
2684 1 return;
2685 }
2686
2/2
✓ Branch 0 (1784→1785) taken 1 times.
✓ Branch 1 (1784→1786) taken 107 times.
2/2
✓ Fully covered.
108 else if ( ++x == number ) {
2687 1 return;
2688 }
2689
2/2
✓ Branch 0 (1786→1787) taken 1 times.
✓ Branch 1 (1786→1788) taken 106 times.
2/2
✓ Fully covered.
107 else if ( ++x == number ) {
2690 1 return;
2691 }
2692
2/2
✓ Branch 0 (1788→1789) taken 1 times.
✓ Branch 1 (1788→1790) taken 105 times.
2/2
✓ Fully covered.
106 else if ( ++x == number ) {
2693 1 return;
2694 }
2695
2/2
✓ Branch 0 (1790→1791) taken 1 times.
✓ Branch 1 (1790→1792) taken 104 times.
2/2
✓ Fully covered.
105 else if ( ++x == number ) {
2696 1 return;
2697 }
2698
2/2
✓ Branch 0 (1792→1793) taken 1 times.
✓ Branch 1 (1792→1794) taken 103 times.
2/2
✓ Fully covered.
104 else if ( ++x == number ) {
2699 1 return;
2700 }
2701
2/2
✓ Branch 0 (1794→1795) taken 1 times.
✓ Branch 1 (1794→1796) taken 102 times.
2/2
✓ Fully covered.
103 else if ( ++x == number ) {
2702 1 return;
2703 }
2704
2/2
✓ Branch 0 (1796→1797) taken 1 times.
✓ Branch 1 (1796→1798) taken 101 times.
2/2
✓ Fully covered.
102 else if ( ++x == number ) {
2705 1 return;
2706 }
2707
2/2
✓ Branch 0 (1798→1799) taken 1 times.
✓ Branch 1 (1798→1800) taken 100 times.
2/2
✓ Fully covered.
101 else if ( ++x == number ) {
2708 1 return;
2709 }
2710
2/2
✓ Branch 0 (1800→1801) taken 1 times.
✓ Branch 1 (1800→1802) taken 99 times.
2/2
✓ Fully covered.
100 else if ( ++x == number ) {
2711 1 return;
2712 }
2713
2/2
✓ Branch 0 (1802→1803) taken 1 times.
✓ Branch 1 (1802→1804) taken 98 times.
2/2
✓ Fully covered.
99 else if ( ++x == number ) {
2714 1 return;
2715 }
2716
2/2
✓ Branch 0 (1804→1805) taken 1 times.
✓ Branch 1 (1804→1806) taken 97 times.
2/2
✓ Fully covered.
98 else if ( ++x == number ) {
2717 1 return;
2718 }
2719
2/2
✓ Branch 0 (1806→1807) taken 1 times.
✓ Branch 1 (1806→1808) taken 96 times.
2/2
✓ Fully covered.
97 else if ( ++x == number ) {
2720 1 return;
2721 }
2722
2/2
✓ Branch 0 (1808→1809) taken 1 times.
✓ Branch 1 (1808→1810) taken 95 times.
2/2
✓ Fully covered.
96 else if ( ++x == number ) {
2723 1 return;
2724 }
2725
2/2
✓ Branch 0 (1810→1811) taken 1 times.
✓ Branch 1 (1810→1812) taken 94 times.
2/2
✓ Fully covered.
95 else if ( ++x == number ) {
2726 1 return;
2727 }
2728
2/2
✓ Branch 0 (1812→1813) taken 1 times.
✓ Branch 1 (1812→1814) taken 93 times.
2/2
✓ Fully covered.
94 else if ( ++x == number ) {
2729 1 return;
2730 }
2731
2/2
✓ Branch 0 (1814→1815) taken 1 times.
✓ Branch 1 (1814→1816) taken 92 times.
2/2
✓ Fully covered.
93 else if ( ++x == number ) {
2732 1 return;
2733 }
2734
2/2
✓ Branch 0 (1816→1817) taken 1 times.
✓ Branch 1 (1816→1818) taken 91 times.
2/2
✓ Fully covered.
92 else if ( ++x == number ) {
2735 1 return;
2736 }
2737
2/2
✓ Branch 0 (1818→1819) taken 1 times.
✓ Branch 1 (1818→1820) taken 90 times.
2/2
✓ Fully covered.
91 else if ( ++x == number ) {
2738 1 return;
2739 }
2740
2/2
✓ Branch 0 (1820→1821) taken 1 times.
✓ Branch 1 (1820→1822) taken 89 times.
2/2
✓ Fully covered.
90 else if ( ++x == number ) {
2741 1 return;
2742 }
2743
2/2
✓ Branch 0 (1822→1823) taken 1 times.
✓ Branch 1 (1822→1824) taken 88 times.
2/2
✓ Fully covered.
89 else if ( ++x == number ) {
2744 1 return;
2745 }
2746
2/2
✓ Branch 0 (1824→1825) taken 1 times.
✓ Branch 1 (1824→1826) taken 87 times.
2/2
✓ Fully covered.
88 else if ( ++x == number ) {
2747 1 return;
2748 }
2749
2/2
✓ Branch 0 (1826→1827) taken 1 times.
✓ Branch 1 (1826→1828) taken 86 times.
2/2
✓ Fully covered.
87 else if ( ++x == number ) {
2750 1 return;
2751 }
2752
2/2
✓ Branch 0 (1828→1829) taken 1 times.
✓ Branch 1 (1828→1830) taken 85 times.
2/2
✓ Fully covered.
86 else if ( ++x == number ) {
2753 1 return;
2754 }
2755
2/2
✓ Branch 0 (1830→1831) taken 1 times.
✓ Branch 1 (1830→1832) taken 84 times.
2/2
✓ Fully covered.
85 else if ( ++x == number ) {
2756 1 return;
2757 }
2758
2/2
✓ Branch 0 (1832→1833) taken 1 times.
✓ Branch 1 (1832→1834) taken 83 times.
2/2
✓ Fully covered.
84 else if ( ++x == number ) {
2759 1 return;
2760 }
2761
2/2
✓ Branch 0 (1834→1835) taken 1 times.
✓ Branch 1 (1834→1836) taken 82 times.
2/2
✓ Fully covered.
83 else if ( ++x == number ) {
2762 1 return;
2763 }
2764
2/2
✓ Branch 0 (1836→1837) taken 1 times.
✓ Branch 1 (1836→1838) taken 81 times.
2/2
✓ Fully covered.
82 else if ( ++x == number ) {
2765 1 return;
2766 }
2767
2/2
✓ Branch 0 (1838→1839) taken 1 times.
✓ Branch 1 (1838→1840) taken 80 times.
2/2
✓ Fully covered.
81 else if ( ++x == number ) {
2768 1 return;
2769 }
2770
2/2
✓ Branch 0 (1840→1841) taken 1 times.
✓ Branch 1 (1840→1842) taken 79 times.
2/2
✓ Fully covered.
80 else if ( ++x == number ) {
2771 1 return;
2772 }
2773
2/2
✓ Branch 0 (1842→1843) taken 1 times.
✓ Branch 1 (1842→1844) taken 78 times.
2/2
✓ Fully covered.
79 else if ( ++x == number ) {
2774 1 return;
2775 }
2776
2/2
✓ Branch 0 (1844→1845) taken 1 times.
✓ Branch 1 (1844→1846) taken 77 times.
2/2
✓ Fully covered.
78 else if ( ++x == number ) {
2777 1 return;
2778 }
2779
2/2
✓ Branch 0 (1846→1847) taken 1 times.
✓ Branch 1 (1846→1848) taken 76 times.
2/2
✓ Fully covered.
77 else if ( ++x == number ) {
2780 1 return;
2781 }
2782
2/2
✓ Branch 0 (1848→1849) taken 1 times.
✓ Branch 1 (1848→1850) taken 75 times.
2/2
✓ Fully covered.
76 else if ( ++x == number ) {
2783 1 return;
2784 }
2785
2/2
✓ Branch 0 (1850→1851) taken 1 times.
✓ Branch 1 (1850→1852) taken 74 times.
2/2
✓ Fully covered.
75 else if ( ++x == number ) {
2786 1 return;
2787 }
2788
2/2
✓ Branch 0 (1852→1853) taken 1 times.
✓ Branch 1 (1852→1854) taken 73 times.
2/2
✓ Fully covered.
74 else if ( ++x == number ) {
2789 1 return;
2790 }
2791
2/2
✓ Branch 0 (1854→1855) taken 1 times.
✓ Branch 1 (1854→1856) taken 72 times.
2/2
✓ Fully covered.
73 else if ( ++x == number ) {
2792 1 return;
2793 }
2794
2/2
✓ Branch 0 (1856→1857) taken 1 times.
✓ Branch 1 (1856→1858) taken 71 times.
2/2
✓ Fully covered.
72 else if ( ++x == number ) {
2795 1 return;
2796 }
2797
2/2
✓ Branch 0 (1858→1859) taken 1 times.
✓ Branch 1 (1858→1860) taken 70 times.
2/2
✓ Fully covered.
71 else if ( ++x == number ) {
2798 1 return;
2799 }
2800
2/2
✓ Branch 0 (1860→1861) taken 1 times.
✓ Branch 1 (1860→1862) taken 69 times.
2/2
✓ Fully covered.
70 else if ( ++x == number ) {
2801 1 return;
2802 }
2803
2/2
✓ Branch 0 (1862→1863) taken 1 times.
✓ Branch 1 (1862→1864) taken 68 times.
2/2
✓ Fully covered.
69 else if ( ++x == number ) {
2804 1 return;
2805 }
2806
2/2
✓ Branch 0 (1864→1865) taken 1 times.
✓ Branch 1 (1864→1866) taken 67 times.
2/2
✓ Fully covered.
68 else if ( ++x == number ) {
2807 1 return;
2808 }
2809
2/2
✓ Branch 0 (1866→1867) taken 1 times.
✓ Branch 1 (1866→1868) taken 66 times.
2/2
✓ Fully covered.
67 else if ( ++x == number ) {
2810 1 return;
2811 }
2812
2/2
✓ Branch 0 (1868→1869) taken 1 times.
✓ Branch 1 (1868→1870) taken 65 times.
2/2
✓ Fully covered.
66 else if ( ++x == number ) {
2813 1 return;
2814 }
2815
2/2
✓ Branch 0 (1870→1871) taken 1 times.
✓ Branch 1 (1870→1872) taken 64 times.
2/2
✓ Fully covered.
65 else if ( ++x == number ) {
2816 1 return;
2817 }
2818
2/2
✓ Branch 0 (1872→1873) taken 1 times.
✓ Branch 1 (1872→1874) taken 63 times.
2/2
✓ Fully covered.
64 else if ( ++x == number ) {
2819 1 return;
2820 }
2821
2/2
✓ Branch 0 (1874→1875) taken 1 times.
✓ Branch 1 (1874→1876) taken 62 times.
2/2
✓ Fully covered.
63 else if ( ++x == number ) {
2822 1 return;
2823 }
2824
2/2
✓ Branch 0 (1876→1877) taken 1 times.
✓ Branch 1 (1876→1878) taken 61 times.
2/2
✓ Fully covered.
62 else if ( ++x == number ) {
2825 1 return;
2826 }
2827
2/2
✓ Branch 0 (1878→1879) taken 1 times.
✓ Branch 1 (1878→1880) taken 60 times.
2/2
✓ Fully covered.
61 else if ( ++x == number ) {
2828 1 return;
2829 }
2830
2/2
✓ Branch 0 (1880→1881) taken 1 times.
✓ Branch 1 (1880→1882) taken 59 times.
2/2
✓ Fully covered.
60 else if ( ++x == number ) {
2831 1 return;
2832 }
2833
2/2
✓ Branch 0 (1882→1883) taken 1 times.
✓ Branch 1 (1882→1884) taken 58 times.
2/2
✓ Fully covered.
59 else if ( ++x == number ) {
2834 1 return;
2835 }
2836
2/2
✓ Branch 0 (1884→1885) taken 1 times.
✓ Branch 1 (1884→1886) taken 57 times.
2/2
✓ Fully covered.
58 else if ( ++x == number ) {
2837 1 return;
2838 }
2839
2/2
✓ Branch 0 (1886→1887) taken 1 times.
✓ Branch 1 (1886→1888) taken 56 times.
2/2
✓ Fully covered.
57 else if ( ++x == number ) {
2840 1 return;
2841 }
2842
2/2
✓ Branch 0 (1888→1889) taken 1 times.
✓ Branch 1 (1888→1890) taken 55 times.
2/2
✓ Fully covered.
56 else if ( ++x == number ) {
2843 1 return;
2844 }
2845
2/2
✓ Branch 0 (1890→1891) taken 1 times.
✓ Branch 1 (1890→1892) taken 54 times.
2/2
✓ Fully covered.
55 else if ( ++x == number ) {
2846 1 return;
2847 }
2848
2/2
✓ Branch 0 (1892→1893) taken 1 times.
✓ Branch 1 (1892→1894) taken 53 times.
2/2
✓ Fully covered.
54 else if ( ++x == number ) {
2849 1 return;
2850 }
2851
2/2
✓ Branch 0 (1894→1895) taken 1 times.
✓ Branch 1 (1894→1896) taken 52 times.
2/2
✓ Fully covered.
53 else if ( ++x == number ) {
2852 1 return;
2853 }
2854
2/2
✓ Branch 0 (1896→1897) taken 1 times.
✓ Branch 1 (1896→1898) taken 51 times.
2/2
✓ Fully covered.
52 else if ( ++x == number ) {
2855 1 return;
2856 }
2857
2/2
✓ Branch 0 (1898→1899) taken 1 times.
✓ Branch 1 (1898→1900) taken 50 times.
2/2
✓ Fully covered.
51 else if ( ++x == number ) {
2858 1 return;
2859 }
2860
2/2
✓ Branch 0 (1900→1901) taken 1 times.
✓ Branch 1 (1900→1902) taken 49 times.
2/2
✓ Fully covered.
50 else if ( ++x == number ) {
2861 1 return;
2862 }
2863
2/2
✓ Branch 0 (1902→1903) taken 1 times.
✓ Branch 1 (1902→1904) taken 48 times.
2/2
✓ Fully covered.
49 else if ( ++x == number ) {
2864 1 return;
2865 }
2866
2/2
✓ Branch 0 (1904→1905) taken 1 times.
✓ Branch 1 (1904→1906) taken 47 times.
2/2
✓ Fully covered.
48 else if ( ++x == number ) {
2867 1 return;
2868 }
2869
2/2
✓ Branch 0 (1906→1907) taken 1 times.
✓ Branch 1 (1906→1908) taken 46 times.
2/2
✓ Fully covered.
47 else if ( ++x == number ) {
2870 1 return;
2871 }
2872
2/2
✓ Branch 0 (1908→1909) taken 1 times.
✓ Branch 1 (1908→1910) taken 45 times.
2/2
✓ Fully covered.
46 else if ( ++x == number ) {
2873 1 return;
2874 }
2875
2/2
✓ Branch 0 (1910→1911) taken 1 times.
✓ Branch 1 (1910→1912) taken 44 times.
2/2
✓ Fully covered.
45 else if ( ++x == number ) {
2876 1 return;
2877 }
2878
2/2
✓ Branch 0 (1912→1913) taken 1 times.
✓ Branch 1 (1912→1914) taken 43 times.
2/2
✓ Fully covered.
44 else if ( ++x == number ) {
2879 1 return;
2880 }
2881
2/2
✓ Branch 0 (1914→1915) taken 1 times.
✓ Branch 1 (1914→1916) taken 42 times.
2/2
✓ Fully covered.
43 else if ( ++x == number ) {
2882 1 return;
2883 }
2884
2/2
✓ Branch 0 (1916→1917) taken 1 times.
✓ Branch 1 (1916→1918) taken 41 times.
2/2
✓ Fully covered.
42 else if ( ++x == number ) {
2885 1 return;
2886 }
2887
2/2
✓ Branch 0 (1918→1919) taken 1 times.
✓ Branch 1 (1918→1920) taken 40 times.
2/2
✓ Fully covered.
41 else if ( ++x == number ) {
2888 1 return;
2889 }
2890
2/2
✓ Branch 0 (1920→1921) taken 1 times.
✓ Branch 1 (1920→1922) taken 39 times.
2/2
✓ Fully covered.
40 else if ( ++x == number ) {
2891 1 return;
2892 }
2893
2/2
✓ Branch 0 (1922→1923) taken 1 times.
✓ Branch 1 (1922→1924) taken 38 times.
2/2
✓ Fully covered.
39 else if ( ++x == number ) {
2894 1 return;
2895 }
2896
2/2
✓ Branch 0 (1924→1925) taken 1 times.
✓ Branch 1 (1924→1926) taken 37 times.
2/2
✓ Fully covered.
38 else if ( ++x == number ) {
2897 1 return;
2898 }
2899
2/2
✓ Branch 0 (1926→1927) taken 1 times.
✓ Branch 1 (1926→1928) taken 36 times.
2/2
✓ Fully covered.
37 else if ( ++x == number ) {
2900 1 return;
2901 }
2902
2/2
✓ Branch 0 (1928→1929) taken 1 times.
✓ Branch 1 (1928→1930) taken 35 times.
2/2
✓ Fully covered.
36 else if ( ++x == number ) {
2903 1 return;
2904 }
2905
2/2
✓ Branch 0 (1930→1931) taken 1 times.
✓ Branch 1 (1930→1932) taken 34 times.
2/2
✓ Fully covered.
35 else if ( ++x == number ) {
2906 1 return;
2907 }
2908
2/2
✓ Branch 0 (1932→1933) taken 1 times.
✓ Branch 1 (1932→1934) taken 33 times.
2/2
✓ Fully covered.
34 else if ( ++x == number ) {
2909 1 return;
2910 }
2911
2/2
✓ Branch 0 (1934→1935) taken 1 times.
✓ Branch 1 (1934→1936) taken 32 times.
2/2
✓ Fully covered.
33 else if ( ++x == number ) {
2912 1 return;
2913 }
2914
2/2
✓ Branch 0 (1936→1937) taken 1 times.
✓ Branch 1 (1936→1938) taken 31 times.
2/2
✓ Fully covered.
32 else if ( ++x == number ) {
2915 1 return;
2916 }
2917
2/2
✓ Branch 0 (1938→1939) taken 1 times.
✓ Branch 1 (1938→1940) taken 30 times.
2/2
✓ Fully covered.
31 else if ( ++x == number ) {
2918 1 return;
2919 }
2920
2/2
✓ Branch 0 (1940→1941) taken 1 times.
✓ Branch 1 (1940→1942) taken 29 times.
2/2
✓ Fully covered.
30 else if ( ++x == number ) {
2921 1 return;
2922 }
2923
2/2
✓ Branch 0 (1942→1943) taken 1 times.
✓ Branch 1 (1942→1944) taken 28 times.
2/2
✓ Fully covered.
29 else if ( ++x == number ) {
2924 1 return;
2925 }
2926
2/2
✓ Branch 0 (1944→1945) taken 1 times.
✓ Branch 1 (1944→1946) taken 27 times.
2/2
✓ Fully covered.
28 else if ( ++x == number ) {
2927 1 return;
2928 }
2929
2/2
✓ Branch 0 (1946→1947) taken 1 times.
✓ Branch 1 (1946→1948) taken 26 times.
2/2
✓ Fully covered.
27 else if ( ++x == number ) {
2930 1 return;
2931 }
2932
2/2
✓ Branch 0 (1948→1949) taken 1 times.
✓ Branch 1 (1948→1950) taken 25 times.
2/2
✓ Fully covered.
26 else if ( ++x == number ) {
2933 1 return;
2934 }
2935
2/2
✓ Branch 0 (1950→1951) taken 1 times.
✓ Branch 1 (1950→1952) taken 24 times.
2/2
✓ Fully covered.
25 else if ( ++x == number ) {
2936 1 return;
2937 }
2938
2/2
✓ Branch 0 (1952→1953) taken 1 times.
✓ Branch 1 (1952→1954) taken 23 times.
2/2
✓ Fully covered.
24 else if ( ++x == number ) {
2939 1 return;
2940 }
2941
2/2
✓ Branch 0 (1954→1955) taken 1 times.
✓ Branch 1 (1954→1956) taken 22 times.
2/2
✓ Fully covered.
23 else if ( ++x == number ) {
2942 1 return;
2943 }
2944
2/2
✓ Branch 0 (1956→1957) taken 1 times.
✓ Branch 1 (1956→1958) taken 21 times.
2/2
✓ Fully covered.
22 else if ( ++x == number ) {
2945 1 return;
2946 }
2947
2/2
✓ Branch 0 (1958→1959) taken 1 times.
✓ Branch 1 (1958→1960) taken 20 times.
2/2
✓ Fully covered.
21 else if ( ++x == number ) {
2948 1 return;
2949 }
2950
2/2
✓ Branch 0 (1960→1961) taken 1 times.
✓ Branch 1 (1960→1962) taken 19 times.
2/2
✓ Fully covered.
20 else if ( ++x == number ) {
2951 1 return;
2952 }
2953
2/2
✓ Branch 0 (1962→1963) taken 1 times.
✓ Branch 1 (1962→1964) taken 18 times.
2/2
✓ Fully covered.
19 else if ( ++x == number ) {
2954 1 return;
2955 }
2956
2/2
✓ Branch 0 (1964→1965) taken 1 times.
✓ Branch 1 (1964→1966) taken 17 times.
2/2
✓ Fully covered.
18 else if ( ++x == number ) {
2957 1 return;
2958 }
2959
2/2
✓ Branch 0 (1966→1967) taken 1 times.
✓ Branch 1 (1966→1968) taken 16 times.
2/2
✓ Fully covered.
17 else if ( ++x == number ) {
2960 1 return;
2961 }
2962
2/2
✓ Branch 0 (1968→1969) taken 1 times.
✓ Branch 1 (1968→1970) taken 15 times.
2/2
✓ Fully covered.
16 else if ( ++x == number ) {
2963 1 return;
2964 }
2965
2/2
✓ Branch 0 (1970→1971) taken 1 times.
✓ Branch 1 (1970→1972) taken 14 times.
2/2
✓ Fully covered.
15 else if ( ++x == number ) {
2966 1 return;
2967 }
2968
2/2
✓ Branch 0 (1972→1973) taken 1 times.
✓ Branch 1 (1972→1974) taken 13 times.
2/2
✓ Fully covered.
14 else if ( ++x == number ) {
2969 1 return;
2970 }
2971
2/2
✓ Branch 0 (1974→1975) taken 1 times.
✓ Branch 1 (1974→1976) taken 12 times.
2/2
✓ Fully covered.
13 else if ( ++x == number ) {
2972 1 return;
2973 }
2974
2/2
✓ Branch 0 (1976→1977) taken 1 times.
✓ Branch 1 (1976→1978) taken 11 times.
2/2
✓ Fully covered.
12 else if ( ++x == number ) {
2975 1 return;
2976 }
2977
2/2
✓ Branch 0 (1978→1979) taken 1 times.
✓ Branch 1 (1978→1980) taken 10 times.
2/2
✓ Fully covered.
11 else if ( ++x == number ) {
2978 1 return;
2979 }
2980
2/2
✓ Branch 0 (1980→1981) taken 1 times.
✓ Branch 1 (1980→1982) taken 9 times.
2/2
✓ Fully covered.
10 else if ( ++x == number ) {
2981 1 return;
2982 }
2983
2/2
✓ Branch 0 (1982→1983) taken 1 times.
✓ Branch 1 (1982→1984) taken 8 times.
2/2
✓ Fully covered.
9 else if ( ++x == number ) {
2984 1 return;
2985 }
2986
2/2
✓ Branch 0 (1984→1985) taken 1 times.
✓ Branch 1 (1984→1986) taken 7 times.
2/2
✓ Fully covered.
8 else if ( ++x == number ) {
2987 1 return;
2988 }
2989
2/2
✓ Branch 0 (1986→1987) taken 1 times.
✓ Branch 1 (1986→1988) taken 6 times.
2/2
✓ Fully covered.
7 else if ( ++x == number ) {
2990 1 return;
2991 }
2992
2/2
✓ Branch 0 (1988→1989) taken 1 times.
✓ Branch 1 (1988→1990) taken 5 times.
2/2
✓ Fully covered.
6 else if ( ++x == number ) {
2993 1 return;
2994 }
2995
2/2
✓ Branch 0 (1990→1991) taken 1 times.
✓ Branch 1 (1990→1992) taken 4 times.
2/2
✓ Fully covered.
5 else if ( ++x == number ) {
2996 1 return;
2997 }
2998
2/2
✓ Branch 0 (1992→1993) taken 1 times.
✓ Branch 1 (1992→1994) taken 3 times.
2/2
✓ Fully covered.
4 else if ( ++x == number ) {
2999 1 return;
3000 }
3001
2/2
✓ Branch 0 (1994→1995) taken 1 times.
✓ Branch 1 (1994→1996) taken 2 times.
2/2
✓ Fully covered.
3 else if ( ++x == number ) {
3002 1 return;
3003 }
3004
2/2
✓ Branch 0 (1996→1997) taken 1 times.
✓ Branch 1 (1996→1998) taken 1 times.
2/2
✓ Fully covered.
2 else if ( ++x == number ) {
3005 1 return;
3006 }
3007
1/2
✗ Branch 0 (1998→1999) not taken.
✓ Branch 1 (1998→2000) taken 1 times.
1/2
✗ True not covered.
1 else if ( ++x == number ) {
3008 return;
3009 }
3010
3011 1 return;
3012 }
3013
3014