GCC Code Coverage Report

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