Flutter Engine
The Flutter Engine
PathOpsSimplifyTest.cpp
Go to the documentation of this file.
1/*
2 * Copyright 2012 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7#include "include/core/SkMatrix.h"
8#include "include/core/SkPath.h"
9#include "include/core/SkPathTypes.h"
10#include "include/core/SkRect.h"
11#include "include/core/SkScalar.h"
12#include "include/core/SkTypes.h"
13#include "include/pathops/SkPathOps.h"
14#include "src/base/SkFloatBits.h"
15#include "src/pathops/SkPathOpsDebug.h"
16#include "tests/PathOpsExtendedTest.h"
17#include "tests/Test.h"
18
19#include <cstddef>
20#include <iterator>
21
22#define TEST(name) { name, #name }
23
24static void testDegenerates(skiatest::Reporter* reporter, const char* filename) {
25 SkPath doubleback;
26 SkPath simple;
27
28 doubleback.lineTo(1, 0);
29 REPORTER_ASSERT(reporter, Simplify(doubleback, &simple));
30 REPORTER_ASSERT(reporter, simple.isEmpty());
31
32 doubleback.reset();
33 doubleback.lineTo(1, 0);
34 doubleback.lineTo(2, 0);
35 REPORTER_ASSERT(reporter, Simplify(doubleback, &simple));
36 REPORTER_ASSERT(reporter, simple.isEmpty());
37
38 doubleback.reset();
39 doubleback.lineTo(-1, 0);
40 doubleback.lineTo(-1, 1);
41 doubleback.lineTo(-1, 0);
42 REPORTER_ASSERT(reporter, Simplify(doubleback, &simple));
43 REPORTER_ASSERT(reporter, simple.isEmpty());
44
45 doubleback.reset();
46 doubleback.lineTo(1, 0);
47 doubleback.lineTo(1, 0);
48 doubleback.lineTo(1, 1);
49 doubleback.lineTo(1, 1);
50 doubleback.lineTo(1, 0);
51 REPORTER_ASSERT(reporter, Simplify(doubleback, &simple));
52 REPORTER_ASSERT(reporter, simple.isEmpty());
53}
54
55static void testLine1(skiatest::Reporter* reporter, const char* filename) {
56 SkPath path;
57 path.moveTo(2,0);
58 path.lineTo(1,1);
59 path.lineTo(0,0);
60 path.close();
61 testSimplify(reporter, path, filename);
62}
63
64static void testLine1x(skiatest::Reporter* reporter, const char* filename) {
65 SkPath path;
66 path.setFillType(SkPathFillType::kEvenOdd);
67 path.moveTo(2,0);
68 path.lineTo(1,1);
69 path.lineTo(0,0);
70 path.close();
71 testSimplify(reporter, path, filename);
72}
73
74static void addInnerCWTriangle(SkPath& path) {
75 path.moveTo(3,0);
76 path.lineTo(4,1);
77 path.lineTo(2,1);
78 path.close();
79}
80
81static void addInnerCCWTriangle(SkPath& path) {
82 path.moveTo(3,0);
83 path.lineTo(2,1);
84 path.lineTo(4,1);
85 path.close();
86}
87
88static void addOuterCWTriangle(SkPath& path) {
89 path.moveTo(3,0);
90 path.lineTo(6,2);
91 path.lineTo(0,2);
92 path.close();
93}
94
95static void addOuterCCWTriangle(SkPath& path) {
96 path.moveTo(3,0);
97 path.lineTo(0,2);
98 path.lineTo(6,2);
99 path.close();
100}
101
102static void testLine2(skiatest::Reporter* reporter, const char* filename) {
103 SkPath path;
104 addInnerCWTriangle(path);
105 addOuterCWTriangle(path);
106 testSimplify(reporter, path, filename);
107}
108
109static void testLine2x(skiatest::Reporter* reporter, const char* filename) {
110 SkPath path;
111 path.setFillType(SkPathFillType::kEvenOdd);
112 addInnerCWTriangle(path);
113 addOuterCWTriangle(path);
114 testSimplify(reporter, path, filename);
115}
116
117static void testLine3(skiatest::Reporter* reporter, const char* filename) {
118 SkPath path;
119 addInnerCCWTriangle(path);
120 addOuterCWTriangle(path);
121 testSimplify(reporter, path, filename);
122}
123
124static void testLine3x(skiatest::Reporter* reporter, const char* filename) {
125 SkPath path;
126 path.setFillType(SkPathFillType::kEvenOdd);
127 addInnerCCWTriangle(path);
128 addOuterCWTriangle(path);
129 testSimplify(reporter, path, filename);
130}
131
132static void testLine3a(skiatest::Reporter* reporter, const char* filename) {
133 SkPath path;
134 addInnerCWTriangle(path);
135 addOuterCCWTriangle(path);
136 testSimplify(reporter, path, filename);
137}
138
139static void testLine3ax(skiatest::Reporter* reporter, const char* filename) {
140 SkPath path;
141 path.setFillType(SkPathFillType::kEvenOdd);
142 addInnerCWTriangle(path);
143 addOuterCCWTriangle(path);
144 testSimplify(reporter, path, filename);
145}
146
147static void testLine3b(skiatest::Reporter* reporter, const char* filename) {
148 SkPath path;
149 addInnerCCWTriangle(path);
150 addOuterCCWTriangle(path);
151 testSimplify(reporter, path, filename);
152}
153
154static void testLine3bx(skiatest::Reporter* reporter, const char* filename) {
155 SkPath path;
156 path.setFillType(SkPathFillType::kEvenOdd);
157 addInnerCCWTriangle(path);
158 addOuterCCWTriangle(path);
159 testSimplify(reporter, path, filename);
160}
161
162static void testLine4(skiatest::Reporter* reporter, const char* filename) {
163 SkPath path;
164 addOuterCCWTriangle(path);
165 addOuterCWTriangle(path);
166 testSimplify(reporter, path, filename);
167}
168
169static void testLine4x(skiatest::Reporter* reporter, const char* filename) {
170 SkPath path;
171 path.setFillType(SkPathFillType::kEvenOdd);
172 addOuterCCWTriangle(path);
173 addOuterCWTriangle(path);
174 testSimplify(reporter, path, filename);
175}
176
177static void testLine5(skiatest::Reporter* reporter, const char* filename) {
178 SkPath path;
179 addOuterCWTriangle(path);
180 addOuterCWTriangle(path);
181 testSimplify(reporter, path, filename);
182}
183
184static void testLine5x(skiatest::Reporter* reporter, const char* filename) {
185 SkPath path;
186 path.setFillType(SkPathFillType::kEvenOdd);
187 addOuterCWTriangle(path);
188 addOuterCWTriangle(path);
189 testSimplify(reporter, path, filename);
190}
191
192static void testLine6(skiatest::Reporter* reporter, const char* filename) {
193 SkPath path;
194 path.moveTo(0,0);
195 path.lineTo(4,0);
196 path.lineTo(2,2);
197 path.close();
198 path.moveTo(2,0);
199 path.lineTo(6,0);
200 path.lineTo(4,2);
201 path.close();
202 testSimplify(reporter, path, filename);
203}
204
205static void testLine6x(skiatest::Reporter* reporter, const char* filename) {
206 SkPath path;
207 path.setFillType(SkPathFillType::kEvenOdd);
208 path.moveTo(0,0);
209 path.lineTo(4,0);
210 path.lineTo(2,2);
211 path.close();
212 path.moveTo(2,0);
213 path.lineTo(6,0);
214 path.lineTo(4,2);
215 path.close();
216 testSimplify(reporter, path, filename);
217}
218
219static void testLine7(skiatest::Reporter* reporter, const char* filename) {
220 SkPath path;
221 path.moveTo(0,0);
222 path.lineTo(4,0);
223 path.lineTo(2,2);
224 path.close();
225 path.moveTo(6,0);
226 path.lineTo(2,0);
227 path.lineTo(4,2);
228 path.close();
229 testSimplify(reporter, path, filename);
230}
231
232static void testLine7x(skiatest::Reporter* reporter, const char* filename) {
233 SkPath path;
234 path.setFillType(SkPathFillType::kEvenOdd);
235 path.moveTo(0,0);
236 path.lineTo(4,0);
237 path.lineTo(2,2);
238 path.close();
239 path.moveTo(6,0);
240 path.lineTo(2,0);
241 path.lineTo(4,2);
242 path.close();
243 testSimplify(reporter, path, filename);
244}
245
246static void testLine7a(skiatest::Reporter* reporter, const char* filename) {
247 SkPath path;
248 path.moveTo(0,0);
249 path.lineTo(4,0);
250 path.lineTo(2,2);
251 path.close();
252 testSimplify(reporter, path, filename);
253}
254
255static void testLine7ax(skiatest::Reporter* reporter, const char* filename) {
256 SkPath path;
257 path.setFillType(SkPathFillType::kEvenOdd);
258 path.moveTo(0,0);
259 path.lineTo(4,0);
260 path.lineTo(2,2);
261 path.close();
262 testSimplify(reporter, path, filename);
263}
264
265static void testLine7b(skiatest::Reporter* reporter, const char* filename) {
266 SkPath path;
267 path.moveTo(0,0);
268 path.lineTo(4,0);
269 path.close();
270 path.moveTo(6,0);
271 path.lineTo(2,0);
272 path.lineTo(4,2);
273 path.close();
274 testSimplify(reporter, path, filename);
275}
276
277static void testLine7bx(skiatest::Reporter* reporter, const char* filename) {
278 SkPath path;
279 path.setFillType(SkPathFillType::kEvenOdd);
280 path.moveTo(0,0);
281 path.lineTo(4,0);
282 path.close();
283 path.moveTo(6,0);
284 path.lineTo(2,0);
285 path.lineTo(4,2);
286 path.close();
287 testSimplify(reporter, path, filename);
288}
289
290static void testLine8(skiatest::Reporter* reporter, const char* filename) {
291 SkPath path;
292 path.moveTo(0,4);
293 path.lineTo(4,4);
294 path.lineTo(2,2);
295 path.close();
296 path.moveTo(2,4);
297 path.lineTo(6,4);
298 path.lineTo(4,2);
299 path.close();
300 testSimplify(reporter, path, filename);
301}
302
303static void testLine8x(skiatest::Reporter* reporter, const char* filename) {
304 SkPath path;
305 path.setFillType(SkPathFillType::kEvenOdd);
306 path.moveTo(0,4);
307 path.lineTo(4,4);
308 path.lineTo(2,2);
309 path.close();
310 path.moveTo(2,4);
311 path.lineTo(6,4);
312 path.lineTo(4,2);
313 path.close();
314 testSimplify(reporter, path, filename);
315}
316
317static void testLine9(skiatest::Reporter* reporter, const char* filename) {
318 SkPath path;
319 path.moveTo(0,4);
320 path.lineTo(4,4);
321 path.lineTo(2,2);
322 path.close();
323 path.moveTo(6,4);
324 path.lineTo(2,4);
325 path.lineTo(4,2);
326 path.close();
327 testSimplify(reporter, path, filename);
328}
329
330static void testLine9x(skiatest::Reporter* reporter, const char* filename) {
331 SkPath path;
332 path.setFillType(SkPathFillType::kEvenOdd);
333 path.moveTo(0,4);
334 path.lineTo(4,4);
335 path.lineTo(2,2);
336 path.close();
337 path.moveTo(6,4);
338 path.lineTo(2,4);
339 path.lineTo(4,2);
340 path.close();
341 testSimplify(reporter, path, filename);
342}
343
344static void testLine10(skiatest::Reporter* reporter, const char* filename) {
345 SkPath path;
346 path.moveTo(0,4);
347 path.lineTo(4,4);
348 path.lineTo(2,2);
349 path.close();
350 path.moveTo(2,1);
351 path.lineTo(3,4);
352 path.lineTo(6,1);
353 path.close();
354 testSimplify(reporter, path, filename);
355}
356
357static void testLine10x(skiatest::Reporter* reporter, const char* filename) {
358 SkPath path;
359 path.setFillType(SkPathFillType::kEvenOdd);
360 path.moveTo(0,4);
361 path.lineTo(4,4);
362 path.lineTo(2,2);
363 path.close();
364 path.moveTo(2,1);
365 path.lineTo(3,4);
366 path.lineTo(6,1);
367 path.close();
368 testSimplify(reporter, path, filename);
369}
370
371static void testLine10a(skiatest::Reporter* reporter, const char* filename) {
372 SkPath path;
373 path.moveTo(0,4);
374 path.lineTo(8,4);
375 path.lineTo(4,0);
376 path.close();
377 path.moveTo(2,2);
378 path.lineTo(3,3);
379 path.lineTo(4,2);
380 path.close();
381 testSimplify(reporter, path, filename);
382}
383
384static void testLine10ax(skiatest::Reporter* reporter, const char* filename) {
385 SkPath path;
386 path.setFillType(SkPathFillType::kEvenOdd);
387 path.moveTo(0,4);
388 path.lineTo(8,4);
389 path.lineTo(4,0);
390 path.close();
391 path.moveTo(2,2);
392 path.lineTo(3,3);
393 path.lineTo(4,2);
394 path.close();
395 testSimplify(reporter, path, filename);
396}
397
398static void addCWContainer(SkPath& path) {
399 path.moveTo(6,4);
400 path.lineTo(0,4);
401 path.lineTo(3,1);
402 path.close();
403}
404
405static void addCCWContainer(SkPath& path) {
406 path.moveTo(0,4);
407 path.lineTo(6,4);
408 path.lineTo(3,1);
409 path.close();
410}
411
412static void addCWContents(SkPath& path) {
413 path.moveTo(2,3);
414 path.lineTo(3,2);
415 path.lineTo(4,3);
416 path.close();
417}
418
419static void addCCWContents(SkPath& path) {
420 path.moveTo(3,2);
421 path.lineTo(2,3);
422 path.lineTo(4,3);
423 path.close();
424}
425
426static void testLine11(skiatest::Reporter* reporter, const char* filename) {
427 SkPath path;
428 addCWContainer(path);
429 addCWContents(path);
430 testSimplify(reporter, path, filename);
431}
432
433static void testLine11x(skiatest::Reporter* reporter, const char* filename) {
434 SkPath path;
435 path.setFillType(SkPathFillType::kEvenOdd);
436 addCWContainer(path);
437 addCWContents(path);
438 testSimplify(reporter, path, filename);
439}
440
441static void testLine12(skiatest::Reporter* reporter, const char* filename) {
442 SkPath path;
443 addCCWContainer(path);
444 addCWContents(path);
445 testSimplify(reporter, path, filename);
446}
447
448static void testLine12x(skiatest::Reporter* reporter, const char* filename) {
449 SkPath path;
450 path.setFillType(SkPathFillType::kEvenOdd);
451 addCCWContainer(path);
452 addCWContents(path);
453 testSimplify(reporter, path, filename);
454}
455
456static void testLine13(skiatest::Reporter* reporter, const char* filename) {
457 SkPath path;
458 addCWContainer(path);
459 addCCWContents(path);
460 testSimplify(reporter, path, filename);
461}
462
463static void testLine13x(skiatest::Reporter* reporter, const char* filename) {
464 SkPath path;
465 path.setFillType(SkPathFillType::kEvenOdd);
466 addCWContainer(path);
467 addCCWContents(path);
468 testSimplify(reporter, path, filename);
469}
470
471static void testLine14(skiatest::Reporter* reporter, const char* filename) {
472 SkPath path;
473 addCCWContainer(path);
474 addCCWContents(path);
475 testSimplify(reporter, path, filename);
476}
477
478static void testLine14x(skiatest::Reporter* reporter, const char* filename) {
479 SkPath path;
480 path.setFillType(SkPathFillType::kEvenOdd);
481 addCCWContainer(path);
482 addCCWContents(path);
483 testSimplify(reporter, path, filename);
484}
485
486static void testLine15(skiatest::Reporter* reporter, const char* filename) {
487 SkPath path;
488 path.addRect(0, 0, 9, 9, SkPathDirection::kCW);
489 testSimplify(reporter, path, filename);
490}
491
492static void testLine15x(skiatest::Reporter* reporter, const char* filename) {
493 SkPath path;
494 path.setFillType(SkPathFillType::kEvenOdd);
495 path.addRect(0, 0, 9, 9, SkPathDirection::kCW);
496 testSimplify(reporter, path, filename);
497}
498
499static void testLine16(skiatest::Reporter* reporter, const char* filename) {
500 SkPath path;
501 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
502 path.addRect(0, 4, 9, 9, SkPathDirection::kCW);
503 testSimplify(reporter, path, filename);
504}
505
506static void testLine16x(skiatest::Reporter* reporter, const char* filename) {
507 SkPath path;
508 path.setFillType(SkPathFillType::kEvenOdd);
509 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
510 path.addRect(0, 4, 9, 9, SkPathDirection::kCW);
511 testSimplify(reporter, path, filename);
512}
513
514static void testLine17(skiatest::Reporter* reporter, const char* filename) {
515 SkPath path;
516 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
517 path.addRect(4, 12, 13, 13, SkPathDirection::kCW);
518 testSimplify(reporter, path, filename);
519}
520
521static void testLine17x(skiatest::Reporter* reporter, const char* filename) {
522 SkPath path;
523 path.setFillType(SkPathFillType::kEvenOdd);
524 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
525 path.addRect(4, 12, 13, 13, SkPathDirection::kCW);
526 testSimplify(reporter, path, filename);
527}
528
529static void testLine18(skiatest::Reporter* reporter, const char* filename) {
530 SkPath path;
531 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
532 path.addRect(12, 4, 21, 21, SkPathDirection::kCW);
533 testSimplify(reporter, path, filename);
534}
535
536static void testLine18x(skiatest::Reporter* reporter, const char* filename) {
537 SkPath path;
538 path.setFillType(SkPathFillType::kEvenOdd);
539 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
540 path.addRect(12, 4, 21, 21, SkPathDirection::kCW);
541 testSimplify(reporter, path, filename);
542}
543
544static void testLine19(skiatest::Reporter* reporter, const char* filename) {
545 SkPath path;
546 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
547 path.addRect(12, 16, 21, 21, SkPathDirection::kCW);
548 testSimplify(reporter, path, filename);
549}
550
551static void testLine19x(skiatest::Reporter* reporter, const char* filename) {
552 SkPath path;
553 path.setFillType(SkPathFillType::kEvenOdd);
554 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
555 path.addRect(12, 16, 21, 21, SkPathDirection::kCW);
556 testSimplify(reporter, path, filename);
557}
558
559static void testLine20(skiatest::Reporter* reporter, const char* filename) {
560 SkPath path;
561 path.addRect(0, 12, 12, 12, SkPathDirection::kCW);
562 path.addRect(0, 12, 9, 9, SkPathDirection::kCW);
563 testSimplify(reporter, path, filename);
564}
565
566static void testLine20x(skiatest::Reporter* reporter, const char* filename) {
567 SkPath path;
568 path.setFillType(SkPathFillType::kEvenOdd);
569 path.addRect(0, 12, 12, 12, SkPathDirection::kCW);
570 path.addRect(0, 12, 9, 9, SkPathDirection::kCW);
571 testSimplify(reporter, path, filename);
572}
573
574static void testLine21(skiatest::Reporter* reporter, const char* filename) {
575 SkPath path;
576 path.addRect(0, 12, 12, 12, SkPathDirection::kCW);
577 path.addRect(0, 16, 9, 9, SkPathDirection::kCW);
578 testSimplify(reporter, path, filename);
579}
580
581static void testLine21x(skiatest::Reporter* reporter, const char* filename) {
582 SkPath path;
583 path.setFillType(SkPathFillType::kEvenOdd);
584 path.addRect(0, 12, 12, 12, SkPathDirection::kCW);
585 path.addRect(0, 16, 9, 9, SkPathDirection::kCW);
586 testSimplify(reporter, path, filename);
587}
588
589static void testLine22(skiatest::Reporter* reporter, const char* filename) {
590 SkPath path;
591 path.addRect(0, 12, 12, 12, SkPathDirection::kCW);
592 path.addRect(4, 12, 13, 13, SkPathDirection::kCW);
593 testSimplify(reporter, path, filename);
594}
595
596static void testLine22x(skiatest::Reporter* reporter, const char* filename) {
597 SkPath path;
598 path.setFillType(SkPathFillType::kEvenOdd);
599 path.addRect(0, 12, 12, 12, SkPathDirection::kCW);
600 path.addRect(4, 12, 13, 13, SkPathDirection::kCW);
601 testSimplify(reporter, path, filename);
602}
603
604static void testLine23(skiatest::Reporter* reporter, const char* filename) {
605 SkPath path;
606 path.addRect(0, 12, 12, 12, SkPathDirection::kCW);
607 path.addRect(12, 0, 21, 21, SkPathDirection::kCW);
608 testSimplify(reporter, path, filename);
609}
610
611static void testLine23x(skiatest::Reporter* reporter, const char* filename) {
612 SkPath path;
613 path.setFillType(SkPathFillType::kEvenOdd);
614 path.addRect(0, 12, 12, 12, SkPathDirection::kCW);
615 path.addRect(12, 0, 21, 21, SkPathDirection::kCW);
616 testSimplify(reporter, path, filename);
617}
618
619static void testLine24a(skiatest::Reporter* reporter, const char* filename) {
620 SkPath path;
621 path.moveTo(2,0);
622 path.lineTo(4,4);
623 path.lineTo(0,4);
624 path.close();
625 path.moveTo(2,0);
626 path.lineTo(1,2);
627 path.lineTo(2,2);
628 path.close();
629 testSimplify(reporter, path, filename);
630}
631
632static void testLine24ax(skiatest::Reporter* reporter, const char* filename) {
633 SkPath path;
634 path.setFillType(SkPathFillType::kEvenOdd);
635 path.moveTo(2,0);
636 path.lineTo(4,4);
637 path.lineTo(0,4);
638 path.close();
639 path.moveTo(2,0);
640 path.lineTo(1,2);
641 path.lineTo(2,2);
642 path.close();
643 testSimplify(reporter, path, filename);
644}
645
646static void testLine24(skiatest::Reporter* reporter, const char* filename) {
647 SkPath path;
648 path.addRect(0, 18, 12, 12, SkPathDirection::kCW);
649 path.addRect(4, 12, 13, 13, SkPathDirection::kCW);
650 testSimplify(reporter, path, filename);
651}
652
653static void testLine24x(skiatest::Reporter* reporter, const char* filename) {
654 SkPath path;
655 path.setFillType(SkPathFillType::kEvenOdd);
656 path.addRect(0, 18, 12, 12, SkPathDirection::kCW);
657 path.addRect(4, 12, 13, 13, SkPathDirection::kCW);
658 testSimplify(reporter, path, filename);
659}
660
661static void testLine25(skiatest::Reporter* reporter, const char* filename) {
662 SkPath path;
663 path.addRect(0, 6, 12, 12, SkPathDirection::kCW);
664 path.addRect(12, 0, 21, 21, SkPathDirection::kCW);
665 testSimplify(reporter, path, filename);
666}
667
668static void testLine25x(skiatest::Reporter* reporter, const char* filename) {
669 SkPath path;
670 path.setFillType(SkPathFillType::kEvenOdd);
671 path.addRect(0, 6, 12, 12, SkPathDirection::kCW);
672 path.addRect(12, 0, 21, 21, SkPathDirection::kCW);
673 testSimplify(reporter, path, filename);
674}
675
676static void testLine26(skiatest::Reporter* reporter, const char* filename) {
677 SkPath path;
678 path.addRect(0, 18, 12, 12, SkPathDirection::kCW);
679 path.addRect(0, 12, 9, 9, SkPathDirection::kCW);
680 testSimplify(reporter, path, filename);
681}
682
683static void testLine26x(skiatest::Reporter* reporter, const char* filename) {
684 SkPath path;
685 path.setFillType(SkPathFillType::kEvenOdd);
686 path.addRect(0, 18, 12, 12, SkPathDirection::kCW);
687 path.addRect(0, 12, 9, 9, SkPathDirection::kCW);
688 testSimplify(reporter, path, filename);
689}
690
691static void testLine27(skiatest::Reporter* reporter, const char* filename) {
692 SkPath path;
693 path.addRect(0, 18, 12, 12, SkPathDirection::kCW);
694 path.addRect(12, 8, 21, 21, SkPathDirection::kCW);
695 testSimplify(reporter, path, filename);
696}
697
698static void testLine27x(skiatest::Reporter* reporter, const char* filename) {
699 SkPath path;
700 path.setFillType(SkPathFillType::kEvenOdd);
701 path.addRect(0, 18, 12, 12, SkPathDirection::kCW);
702 path.addRect(12, 8, 21, 21, SkPathDirection::kCW);
703 testSimplify(reporter, path, filename);
704}
705
706static void testLine28(skiatest::Reporter* reporter, const char* filename) {
707 SkPath path;
708 path.addRect(0, 6, 12, 12, SkPathDirection::kCW);
709 path.addRect(0, 0, 9, 9, SkPathDirection::kCW);
710 testSimplify(reporter, path, filename);
711}
712
713static void testLine28x(skiatest::Reporter* reporter, const char* filename) {
714 SkPath path;
715 path.setFillType(SkPathFillType::kEvenOdd);
716 path.addRect(0, 6, 12, 12, SkPathDirection::kCW);
717 path.addRect(0, 0, 9, 9, SkPathDirection::kCW);
718 testSimplify(reporter, path, filename);
719}
720
721static void testLine29(skiatest::Reporter* reporter, const char* filename) {
722 SkPath path;
723 path.addRect(0, 18, 12, 12, SkPathDirection::kCW);
724 path.addRect(12, 12, 21, 21, SkPathDirection::kCW);
725 testSimplify(reporter, path, filename);
726}
727
728static void testLine29x(skiatest::Reporter* reporter, const char* filename) {
729 SkPath path;
730 path.setFillType(SkPathFillType::kEvenOdd);
731 path.addRect(0, 18, 12, 12, SkPathDirection::kCW);
732 path.addRect(12, 12, 21, 21, SkPathDirection::kCW);
733 testSimplify(reporter, path, filename);
734}
735
736static void testLine30(skiatest::Reporter* reporter, const char* filename) {
737 SkPath path;
738 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
739 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
740 path.addRect(4, 4, 13, 13, SkPathDirection::kCW);
741 testSimplify(reporter, path, filename);
742}
743
744static void testLine30x(skiatest::Reporter* reporter, const char* filename) {
745 SkPath path;
746 path.setFillType(SkPathFillType::kEvenOdd);
747 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
748 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
749 path.addRect(4, 4, 13, 13, SkPathDirection::kCW);
750 testSimplify(reporter, path, filename);
751}
752
753static void testLine31(skiatest::Reporter* reporter, const char* filename) {
754 SkPath path;
755 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
756 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
757 path.addRect(0, 4, 9, 9, SkPathDirection::kCW);
758 testSimplify(reporter, path, filename);
759}
760
761static void testLine31x(skiatest::Reporter* reporter, const char* filename) {
762 SkPath path;
763 path.setFillType(SkPathFillType::kEvenOdd);
764 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
765 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
766 path.addRect(0, 4, 9, 9, SkPathDirection::kCW);
767 testSimplify(reporter, path, filename);
768}
769
770static void testLine32(skiatest::Reporter* reporter, const char* filename) {
771 SkPath path;
772 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
773 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
774 path.addRect(4, 12, 13, 13, SkPathDirection::kCW);
775 testSimplify(reporter, path, filename);
776}
777
778static void testLine32x(skiatest::Reporter* reporter, const char* filename) {
779 SkPath path;
780 path.setFillType(SkPathFillType::kEvenOdd);
781 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
782 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
783 path.addRect(4, 12, 13, 13, SkPathDirection::kCW);
784 testSimplify(reporter, path, filename);
785}
786
787static void testLine33(skiatest::Reporter* reporter, const char* filename) {
788 SkPath path;
789 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
790 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
791 path.addRect(4, 16, 13, 13, SkPathDirection::kCW);
792 testSimplify(reporter, path, filename);
793}
794
795static void testLine33x(skiatest::Reporter* reporter, const char* filename) {
796 SkPath path;
797 path.setFillType(SkPathFillType::kEvenOdd);
798 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
799 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
800 path.addRect(4, 16, 13, 13, SkPathDirection::kCW);
801 testSimplify(reporter, path, filename);
802}
803
804static void testLine34(skiatest::Reporter* reporter, const char* filename) {
805 SkPath path;
806 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
807 path.addRect(0, 6, 12, 12, SkPathDirection::kCW);
808 path.addRect(4, 12, 13, 13, SkPathDirection::kCW);
809 testSimplify(reporter, path, filename);
810}
811
812static void testLine34x(skiatest::Reporter* reporter, const char* filename) {
813 SkPath path;
814 path.setFillType(SkPathFillType::kEvenOdd);
815 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
816 path.addRect(0, 6, 12, 12, SkPathDirection::kCW);
817 path.addRect(4, 12, 13, 13, SkPathDirection::kCW);
818 testSimplify(reporter, path, filename);
819}
820
821static void testLine35(skiatest::Reporter* reporter, const char* filename) {
822 SkPath path;
823 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
824 path.addRect(6, 0, 18, 18, SkPathDirection::kCW);
825 path.addRect(4, 16, 13, 13, SkPathDirection::kCW);
826 testSimplify(reporter, path, filename);
827}
828
829static void testLine35x(skiatest::Reporter* reporter, const char* filename) {
830 SkPath path;
831 path.setFillType(SkPathFillType::kEvenOdd);
832 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
833 path.addRect(6, 0, 18, 18, SkPathDirection::kCW);
834 path.addRect(4, 16, 13, 13, SkPathDirection::kCW);
835 testSimplify(reporter, path, filename);
836}
837
838static void testLine36(skiatest::Reporter* reporter, const char* filename) {
839 SkPath path;
840 path.addRect(0, 10, 20, 20, SkPathDirection::kCW);
841 path.addRect(6, 12, 18, 18, SkPathDirection::kCW);
842 path.addRect(4, 16, 13, 13, SkPathDirection::kCW);
843 testSimplify(reporter, path, filename);
844}
845
846static void testLine36x(skiatest::Reporter* reporter, const char* filename) {
847 SkPath path;
848 path.setFillType(SkPathFillType::kEvenOdd);
849 path.addRect(0, 10, 20, 20, SkPathDirection::kCW);
850 path.addRect(6, 12, 18, 18, SkPathDirection::kCW);
851 path.addRect(4, 16, 13, 13, SkPathDirection::kCW);
852 testSimplify(reporter, path, filename);
853}
854
855static void testLine37(skiatest::Reporter* reporter, const char* filename) {
856 SkPath path;
857 path.addRect(0, 20, 20, 20, SkPathDirection::kCW);
858 path.addRect(18, 24, 30, 30, SkPathDirection::kCW);
859 path.addRect(0, 0, 9, 9, SkPathDirection::kCW);
860 testSimplify(reporter, path, filename);
861}
862
863static void testLine37x(skiatest::Reporter* reporter, const char* filename) {
864 SkPath path;
865 path.setFillType(SkPathFillType::kEvenOdd);
866 path.addRect(0, 20, 20, 20, SkPathDirection::kCW);
867 path.addRect(18, 24, 30, 30, SkPathDirection::kCW);
868 path.addRect(0, 0, 9, 9, SkPathDirection::kCW);
869 testSimplify(reporter, path, filename);
870}
871
872static void testLine38(skiatest::Reporter* reporter, const char* filename) {
873 SkPath path;
874 path.addRect(10, 0, 30, 30, SkPathDirection::kCW);
875 path.addRect(6, 12, 18, 18, SkPathDirection::kCW);
876 path.addRect(12, 12, 21, 21, SkPathDirection::kCW);
877 testSimplify(reporter, path, filename);
878}
879
880static void testLine38x(skiatest::Reporter* reporter, const char* filename) {
881 SkPath path;
882 path.setFillType(SkPathFillType::kEvenOdd);
883 path.addRect(10, 0, 30, 30, SkPathDirection::kCW);
884 path.addRect(6, 12, 18, 18, SkPathDirection::kCW);
885 path.addRect(12, 12, 21, 21, SkPathDirection::kCW);
886 testSimplify(reporter, path, filename);
887}
888
889static void testLine40(skiatest::Reporter* reporter, const char* filename) {
890 SkPath path;
891 path.addRect(10, 0, 30, 30, SkPathDirection::kCW);
892 path.addRect(12, 18, 24, 24, SkPathDirection::kCW);
893 path.addRect(4, 16, 13, 13, SkPathDirection::kCW);
894 testSimplify(reporter, path, filename);
895}
896
897static void testLine40x(skiatest::Reporter* reporter, const char* filename) {
898 SkPath path;
899 path.setFillType(SkPathFillType::kEvenOdd);
900 path.addRect(10, 0, 30, 30, SkPathDirection::kCW);
901 path.addRect(12, 18, 24, 24, SkPathDirection::kCW);
902 path.addRect(4, 16, 13, 13, SkPathDirection::kCW);
903 testSimplify(reporter, path, filename);
904}
905
906static void testLine41(skiatest::Reporter* reporter, const char* filename) {
907 SkPath path;
908 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
909 path.addRect(18, 24, 30, 30, SkPathDirection::kCW);
910 path.addRect(12, 0, 21, 21, SkPathDirection::kCW);
911 testSimplify(reporter, path, filename);
912}
913
914static void testLine41x(skiatest::Reporter* reporter, const char* filename) {
915 SkPath path;
916 path.setFillType(SkPathFillType::kEvenOdd);
917 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
918 path.addRect(18, 24, 30, 30, SkPathDirection::kCW);
919 path.addRect(12, 0, 21, 21, SkPathDirection::kCW);
920 testSimplify(reporter, path, filename);
921}
922
923static void testLine42(skiatest::Reporter* reporter, const char* filename) {
924 SkPath path;
925 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
926 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
927 path.addRect(8, 16, 17, 17, SkPathDirection::kCW);
928 testSimplify(reporter, path, filename);
929}
930
931static void testLine42x(skiatest::Reporter* reporter, const char* filename) {
932 SkPath path;
933 path.setFillType(SkPathFillType::kEvenOdd);
934 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
935 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
936 path.addRect(8, 16, 17, 17, SkPathDirection::kCW);
937 testSimplify(reporter, path, filename);
938}
939
940static void testLine43(skiatest::Reporter* reporter, const char* filename) {
941 SkPath path;
942 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
943 path.addRect(6, 24, 18, 18, SkPathDirection::kCW);
944 path.addRect(0, 32, 9, 36, SkPathDirection::kCCW);
945 testSimplify(reporter, path, filename);
946}
947
948static void testLine43x(skiatest::Reporter* reporter, const char* filename) {
949 SkPath path;
950 path.setFillType(SkPathFillType::kEvenOdd);
951 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
952 path.addRect(6, 24, 18, 18, SkPathDirection::kCW);
953 path.addRect(0, 32, 9, 36, SkPathDirection::kCCW);
954 testSimplify(reporter, path, filename);
955}
956
957static void testLine44(skiatest::Reporter* reporter, const char* filename) {
958 SkPath path;
959 path.addRect(10, 40, 30, 30, SkPathDirection::kCW);
960 path.addRect(18, 0, 30, 30, SkPathDirection::kCW);
961 path.addRect(18, 32, 27, 36, SkPathDirection::kCCW);
962 testSimplify(reporter, path, filename);
963}
964
965static void testLine44x(skiatest::Reporter* reporter, const char* filename) {
966 SkPath path;
967 path.setFillType(SkPathFillType::kEvenOdd);
968 path.addRect(10, 40, 30, 30, SkPathDirection::kCW);
969 path.addRect(18, 0, 30, 30, SkPathDirection::kCW);
970 path.addRect(18, 32, 27, 36, SkPathDirection::kCCW);
971 testSimplify(reporter, path, filename);
972}
973
974static void testLine45(skiatest::Reporter* reporter, const char* filename) {
975 SkPath path;
976 path.addRect(10, 0, 30, 30, SkPathDirection::kCW);
977 path.addRect(18, 0, 30, 30, SkPathDirection::kCW);
978 path.addRect(24, 32, 33, 36, SkPathDirection::kCW);
979 testSimplify(reporter, path, filename);
980}
981
982static void testLine45x(skiatest::Reporter* reporter, const char* filename) {
983 SkPath path;
984 path.setFillType(SkPathFillType::kEvenOdd);
985 path.addRect(10, 0, 30, 30, SkPathDirection::kCW);
986 path.addRect(18, 0, 30, 30, SkPathDirection::kCW);
987 path.addRect(24, 32, 33, 36, SkPathDirection::kCW);
988 testSimplify(reporter, path, filename);
989}
990
991static void testLine46(skiatest::Reporter* reporter, const char* filename) {
992 SkPath path;
993 path.addRect(10, 40, 30, 30, SkPathDirection::kCW);
994 path.addRect(24, 0, 36, 36, SkPathDirection::kCW);
995 path.addRect(24, 32, 33, 36, SkPathDirection::kCW);
996 testSimplify(reporter, path, filename);
997}
998
999static void testLine46x(skiatest::Reporter* reporter, const char* filename) {
1000 SkPath path;
1001 path.setFillType(SkPathFillType::kEvenOdd);
1002 path.addRect(10, 40, 30, 30, SkPathDirection::kCW);
1003 path.addRect(24, 0, 36, 36, SkPathDirection::kCW);
1004 path.addRect(24, 32, 33, 36, SkPathDirection::kCW);
1005 testSimplify(reporter, path, filename);
1006}
1007
1008static void testLine47(skiatest::Reporter* reporter, const char* filename) {
1009 SkPath path;
1010 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1011 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
1012 path.addRect(0, 0, 9, 9, SkPathDirection::kCCW);
1013 testSimplify(reporter, path, filename);
1014}
1015
1016static void testLine47x(skiatest::Reporter* reporter, const char* filename) {
1017 SkPath path;
1018 path.setFillType(SkPathFillType::kEvenOdd);
1019 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1020 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
1021 path.addRect(0, 0, 9, 9, SkPathDirection::kCCW);
1022 testSimplify(reporter, path, filename);
1023}
1024
1025static void testLine48(skiatest::Reporter* reporter, const char* filename) {
1026 SkPath path;
1027 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1028 path.addRect(0, 6, 12, 12, SkPathDirection::kCW);
1029 path.addRect(0, 0, 9, 9, SkPathDirection::kCCW);
1030 testSimplify(reporter, path, filename);
1031}
1032
1033static void testLine48x(skiatest::Reporter* reporter, const char* filename) {
1034 SkPath path;
1035 path.setFillType(SkPathFillType::kEvenOdd);
1036 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1037 path.addRect(0, 6, 12, 12, SkPathDirection::kCW);
1038 path.addRect(0, 0, 9, 9, SkPathDirection::kCCW);
1039 testSimplify(reporter, path, filename);
1040}
1041
1042static void testLine49(skiatest::Reporter* reporter, const char* filename) {
1043 SkPath path;
1044 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1045 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
1046 path.addRect(0, 0, 9, 9, SkPathDirection::kCW);
1047 testSimplify(reporter, path, filename);
1048}
1049
1050static void testLine49x(skiatest::Reporter* reporter, const char* filename) {
1051 SkPath path;
1052 path.setFillType(SkPathFillType::kEvenOdd);
1053 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1054 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
1055 path.addRect(0, 0, 9, 9, SkPathDirection::kCW);
1056 testSimplify(reporter, path, filename);
1057}
1058
1059static void testLine50(skiatest::Reporter* reporter, const char* filename) {
1060 SkPath path;
1061 path.addRect(10, 30, 30, 30, SkPathDirection::kCW);
1062 path.addRect(24, 20, 36, 30, SkPathDirection::kCW);
1063 testSimplify(reporter, path, filename);
1064}
1065
1066static void testLine50x(skiatest::Reporter* reporter, const char* filename) {
1067 SkPath path;
1068 path.setFillType(SkPathFillType::kEvenOdd);
1069 path.addRect(10, 30, 30, 30, SkPathDirection::kCW);
1070 path.addRect(24, 20, 36, 30, SkPathDirection::kCW);
1071 testSimplify(reporter, path, filename);
1072}
1073
1074static void testLine51(skiatest::Reporter* reporter, const char* filename) {
1075 SkPath path;
1076 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1077 path.addRect(0, 12, 12, 12, SkPathDirection::kCW);
1078 path.addRect(4, 12, 13, 13, SkPathDirection::kCCW);
1079 testSimplify(reporter, path, filename);
1080}
1081
1082static void testLine51x(skiatest::Reporter* reporter, const char* filename) {
1083 SkPath path;
1084 path.setFillType(SkPathFillType::kEvenOdd);
1085 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1086 path.addRect(0, 12, 12, 12, SkPathDirection::kCW);
1087 path.addRect(4, 12, 13, 13, SkPathDirection::kCCW);
1088 testSimplify(reporter, path, filename);
1089}
1090
1091static void testLine52(skiatest::Reporter* reporter, const char* filename) {
1092 SkPath path;
1093 path.addRect(0, 30, 20, 20, SkPathDirection::kCW);
1094 path.addRect(6, 20, 18, 30, SkPathDirection::kCW);
1095 path.addRect(32, 0, 36, 41, SkPathDirection::kCW);
1096 testSimplify(reporter, path, filename);
1097}
1098
1099static void testLine52x(skiatest::Reporter* reporter, const char* filename) {
1100 SkPath path;
1101 path.setFillType(SkPathFillType::kEvenOdd);
1102 path.addRect(0, 30, 20, 20, SkPathDirection::kCW);
1103 path.addRect(6, 20, 18, 30, SkPathDirection::kCW);
1104 path.addRect(32, 0, 36, 41, SkPathDirection::kCW);
1105 testSimplify(reporter, path, filename);
1106}
1107
1108static void testLine53(skiatest::Reporter* reporter, const char* filename) {
1109 SkPath path;
1110 path.addRect(10, 30, 30, 30, SkPathDirection::kCW);
1111 path.addRect(12, 20, 24, 30, SkPathDirection::kCW);
1112 path.addRect(12, 32, 21, 36, SkPathDirection::kCCW);
1113 testSimplify(reporter, path, filename);
1114}
1115
1116static void testLine53x(skiatest::Reporter* reporter, const char* filename) {
1117 SkPath path;
1118 path.setFillType(SkPathFillType::kEvenOdd);
1119 path.addRect(10, 30, 30, 30, SkPathDirection::kCW);
1120 path.addRect(12, 20, 24, 30, SkPathDirection::kCW);
1121 path.addRect(12, 32, 21, 36, SkPathDirection::kCCW);
1122 testSimplify(reporter, path, filename);
1123}
1124
1125static void testLine54(skiatest::Reporter* reporter, const char* filename) {
1126 SkPath path;
1127 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1128 path.addRect(6, 0, 18, 18, SkPathDirection::kCW);
1129 path.addRect(8, 4, 17, 17, SkPathDirection::kCCW);
1130 testSimplify(reporter, path, filename);
1131}
1132
1133static void testLine54x(skiatest::Reporter* reporter, const char* filename) {
1134 SkPath path;
1135 path.setFillType(SkPathFillType::kEvenOdd);
1136 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1137 path.addRect(6, 0, 18, 18, SkPathDirection::kCW);
1138 path.addRect(8, 4, 17, 17, SkPathDirection::kCCW);
1139 testSimplify(reporter, path, filename);
1140}
1141
1142static void testLine55(skiatest::Reporter* reporter, const char* filename) {
1143 SkPath path;
1144 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1145 path.addRect(6, 6, 18, 18, SkPathDirection::kCW);
1146 path.addRect(4, 4, 13, 13, SkPathDirection::kCCW);
1147 testSimplify(reporter, path, filename);
1148}
1149
1150static void testLine55x(skiatest::Reporter* reporter, const char* filename) {
1151 SkPath path;
1152 path.setFillType(SkPathFillType::kEvenOdd);
1153 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1154 path.addRect(6, 6, 18, 18, SkPathDirection::kCW);
1155 path.addRect(4, 4, 13, 13, SkPathDirection::kCCW);
1156 testSimplify(reporter, path, filename);
1157}
1158
1159static void testLine56(skiatest::Reporter* reporter, const char* filename) {
1160 SkPath path;
1161 path.addRect(0, 20, 20, 20, SkPathDirection::kCW);
1162 path.addRect(18, 20, 30, 30, SkPathDirection::kCW);
1163 path.addRect(12, 0, 21, 21, SkPathDirection::kCCW);
1164 testSimplify(reporter, path, filename);
1165}
1166
1167static void testLine56x(skiatest::Reporter* reporter, const char* filename) {
1168 SkPath path;
1169 path.setFillType(SkPathFillType::kEvenOdd);
1170 path.addRect(0, 20, 20, 20, SkPathDirection::kCW);
1171 path.addRect(18, 20, 30, 30, SkPathDirection::kCW);
1172 path.addRect(12, 0, 21, 21, SkPathDirection::kCCW);
1173 testSimplify(reporter, path, filename);
1174}
1175
1176static void testLine57(skiatest::Reporter* reporter, const char* filename) {
1177 SkPath path;
1178 path.addRect(20, 0, 40, 40, SkPathDirection::kCW);
1179 path.addRect(20, 0, 30, 40, SkPathDirection::kCW);
1180 path.addRect(12, 0, 21, 21, SkPathDirection::kCCW);
1181 testSimplify(reporter, path, filename);
1182}
1183
1184static void testLine57x(skiatest::Reporter* reporter, const char* filename) {
1185 SkPath path;
1186 path.setFillType(SkPathFillType::kEvenOdd);
1187 path.addRect(20, 0, 40, 40, SkPathDirection::kCW);
1188 path.addRect(20, 0, 30, 40, SkPathDirection::kCW);
1189 path.addRect(12, 0, 21, 21, SkPathDirection::kCCW);
1190 testSimplify(reporter, path, filename);
1191}
1192
1193static void testLine58(skiatest::Reporter* reporter, const char* filename) {
1194 SkPath path;
1195 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1196 path.addRect(0, 0, 12, 12, SkPathDirection::kCCW);
1197 path.addRect(0, 12, 9, 9, SkPathDirection::kCCW);
1198 testSimplify(reporter, path, filename);
1199}
1200
1201static void testLine58x(skiatest::Reporter* reporter, const char* filename) {
1202 SkPath path;
1203 path.setFillType(SkPathFillType::kEvenOdd);
1204 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1205 path.addRect(0, 0, 12, 12, SkPathDirection::kCCW);
1206 path.addRect(0, 12, 9, 9, SkPathDirection::kCCW);
1207 testSimplify(reporter, path, filename);
1208}
1209
1210static void testLine59(skiatest::Reporter* reporter, const char* filename) {
1211 SkPath path;
1212 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1213 path.addRect(6, 6, 18, 18, SkPathDirection::kCCW);
1214 path.addRect(4, 4, 13, 13, SkPathDirection::kCCW);
1215 testSimplify(reporter, path, filename);
1216}
1217
1218static void testLine59x(skiatest::Reporter* reporter, const char* filename) {
1219 SkPath path;
1220 path.setFillType(SkPathFillType::kEvenOdd);
1221 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1222 path.addRect(6, 6, 18, 18, SkPathDirection::kCCW);
1223 path.addRect(4, 4, 13, 13, SkPathDirection::kCCW);
1224 testSimplify(reporter, path, filename);
1225}
1226
1227static void testLine60(skiatest::Reporter* reporter, const char* filename) {
1228 SkPath path;
1229 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1230 path.addRect(6, 12, 18, 18, SkPathDirection::kCCW);
1231 path.addRect(4, 12, 13, 13, SkPathDirection::kCCW);
1232 testSimplify(reporter, path, filename);
1233}
1234
1235static void testLine60x(skiatest::Reporter* reporter, const char* filename) {
1236 SkPath path;
1237 path.setFillType(SkPathFillType::kEvenOdd);
1238 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1239 path.addRect(6, 12, 18, 18, SkPathDirection::kCCW);
1240 path.addRect(4, 12, 13, 13, SkPathDirection::kCCW);
1241 testSimplify(reporter, path, filename);
1242}
1243
1244static void testLine61(skiatest::Reporter* reporter, const char* filename) {
1245 SkPath path;
1246 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1247 path.addRect(12, 0, 24, 24, SkPathDirection::kCCW);
1248 path.addRect(12, 0, 21, 21, SkPathDirection::kCCW);
1249 testSimplify(reporter, path, filename);
1250}
1251
1252static void testLine61x(skiatest::Reporter* reporter, const char* filename) {
1253 SkPath path;
1254 path.setFillType(SkPathFillType::kEvenOdd);
1255 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1256 path.addRect(12, 0, 24, 24, SkPathDirection::kCCW);
1257 path.addRect(12, 0, 21, 21, SkPathDirection::kCCW);
1258 testSimplify(reporter, path, filename);
1259}
1260
1261static void testLine62(skiatest::Reporter* reporter, const char* filename) {
1262 SkPath path;
1263 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1264 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1265 path.addRect(0, 12, 12, 12, SkPathDirection::kCW);
1266 path.addRect(4, 12, 13, 13, SkPathDirection::kCCW);
1267 testSimplify(reporter, path, filename);
1268}
1269
1270static void testLine62x(skiatest::Reporter* reporter, const char* filename) {
1271 SkPath path;
1272 path.setFillType(SkPathFillType::kEvenOdd);
1273 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1274 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1275 path.addRect(0, 12, 12, 12, SkPathDirection::kCW);
1276 path.addRect(4, 12, 13, 13, SkPathDirection::kCCW);
1277 testSimplify(reporter, path, filename);
1278}
1279
1280static void testLine63(skiatest::Reporter* reporter, const char* filename) {
1281 SkPath path;
1282 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1283 path.addRect(0, 10, 20, 20, SkPathDirection::kCW);
1284 path.addRect(0, 6, 12, 12, SkPathDirection::kCCW);
1285 path.addRect(0, 32, 9, 36, SkPathDirection::kCCW);
1286 testSimplify(reporter, path, filename);
1287}
1288
1289static void testLine63x(skiatest::Reporter* reporter, const char* filename) {
1290 SkPath path;
1291 path.setFillType(SkPathFillType::kEvenOdd);
1292 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1293 path.addRect(0, 10, 20, 20, SkPathDirection::kCW);
1294 path.addRect(0, 6, 12, 12, SkPathDirection::kCCW);
1295 path.addRect(0, 32, 9, 36, SkPathDirection::kCCW);
1296 testSimplify(reporter, path, filename);
1297}
1298
1299static void testLine64(skiatest::Reporter* reporter, const char* filename) {
1300 SkPath path;
1301 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1302 path.addRect(10, 40, 30, 30, SkPathDirection::kCW);
1303 path.addRect(18, 6, 30, 30, SkPathDirection::kCW);
1304 testSimplify(reporter, path, filename);
1305}
1306
1307static void testLine64x(skiatest::Reporter* reporter, const char* filename) {
1308 SkPath path;
1309 path.setFillType(SkPathFillType::kEvenOdd);
1310 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1311 path.addRect(10, 40, 30, 30, SkPathDirection::kCW);
1312 path.addRect(18, 6, 30, 30, SkPathDirection::kCW);
1313 testSimplify(reporter, path, filename);
1314}
1315
1316static void testLine65(skiatest::Reporter* reporter, const char* filename) {
1317 SkPath path;
1318 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1319 path.addRect(10, 0, 30, 30, SkPathDirection::kCW);
1320 path.addRect(24, 0, 36, 36, SkPathDirection::kCW);
1321 path.addRect(32, 6, 36, 41, SkPathDirection::kCCW);
1322 testSimplify(reporter, path, filename);
1323}
1324
1325static void testLine65x(skiatest::Reporter* reporter, const char* filename) {
1326 SkPath path;
1327 path.setFillType(SkPathFillType::kEvenOdd);
1328 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1329 path.addRect(10, 0, 30, 30, SkPathDirection::kCW);
1330 path.addRect(24, 0, 36, 36, SkPathDirection::kCW);
1331 path.addRect(32, 6, 36, 41, SkPathDirection::kCCW);
1332 testSimplify(reporter, path, filename);
1333}
1334
1335static void testLine66(skiatest::Reporter* reporter, const char* filename) {
1336 SkPath path;
1337 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1338 path.addRect(0, 30, 20, 20, SkPathDirection::kCW);
1339 path.addRect(12, 20, 24, 30, SkPathDirection::kCW);
1340 testSimplify(reporter, path, filename);
1341}
1342
1343static void testLine66x(skiatest::Reporter* reporter, const char* filename) {
1344 SkPath path;
1345 path.setFillType(SkPathFillType::kEvenOdd);
1346 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1347 path.addRect(0, 30, 20, 20, SkPathDirection::kCW);
1348 path.addRect(12, 20, 24, 30, SkPathDirection::kCW);
1349 testSimplify(reporter, path, filename);
1350}
1351
1352static void testLine67(skiatest::Reporter* reporter, const char* filename) {
1353 SkPath path;
1354 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1355 path.addRect(10, 40, 30, 30, SkPathDirection::kCW);
1356 path.addRect(24, 20, 36, 30, SkPathDirection::kCW);
1357 path.addRect(32, 0, 36, 41, SkPathDirection::kCW);
1358 testSimplify(reporter, path, filename);
1359}
1360
1361static void testLine67x(skiatest::Reporter* reporter, const char* filename) {
1362 SkPath path;
1363 path.setFillType(SkPathFillType::kEvenOdd);
1364 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1365 path.addRect(10, 40, 30, 30, SkPathDirection::kCW);
1366 path.addRect(24, 20, 36, 30, SkPathDirection::kCW);
1367 path.addRect(32, 0, 36, 41, SkPathDirection::kCW);
1368 testSimplify(reporter, path, filename);
1369}
1370
1371static void testLine68a(skiatest::Reporter* reporter, const char* filename) {
1372 SkPath path;
1373 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1374 path.addRect(2, 2, 6, 6, SkPathDirection::kCW);
1375 path.addRect(1, 2, 4, 2, SkPathDirection::kCW);
1376 testSimplify(reporter, path, filename);
1377}
1378
1379static void testLine68ax(skiatest::Reporter* reporter, const char* filename) {
1380 SkPath path;
1381 path.setFillType(SkPathFillType::kEvenOdd);
1382 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1383 path.addRect(2, 2, 6, 6, SkPathDirection::kCW);
1384 path.addRect(1, 2, 4, 2, SkPathDirection::kCW);
1385 testSimplify(reporter, path, filename);
1386}
1387
1388static void testLine68b(skiatest::Reporter* reporter, const char* filename) {
1389 SkPath path;
1390 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1391 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1392 path.addRect(1, 2, 2, 2, SkPathDirection::kCW);
1393 testSimplify(reporter, path, filename);
1394}
1395
1396static void testLine68bx(skiatest::Reporter* reporter, const char* filename) {
1397 SkPath path;
1398 path.setFillType(SkPathFillType::kEvenOdd);
1399 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1400 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1401 path.addRect(1, 2, 2, 2, SkPathDirection::kCW);
1402 testSimplify(reporter, path, filename);
1403}
1404
1405static void testLine68c(skiatest::Reporter* reporter, const char* filename) {
1406 SkPath path;
1407 path.addRect(0, 0, 8, 8, SkPathDirection::kCCW);
1408 path.addRect(2, 2, 6, 6, SkPathDirection::kCW);
1409 path.addRect(1, 2, 4, 2, SkPathDirection::kCW);
1410 testSimplify(reporter, path, filename);
1411}
1412
1413static void testLine68cx(skiatest::Reporter* reporter, const char* filename) {
1414 SkPath path;
1415 path.setFillType(SkPathFillType::kEvenOdd);
1416 path.addRect(0, 0, 8, 8, SkPathDirection::kCCW);
1417 path.addRect(2, 2, 6, 6, SkPathDirection::kCW);
1418 path.addRect(1, 2, 4, 2, SkPathDirection::kCW);
1419 testSimplify(reporter, path, filename);
1420}
1421
1422static void testLine68d(skiatest::Reporter* reporter, const char* filename) {
1423 SkPath path;
1424 path.addRect(0, 0, 8, 8, SkPathDirection::kCCW);
1425 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1426 path.addRect(1, 2, 4, 2, SkPathDirection::kCW);
1427 testSimplify(reporter, path, filename);
1428}
1429
1430static void testLine68dx(skiatest::Reporter* reporter, const char* filename) {
1431 SkPath path;
1432 path.setFillType(SkPathFillType::kEvenOdd);
1433 path.addRect(0, 0, 8, 8, SkPathDirection::kCCW);
1434 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1435 path.addRect(1, 2, 4, 2, SkPathDirection::kCW);
1436 testSimplify(reporter, path, filename);
1437}
1438
1439static void testLine68e(skiatest::Reporter* reporter, const char* filename) {
1440 SkPath path;
1441 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1442 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1443 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1444 path.addRect(1, 2, 2, 2, SkPathDirection::kCW);
1445 testSimplify(reporter, path, filename);
1446}
1447
1448static void testLine68ex(skiatest::Reporter* reporter, const char* filename) {
1449 SkPath path;
1450 path.setFillType(SkPathFillType::kEvenOdd);
1451 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1452 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1453 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1454 path.addRect(1, 2, 2, 2, SkPathDirection::kCW);
1455 testSimplify(reporter, path, filename);
1456}
1457
1458static void testLine68f(skiatest::Reporter* reporter, const char* filename) {
1459 SkPath path;
1460 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1461 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1462 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1463 path.addRect(1, 2, 2, 2, SkPathDirection::kCW);
1464 testSimplify(reporter, path, filename);
1465}
1466
1467static void testLine68fx(skiatest::Reporter* reporter, const char* filename) {
1468 SkPath path;
1469 path.setFillType(SkPathFillType::kEvenOdd);
1470 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1471 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1472 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1473 path.addRect(1, 2, 2, 2, SkPathDirection::kCW);
1474 testSimplify(reporter, path, filename);
1475}
1476
1477static void testLine68g(skiatest::Reporter* reporter, const char* filename) {
1478 SkPath path;
1479 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1480 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1481 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1482 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1483 path.addRect(1, 2, 2, 2, SkPathDirection::kCW);
1484 testSimplify(reporter, path, filename);
1485}
1486
1487static void testLine68gx(skiatest::Reporter* reporter, const char* filename) {
1488 SkPath path;
1489 path.setFillType(SkPathFillType::kEvenOdd);
1490 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1491 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1492 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1493 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1494 path.addRect(1, 2, 2, 2, SkPathDirection::kCW);
1495 testSimplify(reporter, path, filename);
1496}
1497
1498static void testLine68h(skiatest::Reporter* reporter, const char* filename) {
1499 SkPath path;
1500 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1501 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1502 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1503 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1504 path.addRect(1, 2, 2, 2, SkPathDirection::kCW);
1505 testSimplify(reporter, path, filename);
1506}
1507
1508static void testLine68hx(skiatest::Reporter* reporter, const char* filename) {
1509 SkPath path;
1510 path.setFillType(SkPathFillType::kEvenOdd);
1511 path.addRect(0, 0, 8, 8, SkPathDirection::kCW);
1512 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1513 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1514 path.addRect(2, 2, 6, 6, SkPathDirection::kCCW);
1515 path.addRect(1, 2, 2, 2, SkPathDirection::kCW);
1516 testSimplify(reporter, path, filename);
1517}
1518
1519static void testLine69(skiatest::Reporter* reporter, const char* filename) {
1520 SkPath path;
1521 path.addRect(0, 20, 20, 20, SkPathDirection::kCW);
1522 path.addRect(0, 20, 12, 30, SkPathDirection::kCW);
1523 path.addRect(12, 32, 21, 36, SkPathDirection::kCW);
1524 testSimplify(reporter, path, filename);
1525}
1526
1527static void testLine69x(skiatest::Reporter* reporter, const char* filename) {
1528 SkPath path;
1529 path.setFillType(SkPathFillType::kEvenOdd);
1530 path.addRect(0, 20, 20, 20, SkPathDirection::kCW);
1531 path.addRect(0, 20, 12, 30, SkPathDirection::kCW);
1532 path.addRect(12, 32, 21, 36, SkPathDirection::kCW);
1533 testSimplify(reporter, path, filename);
1534}
1535
1536static void testLine70(skiatest::Reporter* reporter, const char* filename) {
1537 SkPath path;
1538 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1539 path.addRect(0, 24, 12, 12, SkPathDirection::kCW);
1540 path.addRect(12, 32, 21, 36, SkPathDirection::kCCW);
1541 testSimplify(reporter, path, filename);
1542}
1543
1544static void testLine70x(skiatest::Reporter* reporter, const char* filename) {
1545 SkPath path;
1546 path.setFillType(SkPathFillType::kEvenOdd);
1547 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1548 path.addRect(0, 24, 12, 12, SkPathDirection::kCW);
1549 path.addRect(12, 32, 21, 36, SkPathDirection::kCCW);
1550 testSimplify(reporter, path, filename);
1551}
1552
1553static void testLine71(skiatest::Reporter* reporter, const char* filename) {
1554 SkPath path;
1555 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1556 path.addRect(12, 0, 24, 24, SkPathDirection::kCW);
1557 path.addRect(12, 32, 21, 36, SkPathDirection::kCW);
1558 testSimplify(reporter, path, filename);
1559}
1560
1561static void testLine71x(skiatest::Reporter* reporter, const char* filename) {
1562 SkPath path;
1563 path.setFillType(SkPathFillType::kEvenOdd);
1564 path.addRect(0, 0, 20, 20, SkPathDirection::kCW);
1565 path.addRect(12, 0, 24, 24, SkPathDirection::kCW);
1566 path.addRect(12, 32, 21, 36, SkPathDirection::kCW);
1567 testSimplify(reporter, path, filename);
1568}
1569
1570static void testLine72(skiatest::Reporter* reporter, const char* filename) {
1571 SkPath path;
1572 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1573 path.addRect(10, 40, 30, 30, SkPathDirection::kCW);
1574 path.addRect(6, 20, 18, 30, SkPathDirection::kCW);
1575 testSimplify(reporter, path, filename);
1576}
1577
1578static void testLine72x(skiatest::Reporter* reporter, const char* filename) {
1579 SkPath path;
1580 path.setFillType(SkPathFillType::kEvenOdd);
1581 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1582 path.addRect(10, 40, 30, 30, SkPathDirection::kCW);
1583 path.addRect(6, 20, 18, 30, SkPathDirection::kCW);
1584 testSimplify(reporter, path, filename);
1585}
1586
1587static void testLine73(skiatest::Reporter* reporter, const char* filename) {
1588 SkPath path;
1589 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1590 path.addRect(0, 40, 20, 20, SkPathDirection::kCW);
1591 path.addRect(0, 20, 12, 30, SkPathDirection::kCW);
1592 path.addRect(0, 0, 9, 9, SkPathDirection::kCCW);
1593 testSimplify(reporter, path, filename);
1594}
1595
1596static void testLine73x(skiatest::Reporter* reporter, const char* filename) {
1597 SkPath path;
1598 path.setFillType(SkPathFillType::kEvenOdd);
1599 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1600 path.addRect(0, 40, 20, 20, SkPathDirection::kCW);
1601 path.addRect(0, 20, 12, 30, SkPathDirection::kCW);
1602 path.addRect(0, 0, 9, 9, SkPathDirection::kCCW);
1603 testSimplify(reporter, path, filename);
1604}
1605
1606static void testLine74(skiatest::Reporter* reporter, const char* filename) {
1607 SkPath path;
1608 path.addRect(20, 30, 40, 40, SkPathDirection::kCW);
1609 path.addRect(24, 20, 36, 30, SkPathDirection::kCCW);
1610 path.addRect(32, 24, 36, 41, SkPathDirection::kCCW);
1611 testSimplify(reporter, path, filename);
1612}
1613
1614static void testLine74x(skiatest::Reporter* reporter, const char* filename) {
1615 SkPath path;
1616 path.setFillType(SkPathFillType::kEvenOdd);
1617 path.addRect(20, 30, 40, 40, SkPathDirection::kCW);
1618 path.addRect(24, 20, 36, 30, SkPathDirection::kCCW);
1619 path.addRect(32, 24, 36, 41, SkPathDirection::kCCW);
1620 testSimplify(reporter, path, filename);
1621}
1622
1623static void testLine75(skiatest::Reporter* reporter, const char* filename) {
1624 SkPath path;
1625 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1626 path.addRect(10, 0, 30, 30, SkPathDirection::kCCW);
1627 path.addRect(18, 0, 30, 30, SkPathDirection::kCCW);
1628 path.addRect(12, 0, 21, 21, SkPathDirection::kCCW);
1629 testSimplify(reporter, path, filename);
1630}
1631
1632static void testLine75x(skiatest::Reporter* reporter, const char* filename) {
1633 SkPath path;
1634 path.setFillType(SkPathFillType::kEvenOdd);
1635 path.addRect(0, 0, 60, 60, SkPathDirection::kCW);
1636 path.addRect(10, 0, 30, 30, SkPathDirection::kCCW);
1637 path.addRect(18, 0, 30, 30, SkPathDirection::kCCW);
1638 path.addRect(12, 0, 21, 21, SkPathDirection::kCCW);
1639 testSimplify(reporter, path, filename);
1640}
1641
1642static void testLine76(skiatest::Reporter* reporter, const char* filename) {
1643 SkPath path;
1644 path.addRect(36, 0, 66, 60, SkPathDirection::kCW);
1645 path.addRect(10, 20, 40, 30, SkPathDirection::kCW);
1646 path.addRect(24, 20, 36, 30, SkPathDirection::kCCW);
1647 path.addRect(32, 6, 36, 41, SkPathDirection::kCCW);
1648 testSimplify(reporter, path, filename);
1649}
1650
1651static void testLine76x(skiatest::Reporter* reporter, const char* filename) {
1652 SkPath path;
1653 path.setFillType(SkPathFillType::kEvenOdd);
1654 path.addRect(36, 0, 66, 60, SkPathDirection::kCW);
1655 path.addRect(10, 20, 40, 30, SkPathDirection::kCW);
1656 path.addRect(24, 20, 36, 30, SkPathDirection::kCCW);
1657 path.addRect(32, 6, 36, 41, SkPathDirection::kCCW);
1658 testSimplify(reporter, path, filename);
1659}
1660
1661static void testLine77(skiatest::Reporter* reporter, const char* filename) {
1662 SkPath path;
1663 path.addRect(20, 0, 40, 40, SkPathDirection::kCW);
1664 path.addRect(24, 6, 36, 36, SkPathDirection::kCCW);
1665 path.addRect(24, 32, 33, 36, SkPathDirection::kCCW);
1666 testSimplify(reporter, path, filename);
1667}
1668
1669static void testLine77x(skiatest::Reporter* reporter, const char* filename) {
1670 SkPath path;
1671 path.setFillType(SkPathFillType::kEvenOdd);
1672 path.addRect(20, 0, 40, 40, SkPathDirection::kCW);
1673 path.addRect(24, 6, 36, 36, SkPathDirection::kCCW);
1674 path.addRect(24, 32, 33, 36, SkPathDirection::kCCW);
1675 testSimplify(reporter, path, filename);
1676}
1677
1678static void testLine78(skiatest::Reporter* reporter, const char* filename) {
1679 SkPath path;
1680 path.addRect(0, 0, 30, 60, SkPathDirection::kCW);
1681 path.addRect(10, 20, 30, 30, SkPathDirection::kCCW);
1682 path.addRect(18, 20, 30, 30, SkPathDirection::kCCW);
1683 path.addRect(32, 0, 36, 41, SkPathDirection::kCCW);
1684 testSimplify(reporter, path, filename);
1685}
1686
1687static void testLine78x(skiatest::Reporter* reporter, const char* filename) {
1688 SkPath path;
1689 path.setFillType(SkPathFillType::kEvenOdd);
1690 path.addRect(0, 0, 30, 60, SkPathDirection::kCW);
1691 path.addRect(10, 20, 30, 30, SkPathDirection::kCCW);
1692 path.addRect(18, 20, 30, 30, SkPathDirection::kCCW);
1693 path.addRect(32, 0, 36, 41, SkPathDirection::kCCW);
1694 testSimplify(reporter, path, filename);
1695}
1696
1697static void testLine79(skiatest::Reporter* reporter, const char* filename) {
1698 SkPath path;
1699 path.addRect(0, 36, 60, 30, SkPathDirection::kCW);
1700 path.addRect(10, 30, 40, 30, SkPathDirection::kCW);
1701 path.addRect(0, 20, 12, 30, SkPathDirection::kCCW);
1702 path.addRect(0, 32, 9, 36, SkPathDirection::kCCW);
1703 testSimplify(reporter, path, filename);
1704}
1705
1706static void testLine79x(skiatest::Reporter* reporter, const char* filename) {
1707 SkPath path;
1708 path.setFillType(SkPathFillType::kEvenOdd);
1709 path.addRect(0, 36, 60, 30, SkPathDirection::kCW);
1710 path.addRect(10, 30, 40, 30, SkPathDirection::kCW);
1711 path.addRect(0, 20, 12, 30, SkPathDirection::kCCW);
1712 path.addRect(0, 32, 9, 36, SkPathDirection::kCCW);
1713 testSimplify(reporter, path, filename);
1714}
1715
1716static void testLine81(skiatest::Reporter* reporter, const char* filename) {
1717 SkPath path;
1718 path.addRect(-1, -1, 3, 3, SkPathDirection::kCW);
1719 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
1720 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
1721 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
1722 path.addRect(1, 1, 2, 2, SkPathDirection::kCCW);
1723 testSimplify(reporter, path, filename);
1724}
1725
1726static void testDegenerate1(skiatest::Reporter* reporter, const char* filename) {
1727 SkPath path;
1728 path.moveTo(0, 0);
1729 path.lineTo(0, 0);
1730 path.lineTo(2, 0);
1731 path.close();
1732 path.moveTo(0, 0);
1733 path.lineTo(1, 0);
1734 path.lineTo(2, 0);
1735 path.close();
1736 testSimplify(reporter, path, filename);
1737}
1738
1739static void testDegenerate1x(skiatest::Reporter* reporter, const char* filename) {
1740 SkPath path;
1741 path.setFillType(SkPathFillType::kEvenOdd);
1742 path.moveTo(0, 0);
1743 path.lineTo(0, 0);
1744 path.lineTo(2, 0);
1745 path.close();
1746 path.moveTo(0, 0);
1747 path.lineTo(1, 0);
1748 path.lineTo(2, 0);
1749 path.close();
1750 testSimplify(reporter, path, filename);
1751}
1752
1753static void testDegenerate2(skiatest::Reporter* reporter, const char* filename) {
1754 SkPath path;
1755 path.moveTo(0, 0);
1756 path.lineTo(0, 0);
1757 path.lineTo(0, 0);
1758 path.close();
1759 path.moveTo(0, 0);
1760 path.lineTo(1, 0);
1761 path.lineTo(0, 1);
1762 path.close();
1763 testSimplify(reporter, path, filename);
1764}
1765
1766static void testDegenerate2x(skiatest::Reporter* reporter, const char* filename) {
1767 SkPath path;
1768 path.setFillType(SkPathFillType::kEvenOdd);
1769 path.moveTo(0, 0);
1770 path.lineTo(0, 0);
1771 path.lineTo(0, 0);
1772 path.close();
1773 path.moveTo(0, 0);
1774 path.lineTo(1, 0);
1775 path.lineTo(0, 1);
1776 path.close();
1777 testSimplify(reporter, path, filename);
1778}
1779
1780static void testDegenerate3(skiatest::Reporter* reporter, const char* filename) {
1781 SkPath path;
1782 path.moveTo(0, 0);
1783 path.lineTo(2, 0);
1784 path.lineTo(1, 0);
1785 path.close();
1786 path.moveTo(0, 0);
1787 path.lineTo(0, 0);
1788 path.lineTo(3, 0);
1789 path.close();
1790 testSimplify(reporter, path, filename);
1791}
1792
1793static void testDegenerate3x(skiatest::Reporter* reporter, const char* filename) {
1794 SkPath path;
1795 path.setFillType(SkPathFillType::kEvenOdd);
1796 path.moveTo(0, 0);
1797 path.lineTo(2, 0);
1798 path.lineTo(1, 0);
1799 path.close();
1800 path.moveTo(0, 0);
1801 path.lineTo(0, 0);
1802 path.lineTo(3, 0);
1803 path.close();
1804 testSimplify(reporter, path, filename);
1805}
1806
1807static void testDegenerate4(skiatest::Reporter* reporter, const char* filename) {
1808 SkPath path;
1809 path.moveTo(0, 0);
1810 path.lineTo(1, 0);
1811 path.lineTo(1, 3);
1812 path.close();
1813 path.moveTo(1, 0);
1814 path.lineTo(1, 1);
1815 path.lineTo(1, 2);
1816 path.close();
1817 testSimplify(reporter, path, filename);
1818}
1819
1820static void testDegenerate4x(skiatest::Reporter* reporter, const char* filename) {
1821 SkPath path;
1822 path.setFillType(SkPathFillType::kEvenOdd);
1823 path.moveTo(0, 0);
1824 path.lineTo(1, 0);
1825 path.lineTo(1, 3);
1826 path.close();
1827 path.moveTo(1, 0);
1828 path.lineTo(1, 1);
1829 path.lineTo(1, 2);
1830 path.close();
1831 testSimplify(reporter, path, filename);
1832}
1833
1834static void testNondegenerate1(skiatest::Reporter* reporter, const char* filename) {
1835 SkPath path;
1836 path.moveTo(0, 0);
1837 path.lineTo(3, 0);
1838 path.lineTo(1, 3);
1839 path.close();
1840 path.moveTo(1, 1);
1841 path.lineTo(2, 1);
1842 path.lineTo(1, 2);
1843 path.close();
1844 testSimplify(reporter, path, filename);
1845}
1846
1847static void testNondegenerate1x(skiatest::Reporter* reporter, const char* filename) {
1848 SkPath path;
1849 path.setFillType(SkPathFillType::kEvenOdd);
1850 path.moveTo(0, 0);
1851 path.lineTo(3, 0);
1852 path.lineTo(1, 3);
1853 path.close();
1854 path.moveTo(1, 1);
1855 path.lineTo(2, 1);
1856 path.lineTo(1, 2);
1857 path.close();
1858 testSimplify(reporter, path, filename);
1859}
1860
1861static void testNondegenerate2(skiatest::Reporter* reporter, const char* filename) {
1862 SkPath path;
1863 path.moveTo(1, 0);
1864 path.lineTo(0, 1);
1865 path.lineTo(1, 1);
1866 path.close();
1867 path.moveTo(0, 2);
1868 path.lineTo(0, 3);
1869 path.lineTo(1, 2);
1870 path.close();
1871 testSimplify(reporter, path, filename);
1872}
1873
1874static void testNondegenerate2x(skiatest::Reporter* reporter, const char* filename) {
1875 SkPath path;
1876 path.setFillType(SkPathFillType::kEvenOdd);
1877 path.moveTo(1, 0);
1878 path.lineTo(0, 1);
1879 path.lineTo(1, 1);
1880 path.close();
1881 path.moveTo(0, 2);
1882 path.lineTo(0, 3);
1883 path.lineTo(1, 2);
1884 path.close();
1885 testSimplify(reporter, path, filename);
1886}
1887
1888static void testNondegenerate3(skiatest::Reporter* reporter, const char* filename) {
1889 SkPath path;
1890 path.moveTo(0, 0);
1891 path.lineTo(1, 0);
1892 path.lineTo(2, 1);
1893 path.close();
1894 path.moveTo(0, 1);
1895 path.lineTo(1, 1);
1896 path.lineTo(0, 2);
1897 path.close();
1898 testSimplify(reporter, path, filename);
1899}
1900
1901static void testNondegenerate3x(skiatest::Reporter* reporter, const char* filename) {
1902 SkPath path;
1903 path.setFillType(SkPathFillType::kEvenOdd);
1904 path.moveTo(0, 0);
1905 path.lineTo(1, 0);
1906 path.lineTo(2, 1);
1907 path.close();
1908 path.moveTo(0, 1);
1909 path.lineTo(1, 1);
1910 path.lineTo(0, 2);
1911 path.close();
1912 testSimplify(reporter, path, filename);
1913}
1914
1915static void testNondegenerate4(skiatest::Reporter* reporter, const char* filename) {
1916 SkPath path;
1917 path.moveTo(1, 0);
1918 path.lineTo(0, 1);
1919 path.lineTo(1, 2);
1920 path.close();
1921 path.moveTo(0, 2);
1922 path.lineTo(0, 3);
1923 path.lineTo(1, 3);
1924 path.close();
1925 testSimplify(reporter, path, filename);
1926}
1927
1928static void testNondegenerate4x(skiatest::Reporter* reporter, const char* filename) {
1929 SkPath path;
1930 path.setFillType(SkPathFillType::kEvenOdd);
1931 path.moveTo(1, 0);
1932 path.lineTo(0, 1);
1933 path.lineTo(1, 2);
1934 path.close();
1935 path.moveTo(0, 2);
1936 path.lineTo(0, 3);
1937 path.lineTo(1, 3);
1938 path.close();
1939 testSimplify(reporter, path, filename);
1940}
1941
1942static void testQuadralateral5(skiatest::Reporter* reporter, const char* filename) {
1943 SkPath path;
1944 path.moveTo(0, 0);
1945 path.lineTo(0, 0);
1946 path.lineTo(1, 0);
1947 path.lineTo(1, 1);
1948 path.close();
1949 path.moveTo(0, 0);
1950 path.lineTo(2, 2);
1951 path.lineTo(3, 2);
1952 path.lineTo(3, 3);
1953 path.close();
1954 testSimplify(reporter, path, filename);
1955}
1956
1957static void testQuadralateral5x(skiatest::Reporter* reporter, const char* filename) {
1958 SkPath path;
1959 path.setFillType(SkPathFillType::kEvenOdd);
1960 path.moveTo(0, 0);
1961 path.lineTo(0, 0);
1962 path.lineTo(1, 0);
1963 path.lineTo(1, 1);
1964 path.close();
1965 path.moveTo(0, 0);
1966 path.lineTo(2, 2);
1967 path.lineTo(3, 2);
1968 path.lineTo(3, 3);
1969 path.close();
1970 testSimplify(reporter, path, filename);
1971}
1972
1973static void testQuadralateral6(skiatest::Reporter* reporter, const char* filename) {
1974 SkPath path;
1975 path.moveTo(0, 0);
1976 path.lineTo(0, 0);
1977 path.lineTo(1, 0);
1978 path.lineTo(1, 1);
1979 path.close();
1980 path.moveTo(1, 0);
1981 path.lineTo(2, 0);
1982 path.lineTo(0, 2);
1983 path.lineTo(2, 2);
1984 path.close();
1985 testSimplify(reporter, path, filename);
1986}
1987
1988static void testQuadralateral6x(skiatest::Reporter* reporter, const char* filename) {
1989 SkPath path;
1990 path.setFillType(SkPathFillType::kEvenOdd);
1991 path.moveTo(0, 0);
1992 path.lineTo(0, 0);
1993 path.lineTo(1, 0);
1994 path.lineTo(1, 1);
1995 path.close();
1996 path.moveTo(1, 0);
1997 path.lineTo(2, 0);
1998 path.lineTo(0, 2);
1999 path.lineTo(2, 2);
2000 path.close();
2001 testSimplify(reporter, path, filename);
2002}
2003
2004static void testFauxQuadralateral6(skiatest::Reporter* reporter, const char* filename) {
2005 SkPath path;
2006 path.moveTo(0, 0);
2007 path.lineTo(1, 0);
2008 path.lineTo(1, 1);
2009 path.close();
2010 path.moveTo(1, 0);
2011 path.lineTo(2, 0);
2012 path.lineTo(1 + 1.0f/3, 2.0f/3);
2013 path.close();
2014 path.moveTo(1 + 1.0f/3, 2.0f/3);
2015 path.lineTo(0, 2);
2016 path.lineTo(2, 2);
2017 path.close();
2018 testSimplify(reporter, path, filename);
2019}
2020
2021static void testFauxQuadralateral6x(skiatest::Reporter* reporter, const char* filename) {
2022 SkPath path;
2023 path.setFillType(SkPathFillType::kEvenOdd);
2024 path.moveTo(0, 0);
2025 path.lineTo(1, 0);
2026 path.lineTo(1, 1);
2027 path.close();
2028 path.moveTo(1, 0);
2029 path.lineTo(2, 0);
2030 path.lineTo(1 + 1.0f/3, 2.0f/3);
2031 path.close();
2032 path.moveTo(1 + 1.0f/3, 2.0f/3);
2033 path.lineTo(0, 2);
2034 path.lineTo(2, 2);
2035 path.close();
2036 testSimplify(reporter, path, filename);
2037}
2038
2039static void testFauxQuadralateral6a(skiatest::Reporter* reporter, const char* filename) {
2040 SkPath path;
2041 path.moveTo(0, 0);
2042 path.lineTo(3, 0);
2043 path.lineTo(3, 3);
2044 path.close();
2045 path.moveTo(3, 0);
2046 path.lineTo(6, 0);
2047 path.lineTo(4, 2);
2048 path.close();
2049 path.moveTo(4, 2);
2050 path.lineTo(0, 6);
2051 path.lineTo(6, 6);
2052 path.close();
2053 testSimplify(reporter, path, filename);
2054}
2055
2056static void testFauxQuadralateral6ax(skiatest::Reporter* reporter, const char* filename) {
2057 SkPath path;
2058 path.setFillType(SkPathFillType::kEvenOdd);
2059 path.moveTo(0, 0);
2060 path.lineTo(3, 0);
2061 path.lineTo(3, 3);
2062 path.close();
2063 path.moveTo(3, 0);
2064 path.lineTo(6, 0);
2065 path.lineTo(4, 2);
2066 path.close();
2067 path.moveTo(4, 2);
2068 path.lineTo(0, 6);
2069 path.lineTo(6, 6);
2070 path.close();
2071 testSimplify(reporter, path, filename);
2072}
2073
2074static void testFauxQuadralateral6b(skiatest::Reporter* reporter, const char* filename) {
2075 SkPath path;
2076 path.moveTo(0, 0);
2077 path.lineTo(3, 0);
2078 path.lineTo(3, 3);
2079 path.close();
2080 path.moveTo(3, 0);
2081 path.lineTo(6, 0);
2082 path.lineTo(4, 2);
2083 path.close();
2084 path.moveTo(4, 2);
2085 path.lineTo(6, 6);
2086 path.lineTo(0, 6);
2087 path.close();
2088 testSimplify(reporter, path, filename);
2089}
2090
2091static void testFauxQuadralateral6bx(skiatest::Reporter* reporter, const char* filename) {
2092 SkPath path;
2093 path.setFillType(SkPathFillType::kEvenOdd);
2094 path.moveTo(0, 0);
2095 path.lineTo(3, 0);
2096 path.lineTo(3, 3);
2097 path.close();
2098 path.moveTo(3, 0);
2099 path.lineTo(6, 0);
2100 path.lineTo(4, 2);
2101 path.close();
2102 path.moveTo(4, 2);
2103 path.lineTo(6, 6);
2104 path.lineTo(0, 6);
2105 path.close();
2106 testSimplify(reporter, path, filename);
2107}
2108
2109static void testFauxQuadralateral6c(skiatest::Reporter* reporter, const char* filename) {
2110 SkPath path;
2111 path.moveTo(0, 0);
2112 path.lineTo(3, 3);
2113 path.lineTo(3, 0);
2114 path.close();
2115 path.moveTo(3, 0);
2116 path.lineTo(6, 0);
2117 path.lineTo(4, 2);
2118 path.close();
2119 path.moveTo(4, 2);
2120 path.lineTo(0, 6);
2121 path.lineTo(6, 6);
2122 path.close();
2123 testSimplify(reporter, path, filename);
2124}
2125
2126static void testFauxQuadralateral6cx(skiatest::Reporter* reporter, const char* filename) {
2127 SkPath path;
2128 path.setFillType(SkPathFillType::kEvenOdd);
2129 path.moveTo(0, 0);
2130 path.lineTo(3, 3);
2131 path.lineTo(3, 0);
2132 path.close();
2133 path.moveTo(3, 0);
2134 path.lineTo(6, 0);
2135 path.lineTo(4, 2);
2136 path.close();
2137 path.moveTo(4, 2);
2138 path.lineTo(0, 6);
2139 path.lineTo(6, 6);
2140 path.close();
2141 testSimplify(reporter, path, filename);
2142}
2143
2144static void testFauxQuadralateral6d(skiatest::Reporter* reporter, const char* filename) {
2145 SkPath path;
2146 path.moveTo(0, 0);
2147 path.lineTo(3, 3);
2148 path.lineTo(3, 0);
2149 path.close();
2150 path.moveTo(3, 0);
2151 path.lineTo(6, 0);
2152 path.lineTo(4, 2);
2153 path.close();
2154 path.moveTo(4, 2);
2155 path.lineTo(6, 6);
2156 path.lineTo(0, 6);
2157 path.close();
2158 testSimplify(reporter, path, filename);
2159}
2160
2161static void testFauxQuadralateral6dx(skiatest::Reporter* reporter, const char* filename) {
2162 SkPath path;
2163 path.setFillType(SkPathFillType::kEvenOdd);
2164 path.moveTo(0, 0);
2165 path.lineTo(3, 3);
2166 path.lineTo(3, 0);
2167 path.close();
2168 path.moveTo(3, 0);
2169 path.lineTo(6, 0);
2170 path.lineTo(4, 2);
2171 path.close();
2172 path.moveTo(4, 2);
2173 path.lineTo(6, 6);
2174 path.lineTo(0, 6);
2175 path.close();
2176 testSimplify(reporter, path, filename);
2177}
2178
2179static void testQuadralateral6a(skiatest::Reporter* reporter, const char* filename) {
2180 SkPath path;
2181 path.moveTo(0, 0);
2182 path.lineTo(0, 0);
2183 path.lineTo(3, 0);
2184 path.lineTo(3, 3);
2185 path.close();
2186 path.moveTo(3, 0);
2187 path.lineTo(6, 0);
2188 path.lineTo(0, 6);
2189 path.lineTo(6, 6);
2190 path.close();
2191 testSimplify(reporter, path, filename);
2192}
2193
2194static void testQuadralateral6ax(skiatest::Reporter* reporter, const char* filename) {
2195 SkPath path;
2196 path.setFillType(SkPathFillType::kEvenOdd);
2197 path.moveTo(0, 0);
2198 path.lineTo(0, 0);
2199 path.lineTo(3, 0);
2200 path.lineTo(3, 3);
2201 path.close();
2202 path.moveTo(3, 0);
2203 path.lineTo(6, 0);
2204 path.lineTo(0, 6);
2205 path.lineTo(6, 6);
2206 path.close();
2207 testSimplify(reporter, path, filename);
2208}
2209
2210static void testQuadralateral7(skiatest::Reporter* reporter, const char* filename) {
2211 SkPath path;
2212 path.moveTo(0, 0);
2213 path.lineTo(0, 0);
2214 path.lineTo(1, 0);
2215 path.lineTo(2, 1);
2216 path.close();
2217 path.moveTo(1, 0);
2218 path.lineTo(1, 1);
2219 path.lineTo(2, 2);
2220 path.lineTo(1, 3);
2221 path.close();
2222 testSimplify(reporter, path, filename);
2223}
2224
2225static void testQuadralateral7x(skiatest::Reporter* reporter, const char* filename) {
2226 SkPath path;
2227 path.setFillType(SkPathFillType::kEvenOdd);
2228 path.moveTo(0, 0);
2229 path.lineTo(0, 0);
2230 path.lineTo(1, 0);
2231 path.lineTo(2, 1);
2232 path.close();
2233 path.moveTo(1, 0);
2234 path.lineTo(1, 1);
2235 path.lineTo(2, 2);
2236 path.lineTo(1, 3);
2237 path.close();
2238 testSimplify(reporter, path, filename);
2239}
2240
2241static void testQuadralateral8(skiatest::Reporter* reporter, const char* filename) {
2242 SkPath path;
2243 path.moveTo(0, 0);
2244 path.lineTo(3, 1);
2245 path.lineTo(1, 3);
2246 path.lineTo(3, 3);
2247 path.close();
2248 path.moveTo(2, 1);
2249 path.lineTo(0, 2);
2250 path.lineTo(3, 2);
2251 path.lineTo(2, 3);
2252 path.close();
2253 testSimplify(reporter, path, filename);
2254}
2255
2256static void testQuadralateral8x(skiatest::Reporter* reporter, const char* filename) {
2257 SkPath path;
2258 path.setFillType(SkPathFillType::kEvenOdd);
2259 path.moveTo(0, 0);
2260 path.lineTo(3, 1);
2261 path.lineTo(1, 3);
2262 path.lineTo(3, 3);
2263 path.close();
2264 path.moveTo(2, 1);
2265 path.lineTo(0, 2);
2266 path.lineTo(3, 2);
2267 path.lineTo(2, 3);
2268 path.close();
2269 testSimplify(reporter, path, filename);
2270}
2271
2272static void testQuadralateral9(skiatest::Reporter* reporter, const char* filename) {
2273 SkPath path;
2274 path.moveTo(0, 0);
2275 path.lineTo(1, 0);
2276 path.lineTo(1, 2);
2277 path.lineTo(2, 2);
2278 path.close();
2279 path.moveTo(1, 1);
2280 path.lineTo(2, 1);
2281 path.lineTo(1, 3);
2282 path.lineTo(2, 3);
2283 path.close();
2284 testSimplify(reporter, path, filename);
2285}
2286
2287static void testQuadralateral9x(skiatest::Reporter* reporter, const char* filename) {
2288 SkPath path;
2289 path.setFillType(SkPathFillType::kEvenOdd);
2290 path.moveTo(0, 0);
2291 path.lineTo(1, 0);
2292 path.lineTo(1, 2);
2293 path.lineTo(2, 2);
2294 path.close();
2295 path.moveTo(1, 1);
2296 path.lineTo(2, 1);
2297 path.lineTo(1, 3);
2298 path.lineTo(2, 3);
2299 path.close();
2300 testSimplify(reporter, path, filename);
2301}
2302
2303static void testLine1a(skiatest::Reporter* reporter, const char* filename) {
2304 SkPath path;
2305 path.setFillType(SkPathFillType::kWinding);
2306 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
2307 path.addRect(4, 0, 13, 13, SkPathDirection::kCCW);
2308 testSimplify(reporter, path, filename);
2309}
2310
2311static void testLine1ax(skiatest::Reporter* reporter, const char* filename) {
2312 SkPath path;
2313 path.setFillType(SkPathFillType::kEvenOdd);
2314 path.addRect(0, 0, 12, 12, SkPathDirection::kCW);
2315 path.addRect(4, 0, 13, 13, SkPathDirection::kCCW);
2316 testSimplify(reporter, path, filename);
2317}
2318
2319static void testLine2ax(skiatest::Reporter* reporter, const char* filename) {
2320 SkPath path;
2321 path.setFillType(SkPathFillType::kEvenOdd);
2322 path.addRect(0, 20, 20, 20, SkPathDirection::kCW);
2323 path.addRect(0, 20, 12, 30, SkPathDirection::kCW);
2324 path.addRect(12, 0, 21, 21, SkPathDirection::kCCW);
2325 testSimplify(reporter, path, filename);
2326}
2327
2328static void testLine3aax(skiatest::Reporter* reporter, const char* filename) {
2329 SkPath path;
2330 path.setFillType(SkPathFillType::kEvenOdd);
2331 path.addRect(10, 30, 30, 30, SkPathDirection::kCW);
2332 path.addRect(18, 20, 30, 30, SkPathDirection::kCCW);
2333 path.addRect(0, 32, 9, 36, SkPathDirection::kCCW);
2334 testSimplify(reporter, path, filename);
2335}
2336
2337static void testLine4ax(skiatest::Reporter* reporter, const char* filename) {
2338 SkPath path;
2339 path.setFillType(SkPathFillType::kEvenOdd);
2340 path.addRect(10, 30, 30, 30, SkPathDirection::kCW);
2341 path.addRect(24, 20, 36, 30, SkPathDirection::kCCW);
2342 path.addRect(0, 32, 9, 36, SkPathDirection::kCCW);
2343 testSimplify(reporter, path, filename);
2344}
2345
2346static void testQuadratic1(skiatest::Reporter* reporter, const char* filename) {
2347 SkPath path;
2348 path.moveTo(0, 0);
2349 path.quadTo(0, 0, 0, 0);
2350 path.lineTo(1, 0);
2351 path.close();
2352 path.moveTo(0, 0);
2353 path.lineTo(0, 0);
2354 path.quadTo(0, 0, 0, 0);
2355 path.close();
2356 testSimplify(reporter, path, filename);
2357}
2358
2359static void testQuadratic1x(skiatest::Reporter* reporter, const char* filename) {
2360 SkPath path;
2361 path.setFillType(SkPathFillType::kEvenOdd);
2362 path.moveTo(0, 0);
2363 path.quadTo(0, 0, 0, 0);
2364 path.lineTo(1, 0);
2365 path.close();
2366 path.moveTo(0, 0);
2367 path.lineTo(0, 0);
2368 path.quadTo(0, 0, 0, 0);
2369 path.close();
2370 testSimplify(reporter, path, filename);
2371}
2372
2373static void testQuadratic2(skiatest::Reporter* reporter, const char* filename) {
2374 SkPath path;
2375 path.moveTo(0, 0);
2376 path.quadTo(0, 0, 0, 0);
2377 path.lineTo(3, 0);
2378 path.close();
2379 path.moveTo(0, 0);
2380 path.lineTo(0, 0);
2381 path.quadTo(1, 0, 0, 1);
2382 path.close();
2383 testSimplify(reporter, path, filename);
2384}
2385
2386static void testQuadratic2x(skiatest::Reporter* reporter, const char* filename) {
2387 SkPath path;
2388 path.setFillType(SkPathFillType::kEvenOdd);
2389 path.moveTo(0, 0);
2390 path.quadTo(0, 0, 0, 0);
2391 path.lineTo(3, 0);
2392 path.close();
2393 path.moveTo(0, 0);
2394 path.lineTo(0, 0);
2395 path.quadTo(1, 0, 0, 1);
2396 path.close();
2397 testSimplify(reporter, path, filename);
2398}
2399
2400static void testQuadratic3(skiatest::Reporter* reporter, const char* filename) {
2401 SkPath path;
2402 path.moveTo(0, 0);
2403 path.quadTo(0, 0, 1, 0);
2404 path.lineTo(0, 2);
2405 path.close();
2406 path.moveTo(0, 0);
2407 path.lineTo(0, 0);
2408 path.quadTo(1, 0, 0, 1);
2409 path.close();
2410 testSimplify(reporter, path, filename);
2411}
2412
2413static void testQuadratic3x(skiatest::Reporter* reporter, const char* filename) {
2414 SkPath path;
2415 path.setFillType(SkPathFillType::kEvenOdd);
2416 path.moveTo(0, 0);
2417 path.quadTo(0, 0, 1, 0);
2418 path.lineTo(0, 2);
2419 path.close();
2420 path.moveTo(0, 0);
2421 path.lineTo(0, 0);
2422 path.quadTo(1, 0, 0, 1);
2423 path.close();
2424 testSimplify(reporter, path, filename);
2425}
2426
2427static void testQuadratic4(skiatest::Reporter* reporter, const char* filename) {
2428 SkPath path;
2429 path.moveTo(0, 0);
2430 path.quadTo(0, 0, 1, 0);
2431 path.lineTo(0, 2);
2432 path.close();
2433 path.moveTo(0, 0);
2434 path.lineTo(0, 0);
2435 path.quadTo(1, 0, 0, 2);
2436 path.close();
2437 testSimplify(reporter, path, filename);
2438}
2439
2440static void testQuadratic4x(skiatest::Reporter* reporter, const char* filename) {
2441 SkPath path;
2442 path.setFillType(SkPathFillType::kEvenOdd);
2443 path.moveTo(0, 0);
2444 path.quadTo(0, 0, 1, 0);
2445 path.lineTo(0, 2);
2446 path.close();
2447 path.moveTo(0, 0);
2448 path.lineTo(0, 0);
2449 path.quadTo(1, 0, 0, 2);
2450 path.close();
2451 testSimplify(reporter, path, filename);
2452}
2453
2454static void testQuadratic5(skiatest::Reporter* reporter, const char* filename) {
2455 SkPath path;
2456 path.moveTo(0, 0);
2457 path.quadTo(0, 0, 0, 0);
2458 path.lineTo(0, 1);
2459 path.close();
2460 path.moveTo(0, 0);
2461 path.lineTo(1, 0);
2462 path.quadTo(0, 1, 0, 2);
2463 path.close();
2464 testSimplify(reporter, path, filename);
2465}
2466
2467static void testQuadratic6(skiatest::Reporter* reporter, const char* filename) {
2468 SkPath path;
2469 path.moveTo(0, 0);
2470 path.quadTo(0, 0, 1, 0);
2471 path.lineTo(2, 1);
2472 path.close();
2473 path.moveTo(0, 0);
2474 path.lineTo(0, 0);
2475 path.quadTo(2, 0, 0, 1);
2476 path.close();
2477 testSimplify(reporter, path, filename);
2478}
2479
2480static void testQuadratic7(skiatest::Reporter* reporter, const char* filename) {
2481 SkPath path;
2482 path.moveTo(0, 0);
2483 path.quadTo(0, 0, 1, 0);
2484 path.lineTo(3, 1);
2485 path.close();
2486 path.moveTo(0, 0);
2487 path.lineTo(0, 0);
2488 path.quadTo(3, 0, 1, 2);
2489 path.close();
2490 markTestFlakyForPathKit();
2491 testSimplify(reporter, path, filename);
2492}
2493
2494static void testQuadratic8(skiatest::Reporter* reporter, const char* filename) {
2495 SkPath path;
2496 path.moveTo(0, 0);
2497 path.quadTo(0, 0, 1, 0);
2498 path.lineTo(0, 2);
2499 path.close();
2500 path.moveTo(0, 0);
2501 path.lineTo(1, 0);
2502 path.quadTo(0, 1, 1, 2);
2503 path.close();
2504 testSimplify(reporter, path, filename);
2505}
2506
2507static void testQuadratic9(skiatest::Reporter* reporter, const char* filename) {
2508 SkPath path;
2509 path.moveTo(0, 0);
2510 path.quadTo(0, 0, 1, 0);
2511 path.lineTo(3, 1);
2512 path.close();
2513 path.moveTo(0, 0);
2514 path.lineTo(1, 0);
2515 path.quadTo(1, 2, 3, 2);
2516 path.close();
2517 testSimplify(reporter, path, filename);
2518}
2519
2520static void testQuadratic14(skiatest::Reporter* reporter, const char* filename) {
2521 SkPath path;
2522 path.moveTo(0, 0);
2523 path.quadTo(0, 0, 1, 0);
2524 path.lineTo(3, 2);
2525 path.close();
2526 path.moveTo(0, 0);
2527 path.lineTo(1, 0);
2528 path.quadTo(3, 2, 3, 3);
2529 path.close();
2530 testSimplify(reporter, path, filename);
2531}
2532
2533static void testQuadratic15(skiatest::Reporter* reporter, const char* filename) {
2534 SkPath path;
2535 path.moveTo(0, 0);
2536 path.quadTo(0, 0, 1, 0);
2537 path.lineTo(1, 3);
2538 path.close();
2539 path.moveTo(1, 0);
2540 path.lineTo(0, 1);
2541 path.quadTo(1, 1, 0, 3);
2542 path.close();
2543 testSimplify(reporter, path, filename);
2544}
2545
2546static void testQuadratic17x(skiatest::Reporter* reporter, const char* filename) {
2547 SkPath path;
2548 path.setFillType(SkPathFillType::kEvenOdd);
2549 path.moveTo(0, 0);
2550 path.quadTo(0, 0, 3, 1);
2551 path.lineTo(0, 2);
2552 path.close();
2553 path.moveTo(0, 0);
2554 path.lineTo(1, 0);
2555 path.quadTo(3, 1, 0, 2);
2556 path.close();
2557 testSimplify(reporter, path, filename);
2558}
2559
2560static void testQuadratic18(skiatest::Reporter* reporter, const char* filename) {
2561 SkPath path;
2562 path.moveTo(0, 0);
2563 path.quadTo(1, 0, 0, 1);
2564 path.lineTo(0, 1);
2565 path.close();
2566 path.moveTo(0, 0);
2567 path.lineTo(0, 0);
2568 path.quadTo(1, 0, 1, 1);
2569 path.close();
2570 testSimplify(reporter, path, filename);
2571}
2572
2573static void testQuadratic19(skiatest::Reporter* reporter, const char* filename) {
2574 SkPath path;
2575 path.moveTo(0, 0);
2576 path.quadTo(1, 0, 0, 1);
2577 path.lineTo(0, 1);
2578 path.close();
2579 path.moveTo(0, 0);
2580 path.lineTo(0, 0);
2581 path.quadTo(2, 0, 0, 1);
2582 path.close();
2583 testSimplify(reporter, path, filename);
2584}
2585
2586static void testQuadratic20(skiatest::Reporter* reporter, const char* filename) {
2587 SkPath path;
2588 path.moveTo(0, 0);
2589 path.quadTo(1, 0, 0, 1);
2590 path.lineTo(0, 1);
2591 path.close();
2592 path.moveTo(0, 0);
2593 path.lineTo(0, 0);
2594 path.quadTo(1, 0, 0, 1);
2595 path.close();
2596 testSimplify(reporter, path, filename);
2597}
2598
2599static void testQuadratic21(skiatest::Reporter* reporter, const char* filename) {
2600 SkPath path;
2601 path.moveTo(0, 0);
2602 path.quadTo(1, 0, 0, 1);
2603 path.lineTo(0, 1);
2604 path.close();
2605 path.moveTo(0, 0);
2606 path.lineTo(0, 0);
2607 path.quadTo(1, 0, 0, 2);
2608 path.close();
2609 testSimplify(reporter, path, filename);
2610}
2611
2612static void testQuadratic22(skiatest::Reporter* reporter, const char* filename) {
2613 SkPath path;
2614 path.moveTo(0, 0);
2615 path.quadTo(1, 0, 0, 1);
2616 path.lineTo(0, 1);
2617 path.close();
2618 path.moveTo(0, 0);
2619 path.lineTo(0, 0);
2620 path.quadTo(0, 1, 2, 1);
2621 path.close();
2622 testSimplify(reporter, path, filename);
2623}
2624
2625static void testQuadratic23(skiatest::Reporter* reporter, const char* filename) {
2626 SkPath path;
2627 path.moveTo(0, 0);
2628 path.quadTo(1, 0, 0, 1);
2629 path.lineTo(0, 1);
2630 path.close();
2631 path.moveTo(0, 0);
2632 path.lineTo(0, 0);
2633 path.quadTo(0, 2, 1, 2);
2634 path.close();
2635 testSimplify(reporter, path, filename);
2636}
2637
2638static void testQuadratic24(skiatest::Reporter* reporter, const char* filename) {
2639 SkPath path;
2640 path.moveTo(0, 0);
2641 path.quadTo(1, 0, 0, 1);
2642 path.lineTo(0, 1);
2643 path.close();
2644 path.moveTo(0, 0);
2645 path.lineTo(1, 0);
2646 path.quadTo(2, 0, 0, 1);
2647 path.close();
2648 testSimplify(reporter, path, filename);
2649}
2650
2651static void testQuadratic25(skiatest::Reporter* reporter, const char* filename) {
2652 SkPath path;
2653 path.moveTo(0, 0);
2654 path.quadTo(1, 0, 1, 1);
2655 path.lineTo(1, 1);
2656 path.close();
2657 path.moveTo(0, 0);
2658 path.lineTo(0, 0);
2659 path.quadTo(2, 1, 0, 2);
2660 path.close();
2661 testSimplify(reporter, path, filename);
2662}
2663
2664static void testQuadratic26(skiatest::Reporter* reporter, const char* filename) {
2665 SkPath path;
2666 path.moveTo(0, 0);
2667 path.quadTo(1, 0, 1, 1);
2668 path.lineTo(0, 2);
2669 path.close();
2670 path.moveTo(0, 0);
2671 path.lineTo(0, 0);
2672 path.quadTo(1, 0, 0, 1);
2673 path.close();
2674 testSimplify(reporter, path, filename);
2675}
2676
2677static void testQuadratic27(skiatest::Reporter* reporter, const char* filename) {
2678 SkPath path;
2679 path.moveTo(0, 0);
2680 path.quadTo(1, 0, 1, 1);
2681 path.lineTo(2, 1);
2682 path.close();
2683 path.moveTo(0, 0);
2684 path.lineTo(0, 0);
2685 path.quadTo(2, 1, 0, 2);
2686 path.close();
2687 testSimplify(reporter, path, filename);
2688}
2689
2690static void testQuadratic28(skiatest::Reporter* reporter, const char* filename) {
2691 SkPath path;
2692 path.moveTo(0, 0);
2693 path.quadTo(1, 0, 0, 1);
2694 path.lineTo(0, 1);
2695 path.close();
2696 path.moveTo(0, 0);
2697 path.lineTo(0, 2);
2698 path.quadTo(1, 2, 0, 3);
2699 path.close();
2700 testSimplify(reporter, path, filename);
2701}
2702
2703static void testQuadratic29(skiatest::Reporter* reporter, const char* filename) {
2704 SkPath path;
2705 path.moveTo(0, 0);
2706 path.quadTo(1, 0, 2, 1);
2707 path.lineTo(0, 2);
2708 path.close();
2709 path.moveTo(0, 0);
2710 path.lineTo(0, 0);
2711 path.quadTo(1, 0, 0, 1);
2712 path.close();
2713 testSimplify(reporter, path, filename);
2714}
2715
2716static void testQuadratic30(skiatest::Reporter* reporter, const char* filename) {
2717 SkPath path;
2718 path.moveTo(0, 0);
2719 path.quadTo(1, 0, 1, 2);
2720 path.lineTo(1, 2);
2721 path.close();
2722 path.moveTo(0, 0);
2723 path.lineTo(1, 0);
2724 path.quadTo(0, 1, 1, 2);
2725 path.close();
2726 testSimplify(reporter, path, filename);
2727}
2728
2729static void testQuadratic31(skiatest::Reporter* reporter, const char* filename) {
2730 SkPath path;
2731 path.moveTo(0, 0);
2732 path.quadTo(1, 0, 1, 2);
2733 path.lineTo(1, 2);
2734 path.close();
2735 path.moveTo(0, 0);
2736 path.lineTo(1, 0);
2737 path.quadTo(0, 1, 1, 3);
2738 path.close();
2739 testSimplify(reporter, path, filename);
2740}
2741
2742static void testQuadratic32(skiatest::Reporter* reporter, const char* filename) {
2743 SkPath path;
2744 path.moveTo(0, 0);
2745 path.quadTo(1, 0, 2, 3);
2746 path.lineTo(2, 3);
2747 path.close();
2748 path.moveTo(0, 0);
2749 path.lineTo(0, 0);
2750 path.quadTo(3, 1, 0, 2);
2751 path.close();
2752 testSimplify(reporter, path, filename);
2753}
2754
2755static void testQuadratic33(skiatest::Reporter* reporter, const char* filename) {
2756 SkPath path;
2757 path.moveTo(0, 0);
2758 path.quadTo(2, 0, 0, 1);
2759 path.lineTo(0, 1);
2760 path.close();
2761 path.moveTo(0, 0);
2762 path.lineTo(1, 1);
2763 path.quadTo(2, 1, 2, 2);
2764 path.close();
2765 testSimplify(reporter, path, filename);
2766}
2767
2768static void testQuadratic34(skiatest::Reporter* reporter, const char* filename) {
2769 SkPath path;
2770 path.moveTo(0, 0);
2771 path.quadTo(2, 0, 0, 1);
2772 path.lineTo(0, 1);
2773 path.close();
2774 path.moveTo(1, 0);
2775 path.lineTo(1, 1);
2776 path.quadTo(2, 1, 1, 2);
2777 path.close();
2778 markTestFlakyForPathKit();
2779 testSimplify(reporter, path, filename);
2780}
2781
2782static void testQuadratic35(skiatest::Reporter* reporter, const char* filename) {
2783 SkPath path;
2784 path.moveTo(0, 0);
2785 path.quadTo(0, 1, 1, 1);
2786 path.lineTo(1, 3);
2787 path.close();
2788 path.moveTo(2, 0);
2789 path.lineTo(3, 0);
2790 path.quadTo(0, 1, 1, 1);
2791 path.close();
2792 testSimplify(reporter, path, filename);
2793}
2794
2795static void testQuadratic36(skiatest::Reporter* reporter, const char* filename) {
2796 SkPath path;
2797 path.moveTo(0, 0);
2798 path.quadTo(2, 1, 2, 3);
2799 path.lineTo(2, 3);
2800 path.close();
2801 path.moveTo(3, 1);
2802 path.lineTo(1, 2);
2803 path.quadTo(3, 2, 1, 3);
2804 path.close();
2805 testSimplify(reporter, path, filename);
2806}
2807
2808static void testQuadratic37(skiatest::Reporter* reporter, const char* filename) {
2809 SkPath path;
2810 path.moveTo(0, 0);
2811 path.quadTo(0, 2, 1, 2);
2812 path.lineTo(1, 2);
2813 path.close();
2814 path.moveTo(0, 0);
2815 path.lineTo(3, 1);
2816 path.quadTo(0, 2, 1, 2);
2817 path.close();
2818 testSimplify(reporter, path, filename);
2819}
2820
2821static void testQuadratic38(skiatest::Reporter* reporter, const char* filename) {
2822 SkPath path;
2823 path.moveTo(1, 0);
2824 path.quadTo(0, 1, 1, 1);
2825 path.lineTo(1, 1);
2826 path.close();
2827 path.moveTo(1, 0);
2828 path.lineTo(1, 2);
2829 path.quadTo(2, 2, 1, 3);
2830 path.close();
2831 testSimplify(reporter, path, filename);
2832}
2833
2834static void testQuadratic51(skiatest::Reporter* reporter, const char* filename) {
2835 SkPath path;
2836 path.moveTo(369.863983f, 145.645813f);
2837 path.quadTo(382.380371f, 121.254936f, 406.236359f, 121.254936f);
2838 path.lineTo(369.863983f, 145.645813f);
2839 path.close();
2840 path.moveTo(369.970581f, 137.94342f);
2841 path.quadTo(383.98465f, 121.254936f, 406.235992f, 121.254936f);
2842 path.lineTo(369.970581f, 137.94342f);
2843 path.close();
2844 testSimplify(reporter, path, filename);
2845}
2846
2847static void testQuadratic53(skiatest::Reporter* reporter, const char* filename) {
2848 SkPath path;
2849 path.moveTo(303.12088f, 141.299606f);
2850 path.lineTo(330.463562f, 217.659027f);
2851 path.lineTo(303.12088f, 141.299606f);
2852 path.close();
2853 path.moveTo(371.919067f, 205.854996f);
2854 path.lineTo(326.236786f, 205.854996f);
2855 path.quadTo(329.104431f, 231.663818f, 351.512085f, 231.663818f);
2856 path.lineTo(371.919067f, 205.854996f);
2857 path.close();
2858 testSimplify(reporter, path, filename);
2859}
2860
2861static void testQuadratic55(skiatest::Reporter* reporter, const char* filename) {
2862 SkPath path;
2863path.moveTo(303.12088f, 141.299606f);
2864path.lineTo(330.463562f, 217.659027f);
2865path.lineTo(358.606506f, 141.299606f);
2866path.lineTo(303.12088f, 141.299606f);
2867path.close();
2868path.moveTo(326.236786f, 205.854996f);
2869path.quadTo(329.104431f, 231.663818f, 351.512085f, 231.663818f);
2870path.lineTo(326.236786f, 205.854996f);
2871path.close();
2872 testSimplify(reporter, path, filename);
2873}
2874
2875static void testQuadratic56(skiatest::Reporter* reporter, const char* filename) {
2876 SkPath path;
2877path.moveTo(366.608826f, 151.196014f);
2878path.quadTo(378.803101f, 136.674606f, 398.164948f, 136.674606f);
2879path.lineTo(354.009216f, 208.816208f);
2880path.lineTo(393.291473f, 102.232819f);
2881path.lineTo(359.978058f, 136.581512f);
2882path.quadTo(378.315979f, 136.581512f, 388.322723f, 149.613556f);
2883path.lineTo(364.390686f, 157.898193f);
2884path.quadTo(375.281769f, 136.674606f, 396.039917f, 136.674606f);
2885path.lineTo(350, 120);
2886path.lineTo(366.608826f, 151.196014f);
2887path.close();
2888 testSimplify(reporter, path, filename);
2889}
2890
2891static void testLine80(skiatest::Reporter* reporter, const char* filename) {
2892 SkPath path;
2893path.moveTo(4, 0);
2894path.lineTo(3, 7);
2895path.lineTo(7, 5);
2896path.lineTo(2, 2);
2897path.close();
2898path.moveTo(0, 6);
2899path.lineTo(6, 12);
2900path.lineTo(8, 3);
2901path.close();
2902 testSimplify(reporter, path, filename);
2903}
2904
2905static void testQuadratic58(skiatest::Reporter* reporter, const char* filename) {
2906 SkPath path;
2907 path.moveTo(283.714233f, 240);
2908 path.lineTo(283.714233f, 141.299606f);
2909 path.lineTo(303.12088f, 141.299606f);
2910 path.lineTo(330.463562f, 217.659027f);
2911 path.lineTo(358.606506f, 141.299606f);
2912 path.lineTo(362.874634f, 159.705902f);
2913 path.lineTo(335.665344f, 233.397751f);
2914 path.lineTo(322.12738f, 233.397751f);
2915 path.lineTo(295.718353f, 159.505829f);
2916 path.lineTo(295.718353f, 240);
2917 path.lineTo(283.714233f, 240);
2918 path.close();
2919 path.moveTo(322.935669f, 231.030273f);
2920 path.quadTo(312.832214f, 220.393295f, 312.832214f, 203.454178f);
2921 path.quadTo(312.832214f, 186.981888f, 321.73526f, 176.444946f);
2922 path.quadTo(330.638306f, 165.90802f, 344.509705f, 165.90802f);
2923 path.quadTo(357.647522f, 165.90802f, 364.81665f, 175.244537f);
2924 path.lineTo(371.919067f, 205.854996f);
2925 path.lineTo(326.236786f, 205.854996f);
2926 path.quadTo(329.104431f, 231.663818f, 351.512085f, 231.663818f);
2927 path.lineTo(322.935669f, 231.030273f);
2928 path.close();
2929 path.moveTo(326.837006f, 195.984955f);
2930 path.lineTo(358.78125f, 195.984955f);
2931 path.quadTo(358.78125f, 175.778046f, 343.709442f, 175.778046f);
2932 path.quadTo(328.570923f, 175.778046f, 326.837006f, 195.984955f);
2933 path.close();
2934 testSimplify(reporter, path, filename);
2935}
2936
2937static void testQuadratic59x(skiatest::Reporter* reporter, const char* filename) {
2938 SkPath path;
2939 path.setFillType(SkPathFillType::kEvenOdd);
2940 path.moveTo(0, 0);
2941 path.quadTo(0, 0, 0, 0);
2942 path.lineTo(2, 2);
2943 path.close();
2944 path.moveTo(0, 0);
2945 path.lineTo(2, 0);
2946 path.quadTo(3, 1, 1, 2);
2947 path.close();
2948 testSimplify(reporter, path, filename);
2949}
2950
2951static void testQuadratic59(skiatest::Reporter* reporter, const char* filename) {
2952 SkPath path;
2953 path.setFillType(SkPathFillType::kWinding);
2954 path.moveTo(0, 0);
2955 path.quadTo(0, 0, 0, 0);
2956 path.lineTo(2, 2);
2957 path.close();
2958 path.moveTo(0, 0);
2959 path.lineTo(2, 0);
2960 path.quadTo(3, 1, 1, 2);
2961 path.close();
2962 testSimplify(reporter, path, filename);
2963}
2964
2965static void testQuadratic63(skiatest::Reporter* reporter, const char* filename) {
2966 SkPath path;
2967 path.moveTo(0, 0);
2968 path.quadTo(0, 0, 0, 0);
2969 path.lineTo(3, 2);
2970 path.close();
2971 path.moveTo(1, 0);
2972 path.lineTo(2, 1);
2973 path.quadTo(2, 1, 2, 2);
2974 path.close();
2975 testSimplify(reporter, path, filename);
2976}
2977
2978static void testQuadratic64(skiatest::Reporter* reporter, const char* filename) {
2979 SkPath path;
2980 path.moveTo(0, 0);
2981 path.quadTo(0, 0, 0, 0);
2982 path.lineTo(2, 3);
2983 path.close();
2984 path.moveTo(1, 2);
2985 path.lineTo(2, 2);
2986 path.quadTo(0, 3, 3, 3);
2987 path.close();
2988 testSimplify(reporter, path, filename);
2989}
2990
2991static void testQuadratic65(skiatest::Reporter* reporter, const char* filename) {
2992 SkPath path;
2993 path.moveTo(0, 0);
2994 path.quadTo(0, 0, 0, 0);
2995 path.lineTo(3, 2);
2996 path.close();
2997 path.moveTo(2, 1);
2998 path.lineTo(2, 2);
2999 path.quadTo(0, 3, 1, 3);
3000 path.close();
3001 testSimplify(reporter, path, filename);
3002}
3003
3004static void testQuadratic67x(skiatest::Reporter* reporter, const char* filename) {
3005 SkPath path;
3006 path.setFillType(SkPathFillType::kEvenOdd);
3007 path.moveTo(0, 0);
3008 path.quadTo(0, 0, 2, 1);
3009 path.lineTo(2, 2);
3010 path.close();
3011 path.moveTo(0, 0);
3012 path.lineTo(2, 0);
3013 path.quadTo(1, 1, 3, 2);
3014 path.close();
3015 testSimplify(reporter, path, filename);
3016}
3017
3018static void testQuadratic68(skiatest::Reporter* reporter, const char* filename) {
3019 SkPath path;
3020 path.moveTo(0, 0);
3021 path.quadTo(1, 0, 0, 1);
3022 path.lineTo(1, 2);
3023 path.close();
3024 path.moveTo(0, 0);
3025 path.lineTo(0, 0);
3026 path.quadTo(0, 1, 2, 1);
3027 path.close();
3028 testSimplify(reporter, path, filename);
3029}
3030
3031static void testQuadratic69(skiatest::Reporter* reporter, const char* filename) {
3032 SkPath path;
3033 path.moveTo(0, 0);
3034 path.quadTo(0, 0, 0, 1);
3035 path.lineTo(3, 2);
3036 path.close();
3037 path.moveTo(2, 0);
3038 path.lineTo(1, 1);
3039 path.quadTo(3, 2, 2, 3);
3040 path.close();
3041 markTestFlakyForPathKit();
3042 testSimplify(reporter, path, filename);
3043}
3044
3045static void testQuadratic70x(skiatest::Reporter* reporter, const char* filename) {
3046 SkPath path;
3047 path.setFillType(SkPathFillType::kEvenOdd);
3048 path.moveTo(0, 0);
3049 path.quadTo(1, 0, 0, 1);
3050 path.lineTo(1, 2);
3051 path.close();
3052 path.moveTo(0, 0);
3053 path.lineTo(0, 0);
3054 path.quadTo(0, 1, 2, 1);
3055 path.close();
3056 testSimplify(reporter, path, filename);
3057}
3058
3059static void testQuadratic71(skiatest::Reporter* reporter, const char* filename) {
3060 SkPath path;
3061 path.moveTo(0, 0);
3062 path.quadTo(1, 0, 1, 1);
3063 path.lineTo(3, 2);
3064 path.close();
3065 path.moveTo(0, 0);
3066 path.lineTo(0, 0);
3067 path.quadTo(1, 1, 3, 1);
3068 path.close();
3069 testSimplify(reporter, path, filename);
3070}
3071
3072static void testQuadratic72(skiatest::Reporter* reporter, const char* filename) {
3073 SkPath path;
3074 path.moveTo(0, 0);
3075 path.quadTo(1, 0, 1, 2);
3076 path.lineTo(1, 2);
3077 path.close();
3078 path.moveTo(0, 0);
3079 path.lineTo(1, 0);
3080 path.quadTo(0, 1, 3, 2);
3081 path.close();
3082 testSimplify(reporter, path, filename);
3083}
3084
3085static void testQuadratic73(skiatest::Reporter* reporter, const char* filename) {
3086 SkPath path;
3087 path.moveTo(0, 0);
3088 path.quadTo(1, 0, 0, 3);
3089 path.lineTo(0, 3);
3090 path.close();
3091 path.moveTo(0, 0);
3092 path.lineTo(1, 0);
3093 path.quadTo(0, 1, 1, 1);
3094 path.close();
3095 testSimplify(reporter, path, filename);
3096}
3097
3098static void testQuadratic74(skiatest::Reporter* reporter, const char* filename) {
3099 SkPath path;
3100 path.moveTo(0, 0);
3101 path.quadTo(1, 0, 1, 3);
3102 path.lineTo(1, 3);
3103 path.close();
3104 path.moveTo(0, 0);
3105 path.lineTo(0, 1);
3106 path.quadTo(3, 2, 2, 3);
3107 path.close();
3108 testSimplify(reporter, path, filename);
3109}
3110
3111static void testQuadratic75(skiatest::Reporter* reporter, const char* filename) {
3112 SkPath path;
3113 path.moveTo(0, 0);
3114 path.quadTo(1, 0, 1, 3);
3115 path.lineTo(2, 3);
3116 path.close();
3117 path.moveTo(0, 0);
3118 path.lineTo(0, 1);
3119 path.quadTo(3, 2, 2, 3);
3120 path.close();
3121 testSimplify(reporter, path, filename);
3122}
3123
3124static void testQuadratic76(skiatest::Reporter* reporter, const char* filename) {
3125 SkPath path;
3126 path.moveTo(0, 0);
3127 path.quadTo(0, 0, 0, 0);
3128 path.lineTo(2, 3);
3129 path.close();
3130 path.moveTo(1, 0);
3131 path.lineTo(1, 2);
3132 path.quadTo(1, 2, 2, 2);
3133 path.close();
3134 testSimplify(reporter, path, filename);
3135}
3136
3137static void testQuadratic77(skiatest::Reporter* reporter, const char* filename) {
3138 SkPath path;
3139 path.moveTo(0, 0);
3140 path.quadTo(1, 0, 1, 1);
3141 path.lineTo(3, 1);
3142 path.close();
3143 path.moveTo(0, 0);
3144 path.lineTo(1, 0);
3145 path.quadTo(0, 1, 3, 2);
3146 path.close();
3147 testSimplify(reporter, path, filename);
3148}
3149
3150static void testQuadratic78(skiatest::Reporter* reporter, const char* filename) {
3151 SkPath path;
3152 path.moveTo(0, 0);
3153 path.quadTo(1, 0, 1, 2);
3154 path.lineTo(3, 2);
3155 path.close();
3156 path.moveTo(0, 0);
3157 path.lineTo(0, 0);
3158 path.quadTo(2, 1, 0, 2);
3159 path.close();
3160 testSimplify(reporter, path, filename);
3161}
3162
3163static void testQuadratic79(skiatest::Reporter* reporter, const char* filename) {
3164 SkPath path;
3165 path.moveTo(0, 0);
3166 path.quadTo(1, 0, 1, 2);
3167 path.lineTo(3, 2);
3168 path.close();
3169 path.moveTo(0, 0);
3170 path.lineTo(1, 0);
3171 path.quadTo(0, 1, 3, 2);
3172 path.close();
3173 testSimplify(reporter, path, filename);
3174}
3175
3176static void testEight1(skiatest::Reporter* reporter, const char* filename) {
3177 SkPath path;
3178 path.moveTo(0, 0);
3179 path.lineTo(2, 2);
3180 path.lineTo(0, 2);
3181 path.lineTo(2, 0);
3182 path.close();
3183 testSimplify(reporter, path, filename);
3184}
3185
3186static void testEight2(skiatest::Reporter* reporter, const char* filename) {
3187 SkPath path;
3188 path.moveTo(0, 0);
3189 path.lineTo(2, 0);
3190 path.lineTo(0, 2);
3191 path.lineTo(2, 2);
3192 path.close();
3193 testSimplify(reporter, path, filename);
3194}
3195
3196static void testEight3(skiatest::Reporter* reporter, const char* filename) {
3197 SkPath path;
3198 path.moveTo(0, 0);
3199 path.lineTo(0, 2);
3200 path.lineTo(2, 0);
3201 path.lineTo(2, 2);
3202 path.close();
3203 testSimplify(reporter, path, filename);
3204}
3205
3206static void testEight4(skiatest::Reporter* reporter, const char* filename) {
3207 SkPath path;
3208 path.moveTo(0, 0);
3209 path.lineTo(2, 2);
3210 path.lineTo(2, 0);
3211 path.lineTo(0, 2);
3212 path.close();
3213 testSimplify(reporter, path, filename);
3214}
3215
3216static void testEight5(skiatest::Reporter* reporter, const char* filename) {
3217 SkPath path;
3218 path.moveTo(1, 0);
3219 path.lineTo(1, 2);
3220 path.lineTo(0, 2);
3221 path.lineTo(2, 0);
3222 path.close();
3223 testSimplify(reporter, path, filename);
3224}
3225
3226static void testEight6(skiatest::Reporter* reporter, const char* filename) {
3227 SkPath path;
3228 path.moveTo(1, 0);
3229 path.lineTo(2, 0);
3230 path.lineTo(0, 2);
3231 path.lineTo(1, 2);
3232 path.close();
3233 testSimplify(reporter, path, filename);
3234}
3235
3236static void testEight7(skiatest::Reporter* reporter, const char* filename) {
3237 SkPath path;
3238 path.moveTo(0, 0);
3239 path.lineTo(0, 1);
3240 path.lineTo(2, 1);
3241 path.lineTo(2, 2);
3242 path.close();
3243 testSimplify(reporter, path, filename);
3244}
3245
3246static void testEight8(skiatest::Reporter* reporter, const char* filename) {
3247 SkPath path;
3248 path.moveTo(0, 0);
3249 path.lineTo(2, 2);
3250 path.lineTo(2, 1);
3251 path.lineTo(0, 1);
3252 path.close();
3253 testSimplify(reporter, path, filename);
3254}
3255
3256static void testEight9(skiatest::Reporter* reporter, const char* filename) {
3257 SkPath path;
3258 path.moveTo(1, 0);
3259 path.lineTo(1, 2);
3260 path.lineTo(2, 1);
3261 path.lineTo(0, 1);
3262 path.close();
3263 testSimplify(reporter, path, filename);
3264}
3265
3266static void testEight10(skiatest::Reporter* reporter, const char* filename) {
3267 SkPath path;
3268 path.moveTo(1, 0);
3269 path.lineTo(0, 1);
3270 path.lineTo(2, 1);
3271 path.lineTo(1, 2);
3272 path.close();
3273 testSimplify(reporter, path, filename);
3274}
3275
3276static void testQuadratic80(skiatest::Reporter* reporter, const char* filename) {
3277 SkPath path;
3278 path.moveTo(0, 0);
3279 path.quadTo(1, 0, 2, 3);
3280 path.lineTo(2, 3);
3281 path.close();
3282 path.moveTo(1, 0);
3283 path.lineTo(3, 0);
3284 path.quadTo(0, 1, 1, 1);
3285 path.close();
3286 testSimplify(reporter, path, filename);
3287}
3288
3289static void testQuadratic81(skiatest::Reporter* reporter, const char* filename) {
3290 SkPath path;
3291 path.moveTo(0, 0);
3292 path.quadTo(2, 0, 1, 1);
3293 path.lineTo(1, 1);
3294 path.close();
3295 path.moveTo(0, 0);
3296 path.lineTo(0, 0);
3297 path.quadTo(2, 1, 0, 2);
3298 path.close();
3299 testSimplify(reporter, path, filename);
3300}
3301
3302static void testQuadratic82(skiatest::Reporter* reporter, const char* filename) {
3303 SkPath path;
3304 path.moveTo(0, 0);
3305 path.quadTo(2, 0, 1, 1);
3306 path.lineTo(0, 3);
3307 path.close();
3308 path.moveTo(0, 0);
3309 path.lineTo(0, 0);
3310 path.quadTo(2, 1, 0, 2);
3311 path.close();
3312 testSimplify(reporter, path, filename);
3313}
3314
3315static void testQuadratic83(skiatest::Reporter* reporter, const char* filename) {
3316 SkPath path;
3317 path.moveTo(0, 0);
3318 path.quadTo(0, 0, 2, 0);
3319 path.lineTo(2, 2);
3320 path.close();
3321 path.moveTo(0, 1);
3322 path.lineTo(0, 2);
3323 path.quadTo(2, 2, 1, 3);
3324 path.close();
3325 testSimplify(reporter, path, filename);
3326}
3327
3328static void testQuadratic84(skiatest::Reporter* reporter, const char* filename) {
3329 SkPath path;
3330 path.moveTo(0, 0);
3331 path.quadTo(2, 0, 1, 1);
3332 path.lineTo(2, 1);
3333 path.close();
3334 path.moveTo(1, 0);
3335 path.lineTo(2, 0);
3336 path.quadTo(0, 1, 2, 2);
3337 path.close();
3338 testSimplify(reporter, path, filename);
3339}
3340
3341static void testQuadratic85(skiatest::Reporter* reporter, const char* filename) {
3342 SkPath path;
3343 path.moveTo(0, 0);
3344 path.quadTo(3, 0, 1, 1);
3345 path.lineTo(1, 1);
3346 path.close();
3347 path.moveTo(1, 0);
3348 path.lineTo(3, 0);
3349 path.quadTo(0, 1, 1, 2);
3350 path.close();
3351 testSimplify(reporter, path, filename);
3352}
3353
3354static void testQuadratic86(skiatest::Reporter* reporter, const char* filename) {
3355 SkPath path;
3356 path.moveTo(0, 0);
3357 path.quadTo(0, 1, 1, 1);
3358 path.lineTo(2, 3);
3359 path.close();
3360 path.moveTo(0, 0);
3361 path.lineTo(0, 0);
3362 path.quadTo(1, 1, 1, 3);
3363 path.close();
3364 testSimplify(reporter, path, filename);
3365}
3366
3367static void testQuadratic87(skiatest::Reporter* reporter, const char* filename) {
3368 SkPath path;
3369 path.moveTo(0, 0);
3370 path.quadTo(2, 1, 0, 2);
3371 path.lineTo(2, 3);
3372 path.close();
3373 path.moveTo(0, 0);
3374 path.lineTo(1, 1);
3375 path.quadTo(0, 2, 3, 2);
3376 path.close();
3377 testSimplify(reporter, path, filename);
3378}
3379
3380static void testQuadratic88(skiatest::Reporter* reporter, const char* filename) {
3381 SkPath path;
3382 path.moveTo(0, 0);
3383 path.quadTo(2, 1, 0, 2);
3384 path.lineTo(2, 2);
3385 path.close();
3386 path.moveTo(1, 0);
3387 path.lineTo(1, 1);
3388 path.quadTo(0, 2, 2, 2);
3389 path.close();
3390 testSimplify(reporter, path, filename);
3391}
3392
3393static void testQuadratic89x(skiatest::Reporter* reporter, const char* filename) {
3394 SkPath path;
3395 path.setFillType(SkPathFillType::kEvenOdd);
3396 path.moveTo(0, 0);
3397 path.quadTo(3, 1, 2, 2);
3398 path.lineTo(0, 3);
3399 path.close();
3400 path.moveTo(0, 0);
3401 path.lineTo(2, 1);
3402 path.quadTo(3, 1, 3, 3);
3403 path.close();
3404 testSimplify(reporter, path, filename);
3405}
3406
3407static void testQuadratic90x(skiatest::Reporter* reporter, const char* filename) {
3408 SkPath path;
3409 path.setFillType(SkPathFillType::kEvenOdd);
3410 path.moveTo(0, 0);
3411 path.quadTo(3, 0, 2, 2);
3412 path.lineTo(1, 3);
3413 path.close();
3414 path.moveTo(0, 0);
3415 path.lineTo(0, 1);
3416 path.quadTo(3, 2, 2, 3);
3417 path.close();
3418 testSimplify(reporter, path, filename);
3419}
3420
3421static void testQuadratic91(skiatest::Reporter* reporter, const char* filename) {
3422 SkPath path;
3423 path.moveTo(0, 0);
3424 path.quadTo(3, 2, 2, 3);
3425 path.lineTo(2, 3);
3426 path.close();
3427 path.moveTo(0, 0);
3428 path.lineTo(1, 1);
3429 path.quadTo(2, 1, 2, 3);
3430 path.close();
3431 testSimplify(reporter, path, filename);
3432}
3433
3434static void testQuadratic92x(skiatest::Reporter* reporter, const char* filename) {
3435 SkPath path;
3436 path.setFillType(SkPathFillType::kEvenOdd);
3437 path.moveTo(1, 0);
3438 path.quadTo(3, 0, 2, 2);
3439 path.lineTo(2, 2);
3440 path.close();
3441 path.moveTo(2, 0);
3442 path.lineTo(0, 1);
3443 path.quadTo(3, 2, 2, 3);
3444 path.close();
3445 testSimplify(reporter, path, filename);
3446}
3447
3448static void testLine82(skiatest::Reporter* reporter, const char* filename) {
3449 SkPath path;
3450 path.addRect(20, 0, 40, 40, SkPathDirection::kCCW);
3451 path.addRect(24, 20, 36, 30, SkPathDirection::kCCW);
3452 path.addRect(24, 32, 33, 36, SkPathDirection::kCCW);
3453 testSimplify(reporter, path, filename);
3454}
3455
3456static void testLine82a(skiatest::Reporter* reporter, const char* filename) {
3457 SkPath path;
3458 path.addRect(0, 0, 6, 10, SkPathDirection::kCW);
3459 path.addRect(2, 2, 4, 4, SkPathDirection::kCW);
3460 path.addRect(2, 6, 4, 8, SkPathDirection::kCW);
3461 testSimplify(reporter, path, filename);
3462}
3463
3464static void testLine82b(skiatest::Reporter* reporter, const char* filename) {
3465 SkPath path;
3466 path.addRect(0, 0, 6, 10, SkPathDirection::kCW);
3467 path.addRect(2, 2, 4, 4, SkPathDirection::kCW);
3468 path.addRect(2, 6, 4, 8, SkPathDirection::kCCW);
3469 testSimplify(reporter, path, filename);
3470}
3471
3472static void testLine82c(skiatest::Reporter* reporter, const char* filename) {
3473 SkPath path;
3474 path.addRect(0, 0, 6, 10, SkPathDirection::kCW);
3475 path.addRect(2, 2, 4, 4, SkPathDirection::kCCW);
3476 path.addRect(2, 6, 4, 8, SkPathDirection::kCW);
3477 testSimplify(reporter, path, filename);
3478}
3479
3480static void testLine82d(skiatest::Reporter* reporter, const char* filename) {
3481 SkPath path;
3482 path.addRect(0, 0, 6, 10, SkPathDirection::kCW);
3483 path.addRect(2, 2, 4, 4, SkPathDirection::kCCW);
3484 path.addRect(2, 6, 4, 8, SkPathDirection::kCCW);
3485 testSimplify(reporter, path, filename);
3486}
3487
3488static void testLine82e(skiatest::Reporter* reporter, const char* filename) {
3489 SkPath path;
3490 path.addRect(0, 0, 6, 10, SkPathDirection::kCCW);
3491 path.addRect(2, 2, 4, 4, SkPathDirection::kCW);
3492 path.addRect(2, 6, 4, 8, SkPathDirection::kCW);
3493 testSimplify(reporter, path, filename);
3494}
3495
3496static void testLine82f(skiatest::Reporter* reporter, const char* filename) {
3497 SkPath path;
3498 path.addRect(0, 0, 6, 10, SkPathDirection::kCCW);
3499 path.addRect(2, 2, 4, 4, SkPathDirection::kCW);
3500 path.addRect(2, 6, 4, 8, SkPathDirection::kCCW);
3501 testSimplify(reporter, path, filename);
3502}
3503
3504static void testLine82g(skiatest::Reporter* reporter, const char* filename) {
3505 SkPath path;
3506 path.addRect(0, 0, 6, 10, SkPathDirection::kCCW);
3507 path.addRect(2, 2, 4, 4, SkPathDirection::kCCW);
3508 path.addRect(2, 6, 4, 8, SkPathDirection::kCW);
3509 testSimplify(reporter, path, filename);
3510}
3511
3512static void testLine82h(skiatest::Reporter* reporter, const char* filename) {
3513 SkPath path;
3514 path.addRect(0, 0, 6, 10, SkPathDirection::kCCW);
3515 path.addRect(2, 2, 4, 4, SkPathDirection::kCCW);
3516 path.addRect(2, 6, 4, 8, SkPathDirection::kCCW);
3517 testSimplify(reporter, path, filename);
3518}
3519
3520static void testLine83(skiatest::Reporter* reporter, const char* filename) {
3521 SkPath path;
3522path.addRect(10, 30, 30, 40, SkPathDirection::kCCW);
3523path.addRect(0, 12, 12, 18, SkPathDirection::kCCW);
3524path.addRect(4, 13, 13, 16, SkPathDirection::kCCW);
3525 testSimplify(reporter, path, filename);
3526}
3527
3528static void testLine84(skiatest::Reporter* reporter, const char* filename) {
3529 SkPath path;
3530 path.addRect(0, 12, 60, 30, SkPathDirection::kCCW);
3531 path.addRect(10, 20, 40, 30, SkPathDirection::kCW);
3532 path.addRect(0, 12, 12, 12, SkPathDirection::kCW);
3533 path.addRect(4, 12, 13, 13, SkPathDirection::kCW);
3534 testSimplify(reporter, path, filename);
3535}
3536
3537static void testLine84x(skiatest::Reporter* reporter, const char* filename) {
3538 SkPath path;
3539 path.setFillType(SkPathFillType::kEvenOdd);
3540 path.addRect(0, 12, 60, 30, SkPathDirection::kCCW);
3541 path.addRect(10, 20, 40, 30, SkPathDirection::kCCW);
3542 path.addRect(0, 12, 12, 12, SkPathDirection::kCCW);
3543 path.addRect(4, 12, 13, 13, SkPathDirection::kCCW);
3544 testSimplify(reporter, path, filename);
3545}
3546
3547static void testLine85(skiatest::Reporter* reporter, const char* filename) {
3548 SkPath path;
3549 path.addRect(36, 0, 66, 60, SkPathDirection::kCCW);
3550 path.addRect(20, 0, 40, 40, SkPathDirection::kCCW);
3551 path.addRect(12, 0, 24, 24, SkPathDirection::kCCW);
3552 path.addRect(32, 0, 36, 41, SkPathDirection::kCCW);
3553 testSimplify(reporter, path, filename);
3554}
3555
3556static void testQuadralateral1(skiatest::Reporter* reporter, const char* filename) {
3557 SkPath path;
3558 path.moveTo(0, 0);
3559 path.lineTo(0, 0);
3560 path.lineTo(0, 0);
3561 path.lineTo(3, 2);
3562 path.close();
3563 path.moveTo(0, 0);
3564 path.lineTo(2, 1);
3565 path.lineTo(2, 2);
3566 path.lineTo(2, 3);
3567 path.close();
3568 testSimplify(reporter, path, filename);
3569}
3570
3571static void testCubic1(skiatest::Reporter* reporter, const char* filename) {
3572 SkPath path;
3573 path.moveTo(0, 0);
3574 path.cubicTo(0, 1, 1, 1, 1, 0);
3575 path.close();
3576 path.moveTo(1, 0);
3577 path.cubicTo(0, 0, 0, 1, 1, 1);
3578 path.close();
3579 testSimplify(reporter, path, filename);
3580}
3581
3582static void testQuadratic93(skiatest::Reporter* reporter, const char* filename) {
3583 SkPath path;
3584 path.moveTo(3, 0);
3585 path.quadTo(0, 1, 3, 2);
3586 path.lineTo(0, 3);
3587 path.close();
3588 path.moveTo(1, 0);
3589 path.lineTo(2, 0);
3590 path.quadTo(1, 1, 2, 2);
3591 path.close();
3592 testSimplify(reporter, path, filename);
3593}
3594
3595static void testCubic2(skiatest::Reporter* reporter, const char* filename) {
3596 SkPath path;
3597 path.moveTo(0,2);
3598 path.cubicTo(0,3, 2,1, 4,0);
3599 path.close();
3600 path.moveTo(1,2);
3601 path.cubicTo(0,4, 2,0, 3,0);
3602 path.close();
3603 testSimplify(reporter, path, filename);
3604}
3605
3606static void testQuad1(skiatest::Reporter* reporter, const char* filename) {
3607 SkPath path;
3608 path.moveTo(0,0);
3609 path.quadTo(0,0, 0,1);
3610 path.lineTo(1,1);
3611 path.close();
3612 path.moveTo(0,0);
3613 path.quadTo(1,1, 0,2);
3614 path.close();
3615 testSimplify(reporter, path, filename);
3616}
3617
3618static void testQuadralateral2(skiatest::Reporter* reporter, const char* filename) {
3619 SkPath path;
3620 path.moveTo(0, 0);
3621 path.lineTo(2, 2);
3622 path.lineTo(0, 3);
3623 path.lineTo(3, 3);
3624 path.close();
3625 path.moveTo(2, 0);
3626 path.lineTo(3, 0);
3627 path.lineTo(0, 1);
3628 path.lineTo(1, 2);
3629 path.close();
3630 markTestFlakyForPathKit();
3631 testSimplify(reporter, path, filename);
3632}
3633
3634static void testQuadratic94(skiatest::Reporter* reporter, const char* filename) {
3635 SkPath path;
3636 path.moveTo(0, 0);
3637 path.lineTo(8, 8);
3638 path.quadTo(8, 4, 4, 4);
3639 path.quadTo(4, 0, 0, 0);
3640 path.close();
3641 testSimplify(reporter, path, filename);
3642}
3643
3644static void testQuadratic95(skiatest::Reporter* reporter, const char* filename) {
3645 SkPath path;
3646 path.moveTo(8, 8);
3647 path.lineTo(0, 0);
3648 path.quadTo(4, 0, 4, 4);
3649 path.quadTo(8, 4, 8, 8);
3650 path.close();
3651 testSimplify(reporter, path, filename);
3652}
3653
3654static void testQuadratic96(skiatest::Reporter* reporter, const char* filename) {
3655 SkPath path;
3656 path.moveTo(8, 0);
3657 path.lineTo(0, 8);
3658 path.quadTo(0, 4, 4, 4);
3659 path.quadTo(4, 0, 8, 0);
3660 path.close();
3661 testSimplify(reporter, path, filename);
3662}
3663
3664static void testQuadratic97(skiatest::Reporter* reporter, const char* filename) {
3665 SkPath path;
3666 path.moveTo(0, 8);
3667 path.lineTo(8, 0);
3668 path.quadTo(4, 0, 4, 4);
3669 path.quadTo(0, 4, 0, 8);
3670 path.close();
3671 testSimplify(reporter, path, filename);
3672}
3673
3674static void testTriangles1(skiatest::Reporter* reporter, const char* filename) {
3675 SkPath path;
3676 path.moveTo(0, 0);
3677 path.lineTo(1, 0);
3678 path.lineTo(3, 3);
3679 path.close();
3680 path.moveTo(0, 0);
3681 path.lineTo(1, 2);
3682 path.lineTo(1, 1);
3683 path.close();
3684 testSimplify(reporter, path, filename);
3685}
3686
3687static void testTriangles2(skiatest::Reporter* reporter, const char* filename) {
3688 SkPath path;
3689 path.moveTo(0, 0);
3690 path.lineTo(1, 0);
3691 path.lineTo(3, 3);
3692 path.close();
3693 path.moveTo(1, 1);
3694 path.lineTo(2, 3);
3695 path.lineTo(1, 2);
3696 path.close();
3697 testSimplify(reporter, path, filename);
3698}
3699
3700// A test for this case:
3701// contourA has two segments that are coincident
3702// contourB has two segments that are coincident in the same place
3703// each ends up with +2/0 pairs for winding count
3704// since logic in OpSegment::addTCoincident doesn't transfer count (only increments/decrements)
3705// can this be resolved to +4/0 ?
3706static void testAddTCoincident1(skiatest::Reporter* reporter, const char* filename) {
3707 SkPath path;
3708 path.moveTo(2, 0);
3709 path.lineTo(2, 2);
3710 path.lineTo(1, 1);
3711 path.lineTo(2, 0);
3712 path.lineTo(2, 2);
3713 path.lineTo(1, 1);
3714 path.close();
3715 path.moveTo(2, 0);
3716 path.lineTo(2, 2);
3717 path.lineTo(3, 1);
3718 path.lineTo(2, 0);
3719 path.lineTo(2, 2);
3720 path.lineTo(3, 1);
3721 path.close();
3722 testSimplify(reporter, path, filename);
3723}
3724
3725// test with implicit close
3726static void testAddTCoincident2(skiatest::Reporter* reporter, const char* filename) {
3727 SkPath path;
3728 path.moveTo(2, 0);
3729 path.lineTo(2, 2);
3730 path.lineTo(1, 1);
3731 path.lineTo(2, 0);
3732 path.lineTo(2, 2);
3733 path.lineTo(1, 1);
3734 path.moveTo(2, 0);
3735 path.lineTo(2, 2);
3736 path.lineTo(3, 1);
3737 path.lineTo(2, 0);
3738 path.lineTo(2, 2);
3739 path.lineTo(3, 1);
3740 testSimplify(reporter, path, filename);
3741}
3742
3743static void testQuad2(skiatest::Reporter* reporter, const char* filename) {
3744 SkPath path;
3745 path.moveTo(1, 0);
3746 path.quadTo(0, 1, 3, 2);
3747 path.lineTo(2, 3);
3748 path.close();
3749 path.moveTo(0, 0);
3750 path.lineTo(1, 0);
3751 path.quadTo(0, 1, 1, 1);
3752 path.close();
3753}
3754
3755static void testQuad3(skiatest::Reporter* reporter, const char* filename) {
3756 SkPath path;
3757 path.moveTo(1, 0);
3758 path.quadTo(0, 1, 3, 2);
3759 path.lineTo(3, 3);
3760 path.close();
3761 path.moveTo(0, 0);
3762 path.lineTo(1, 0);
3763 path.quadTo(0, 1, 1, 1);
3764 path.close();
3765 testSimplify(reporter, path, filename);
3766}
3767
3768static void testQuad4(skiatest::Reporter* reporter, const char* filename) {
3769 SkPath path;
3770 path.moveTo(2, 0);
3771 path.quadTo(0, 1, 1, 1);
3772 path.lineTo(3, 3);
3773 path.close();
3774 path.moveTo(0, 0);
3775 path.lineTo(2, 0);
3776 path.quadTo(0, 1, 2, 2);
3777 path.close();
3778 testSimplify(reporter, path, filename);
3779}
3780
3781static void testQuad5(skiatest::Reporter* reporter, const char* filename) {
3782 SkPath path;
3783 path.moveTo(2, 0);
3784 path.quadTo(0, 1, 2, 2);
3785 path.lineTo(1, 3);
3786 path.close();
3787 path.moveTo(0, 0);
3788 path.lineTo(2, 0);
3789 path.quadTo(0, 1, 1, 1);
3790 path.close();
3791 testSimplify(reporter, path, filename);
3792}
3793
3794static void testQuad6(skiatest::Reporter* reporter, const char* filename) {
3795 SkPath path;
3796 path.moveTo(2, 0);
3797 path.quadTo(0, 1, 2, 2);
3798 path.lineTo(1, 3);
3799 path.close();
3800 path.moveTo(1, 0);
3801 path.lineTo(2, 0);
3802 path.quadTo(0, 1, 1, 1);
3803 path.close();
3804 testSimplify(reporter, path, filename);
3805}
3806
3807static void testQuad7(skiatest::Reporter* reporter, const char* filename) {
3808 SkPath path;
3809 path.moveTo(3, 0);
3810 path.quadTo(0, 1, 1, 1);
3811 path.lineTo(1, 3);
3812 path.close();
3813 path.moveTo(1, 0);
3814 path.lineTo(3, 0);
3815 path.quadTo(0, 1, 1, 2);
3816 path.close();
3817 testSimplify(reporter, path, filename);
3818}
3819
3820static void testQuadLineIntersect1(skiatest::Reporter* reporter, const char* filename) {
3821 SkPath path;
3822 path.moveTo(0, 0);
3823 path.quadTo(3, 1, 0, 3);
3824 path.lineTo(2, 3);
3825 path.close();
3826 path.moveTo(2, 0);
3827 path.lineTo(0, 1);
3828 path.quadTo(3, 1, 0, 2);
3829 path.close();
3830 testSimplify(reporter, path, filename);
3831}
3832
3833static void testQuadLineIntersect2(skiatest::Reporter* reporter, const char* filename) {
3834 SkPath path;
3835 path.moveTo(0, 0);
3836 path.quadTo(3, 1, 0, 3);
3837 path.lineTo(0, 3);
3838 path.close();
3839 path.moveTo(2, 0);
3840 path.lineTo(0, 1);
3841 path.quadTo(3, 1, 0, 2);
3842 path.close();
3843 testSimplify(reporter, path, filename);
3844}
3845
3846static void testQuadLineIntersect3(skiatest::Reporter* reporter, const char* filename) {
3847 SkPath path;
3848 path.moveTo(0, 0);
3849 path.quadTo(3, 1, 0, 3);
3850 path.lineTo(1, 3);
3851 path.close();
3852 path.moveTo(2, 0);
3853 path.lineTo(0, 1);
3854 path.quadTo(3, 1, 0, 2);
3855 path.close();
3856 testSimplify(reporter, path, filename);
3857}
3858
3859static void skphealth_com76s(skiatest::Reporter* reporter, const char* filename) {
3860 SkPath path;
3861 path.setFillType(SkPathFillType::kWinding);
3862 path.moveTo(708.099182f, 7.09919119f);
3863 path.lineTo(708.099182f, 7.09920025f);
3864 path.quadTo(704.000000f, 11.2010098f, 704.000000f, 17.0000000f);
3865 path.lineTo(704.000000f, 33.0000000f);
3866 path.lineTo(705.000000f, 33.0000000f);
3867 path.lineTo(705.000000f, 17.0000000f);
3868 path.cubicTo(705.000000f, 13.4101496f, 706.455078f, 10.1601505f, 708.807617f, 7.80761385f);
3869 path.lineTo(708.099182f, 7.09919119f);
3870 path.close();
3871 path.moveTo(704.000000f, 3.00000000f);
3872 path.lineTo(704.000000f, 33.0000000f);
3873 path.lineTo(705.000000f, 33.0000000f);
3874 path.lineTo(719.500000f, 3.00000000f);
3875 testSimplify(reporter, path, filename);
3876}
3877
3878static void tooCloseTest(skiatest::Reporter* reporter, const char* filename) {
3879 SkPath path;
3880 path.moveTo(0, 0);
3881 path.lineTo(1, 1);
3882 path.lineTo(1,-1);
3883 path.close();
3884 path.moveTo(0, 0);
3885 path.lineTo(1,-2);
3886 path.lineTo(1, 2);
3887 path.lineTo(2, 0);
3888 path.close();
3889 testSimplify(reporter, path, filename);
3890}
3891
3892static void testRect1s(skiatest::Reporter* reporter, const char* filename) {
3893 SkPath path;
3894 path.addRect(0, 0, 60, 60, SkPathDirection::kCCW);
3895 path.addRect(30, 20, 50, 50, SkPathDirection::kCCW);
3896 path.addRect(24, 20, 36, 30, SkPathDirection::kCCW);
3897 path.addRect(32, 24, 36, 41, SkPathDirection::kCCW);
3898 testSimplify(reporter, path, filename);
3899}
3900
3901static void testRect2s(skiatest::Reporter* reporter, const char* filename) {
3902 SkPath path;
3903 path.setFillType(SkPathFillType::kWinding);
3904 path.moveTo(0, 0);
3905 path.lineTo(60, 0);
3906 path.lineTo(60, 60);
3907 path.lineTo(0, 60);
3908 path.close();
3909 path.moveTo(30, 20);
3910 path.lineTo(30, 50);
3911 path.lineTo(50, 50);
3912 path.lineTo(50, 20);
3913 path.close();
3914 path.moveTo(24, 20);
3915 path.lineTo(24, 30);
3916 path.lineTo(36, 30);
3917 path.lineTo(36, 20);
3918 path.close();
3919 path.moveTo(32, 24);
3920 path.lineTo(32, 41);
3921 path.lineTo(36, 41);
3922 path.lineTo(36, 24);
3923 path.close();
3924 testSimplify(reporter, path, filename);
3925}
3926
3927static void testTriangles3x(skiatest::Reporter* reporter, const char* filename) {
3928 SkPath path;
3929 path.setFillType(SkPathFillType::kEvenOdd);
3930 path.moveTo(1, 0);
3931 path.quadTo(0, 1, 3, 2);
3932 path.lineTo(1, 3);
3933 path.close();
3934 path.moveTo(0, 0);
3935 path.lineTo(1, 1);
3936 path.quadTo(2, 1, 0, 2);
3937 path.close();
3938 testSimplify(reporter, path, filename);
3939}
3940
3941static void testQuad8(skiatest::Reporter* reporter, const char* filename) {
3942 SkPath path;
3943 path.moveTo(3, 0);
3944 path.quadTo(0, 1, 3, 2);
3945 path.lineTo(0, 3);
3946 path.close();
3947 path.moveTo(1, 0);
3948 path.lineTo(3, 0);
3949 path.quadTo(1, 1, 2, 2);
3950 path.close();
3951 testSimplify(reporter, path, filename);
3952}
3953
3954static void testTriangles4x(skiatest::Reporter* reporter, const char* filename) {
3955 SkPath path;
3956 path.setFillType(SkPathFillType::kEvenOdd);
3957 path.moveTo(0, 0);
3958 path.quadTo(2, 0, 0, 3);
3959 path.lineTo(2, 3);
3960 path.close();
3961 path.moveTo(0, 0);
3962 path.lineTo(0, 1);
3963 path.quadTo(3, 2, 2, 3);
3964 path.close();
3965 testSimplify(reporter, path, filename);
3966}
3967
3968static void testQuad9(skiatest::Reporter* reporter, const char* filename) {
3969 SkPath path;
3970 path.setFillType(SkPathFillType::kEvenOdd);
3971 path.moveTo(1, 0);
3972 path.quadTo(0, 1, 3, 2);
3973 path.lineTo(1, 3);
3974 path.close();
3975 path.moveTo(1, 0);
3976 path.lineTo(1, 1);
3977 path.quadTo(2, 1, 1, 3);
3978 path.close();
3979 testSimplify(reporter, path, filename);
3980}
3981
3982static void testQuad10(skiatest::Reporter* reporter, const char* filename) {
3983 SkPath path;
3984 path.moveTo(1, 0);
3985 path.quadTo(0, 1, 3, 2);
3986 path.lineTo(3, 3);
3987 path.close();
3988 path.moveTo(1, 0);
3989 path.lineTo(2, 0);
3990 path.quadTo(2, 3, 3, 3);
3991 path.close();
3992 testSimplify(reporter, path, filename);
3993}
3994
3995static void testQuad11(skiatest::Reporter* reporter, const char* filename) {
3996 SkPath path;
3997 path.moveTo(2, 0);
3998 path.quadTo(0, 1, 1, 2);
3999 path.lineTo(1, 2);
4000 path.close();
4001 path.moveTo(0, 0);
4002 path.lineTo(1, 1);
4003 path.quadTo(1, 3, 3, 3);
4004 path.close();
4005 testSimplify(reporter, path, filename);
4006}
4007
4008static void testQuad12(skiatest::Reporter* reporter, const char* filename) {
4009 SkPath path;
4010 path.moveTo(0, 0);
4011 path.quadTo(0, 0, 0, 0);
4012 path.lineTo(0, 1);
4013 path.close();
4014 path.moveTo(0, 0);
4015 path.lineTo(0, 0);
4016 path.quadTo(1, 0, 0, 1);
4017 path.close();
4018 testSimplify(reporter, path, filename);
4019}
4020
4021static void testQuadralateral3(skiatest::Reporter* reporter, const char* filename) {
4022 SkPath path;
4023 path.setFillType(SkPathFillType::kEvenOdd);
4024 path.moveTo(0, 0);
4025 path.lineTo(0, 0);
4026 path.lineTo(0, 0);
4027 path.lineTo(1, 0);
4028 path.close();
4029 path.moveTo(0, 0);
4030 path.lineTo(0, 0);
4031 path.lineTo(1, 0);
4032 path.lineTo(0, 1);
4033 path.close();
4034 testSimplify(reporter, path, filename);
4035}
4036
4037
4038static void testDegenerate5(skiatest::Reporter* reporter, const char* filename) {
4039 SkPath path;
4040 path.moveTo(0, 0);
4041 path.lineTo(0, 0);
4042 path.lineTo(1, 0);
4043 path.close();
4044 path.moveTo(0, 0);
4045 path.lineTo(1, 0);
4046 path.lineTo(0, 1);
4047 path.close();
4048 testSimplify(reporter, path, filename);
4049}
4050
4051static void testQuadralateral4(skiatest::Reporter* reporter, const char* filename) {
4052 SkPath path;
4053 path.moveTo(0, 0);
4054 path.lineTo(0, 0);
4055 path.lineTo(0, 0);
4056 path.lineTo(3, 1);
4057 path.close();
4058 path.moveTo(0, 0);
4059 path.lineTo(0, 0);
4060 path.lineTo(0, 1);
4061 path.lineTo(3, 1);
4062 path.close();
4063 testSimplify(reporter, path, filename);
4064}
4065
4066static void testDegenerates1(skiatest::Reporter* reporter, const char* filename) {
4067 SkPath path;
4068 path.moveTo(0, 0);
4069 path.quadTo(0, 0, 1, 1);
4070 path.lineTo(2, 3);
4071 path.close();
4072 path.moveTo(0, 0);
4073 path.lineTo(0, 0);
4074 path.quadTo(3, 2, 2, 3);
4075 path.close();
4076 testSimplify(reporter, path, filename);
4077}
4078
4079static void testQuad13(skiatest::Reporter* reporter, const char* filename) {
4080 SkPath path;
4081 path.moveTo(0, 0);
4082 path.quadTo(0, 0, 1, 1);
4083 path.lineTo(2, 3);
4084 path.close();
4085 path.moveTo(0, 0);
4086 path.lineTo(0, 0);
4087 path.quadTo(3, 2, 2, 3);
4088 path.close();
4089 testSimplify(reporter, path, filename);
4090}
4091
4092static void testQuad14(skiatest::Reporter* reporter, const char* filename) {
4093 SkPath path;
4094 path.setFillType(SkPathFillType::kWinding);
4095 path.moveTo(0, 0);
4096 path.quadTo(0, 0, 1, 1);
4097 path.lineTo(1, 2);
4098 path.close();
4099 path.moveTo(0, 0);
4100 path.lineTo(0, 0);
4101 path.quadTo(3, 1, 1, 3);
4102 path.close();
4103 testSimplify(reporter, path, filename);
4104}
4105
4106static void testQuad15(skiatest::Reporter* reporter, const char* filename) {
4107 SkPath path;
4108 path.moveTo(0, 0);
4109 path.quadTo(0, 0, 1, 1);
4110 path.lineTo(1, 3);
4111 path.close();
4112 path.moveTo(0, 0);
4113 path.lineTo(0, 0);
4114 path.quadTo(2, 0, 1, 3);
4115 path.close();
4116 testSimplify(reporter, path, filename);
4117}
4118
4119static void testQuads16(skiatest::Reporter* reporter, const char* filename) {
4120 SkPath path;
4121 path.moveTo(0, 0);
4122 path.quadTo(0, 0, 1, 1);
4123 path.lineTo(3, 2);
4124 path.close();
4125 path.moveTo(0, 0);
4126 path.lineTo(0, 0);
4127 path.quadTo(0, 1, 3, 2);
4128 path.close();
4129 testSimplify(reporter, path, filename);
4130}
4131
4132static void testQuads17(skiatest::Reporter* reporter, const char* filename) {
4133 SkPath path;
4134 path.moveTo(0, 0);
4135 path.quadTo(0, 0, 1, 1);
4136 path.lineTo(3, 2);
4137 path.close();
4138 path.moveTo(0, 0);
4139 path.lineTo(0, 0);
4140 path.quadTo(0, 2, 3, 2);
4141 path.close();
4142 testSimplify(reporter, path, filename);
4143}
4144
4145static void testQuads18(skiatest::Reporter* reporter, const char* filename) {
4146 SkPath path;
4147 path.moveTo(0, 0);
4148 path.quadTo(0, 0, 1, 1);
4149 path.lineTo(3, 2);
4150 path.close();
4151 path.moveTo(0, 0);
4152 path.lineTo(0, 0);
4153 path.quadTo(1, 2, 3, 2);
4154 path.close();
4155 testSimplify(reporter, path, filename);
4156}
4157
4158static void testQuads19(skiatest::Reporter* reporter, const char* filename) {
4159 SkPath path;
4160 path.moveTo(0, 0);
4161 path.quadTo(0, 0, 2, 1);
4162 path.lineTo(1, 2);
4163 path.close();
4164 path.moveTo(0, 0);
4165 path.lineTo(0, 0);
4166 path.quadTo(2, 1, 1, 2);
4167 path.close();
4168 testSimplify(reporter, path, filename);
4169}
4170
4171static void testQuads20(skiatest::Reporter* reporter, const char* filename) {
4172 SkPath path;
4173 path.moveTo(0, 0);
4174 path.quadTo(0, 0, 2, 1);
4175 path.lineTo(1, 3);
4176 path.close();
4177 path.moveTo(0, 0);
4178 path.lineTo(0, 0);
4179 path.quadTo(2, 1, 1, 3);
4180 path.close();
4181 testSimplify(reporter, path, filename);
4182}
4183
4184static void testQuads21(skiatest::Reporter* reporter, const char* filename) {
4185 SkPath path;
4186 path.moveTo(0, 0);
4187 path.quadTo(0, 0, 1, 1);
4188 path.lineTo(2, 1);
4189 path.close();
4190 path.moveTo(0, 0);
4191 path.lineTo(0, 0);
4192 path.quadTo(3, 0, 2, 3);
4193 path.close();
4194 testSimplify(reporter, path, filename);
4195}
4196
4197static void testQuads22(skiatest::Reporter* reporter, const char* filename) {
4198 SkPath path;
4199 path.moveTo(0, 0);
4200 path.quadTo(0, 0, 2, 0);
4201 path.lineTo(1, 1);
4202 path.close();
4203 path.moveTo(0, 0);
4204 path.lineTo(0, 0);
4205 path.quadTo(0, 1, 3, 2);
4206 path.close();
4207 testSimplify(reporter, path, filename);
4208}
4209
4210static void testQuads23(skiatest::Reporter* reporter, const char* filename) {
4211 SkPath path;
4212 path.moveTo(0, 0);
4213 path.quadTo(0, 0, 1, 0);
4214 path.lineTo(1, 1);
4215 path.close();
4216 path.moveTo(0, 0);
4217 path.lineTo(0, 0);
4218 path.quadTo(0, 1, 3, 2);
4219 path.close();
4220 testSimplify(reporter, path, filename);
4221}
4222
4223static void testQuads24(skiatest::Reporter* reporter, const char* filename) {
4224 SkPath path;
4225 path.moveTo(0, 0);
4226 path.quadTo(0, 0, 0, 1);
4227 path.lineTo(1, 2);
4228 path.close();
4229 path.moveTo(0, 1);
4230 path.lineTo(0, 1);
4231 path.quadTo(0, 2, 3, 3);
4232 path.close();
4233 testSimplify(reporter, path, filename);
4234}
4235
4236static void testQuads25(skiatest::Reporter* reporter, const char* filename) {
4237 SkPath path;
4238 path.moveTo(0, 0);
4239 path.quadTo(0, 0, 0, 1);
4240 path.lineTo(2, 1);
4241 path.close();
4242 path.moveTo(0, 0);
4243 path.lineTo(0, 0);
4244 path.quadTo(3, 0, 2, 3);
4245 path.close();
4246 testSimplify(reporter, path, filename);
4247}
4248
4249static void testQuads26(skiatest::Reporter* reporter, const char* filename) {
4250 SkPath path;
4251 path.moveTo(0, 0);
4252 path.quadTo(0, 0, 3, 0);
4253 path.lineTo(1, 1);
4254 path.close();
4255 path.moveTo(0, 0);
4256 path.lineTo(0, 0);
4257 path.quadTo(0, 1, 3, 2);
4258 path.close();
4259 testSimplify(reporter, path, filename);
4260}
4261
4262static void testQuads27(skiatest::Reporter* reporter, const char* filename) {
4263 SkPath path;
4264 path.moveTo(0, 0);
4265 path.quadTo(0, 0, 2, 0);
4266 path.lineTo(2, 1);
4267 path.close();
4268 path.moveTo(2, 0);
4269 path.lineTo(2, 0);
4270 path.quadTo(3, 0, 1, 3);
4271 path.close();
4272 testSimplify(reporter, path, filename);
4273}
4274
4275static void testQuads28(skiatest::Reporter* reporter, const char* filename) {
4276 SkPath path;
4277 path.moveTo(0, 0);
4278 path.quadTo(0, 0, 0, 1);
4279 path.lineTo(2, 2);
4280 path.close();
4281 path.moveTo(0, 0);
4282 path.lineTo(0, 0);
4283 path.quadTo(3, 0, 2, 3);
4284 path.close();
4285 testSimplify(reporter, path, filename);
4286}
4287
4288static void testQuads29(skiatest::Reporter* reporter, const char* filename) {
4289 SkPath path;
4290 path.moveTo(0, 0);
4291 path.quadTo(0, 0, 3, 0);
4292 path.lineTo(2, 1);
4293 path.close();
4294 path.moveTo(3, 0);
4295 path.lineTo(3, 0);
4296 path.quadTo(3, 1, 0, 2);
4297 path.close();
4298 testSimplify(reporter, path, filename);
4299}
4300
4301static void testQuads30(skiatest::Reporter* reporter, const char* filename) {
4302 SkPath path;
4303 path.moveTo(0, 0);
4304
4305 path.quadTo(0, 0, 2, 0);
4306 path.lineTo(2, 2);
4307 path.close();
4308 path.moveTo(2, 0);
4309 path.lineTo(2, 0);
4310 path.quadTo(3, 2, 1, 3);
4311 path.close();
4312 testSimplify(reporter, path, filename);
4313}
4314
4315static void testQuads31(skiatest::Reporter* reporter, const char* filename) {
4316 SkPath path;
4317 path.moveTo(0, 0);
4318 path.quadTo(0, 0, 2, 1);
4319 path.lineTo(1, 3);
4320 path.close();
4321 path.moveTo(3, 0);
4322 path.lineTo(0, 1);
4323
4324 path.quadTo(2, 1, 1, 3);
4325 path.close();
4326 testSimplify(reporter, path, filename);
4327}
4328
4329static void testQuads32(skiatest::Reporter* reporter, const char* filename) {
4330 SkPath path;
4331 path.moveTo(0, 0);
4332 path.quadTo(0, 0, 1, 1);
4333 path.lineTo(1, 2);
4334 path.close();
4335 path.moveTo(1, 1);
4336 path.lineTo(1, 1);
4337 path.quadTo(3, 1, 0, 3);
4338 path.close();
4339 testSimplify(reporter, path, filename);
4340}
4341
4342static void testQuads33(skiatest::Reporter* reporter, const char* filename) {
4343 SkPath path;
4344 path.moveTo(0, 0);
4345 path.quadTo(0, 0, 1, 1);
4346 path.lineTo(2, 1);
4347 path.close();
4348 path.moveTo(0, 0);
4349 path.lineTo(0, 0);
4350 path.quadTo(3, 0, 2, 3);
4351 path.close();
4352 testSimplify(reporter, path, filename);
4353}
4354
4355static void testQuads34(skiatest::Reporter* reporter, const char* filename) {
4356 SkPath path;
4357 path.moveTo(0, 0);
4358 path.quadTo(0, 0, 1, 0);
4359 path.lineTo(2, 1);
4360 path.close();
4361 path.moveTo(1, 0);
4362 path.lineTo(1, 0);
4363 path.quadTo(2, 0, 3, 3);
4364 path.close();
4365 testSimplify(reporter, path, filename);
4366}
4367
4368static void testQuads35(skiatest::Reporter* reporter, const char* filename) {
4369 SkPath path;
4370 path.moveTo(0, 0);
4371 path.quadTo(0, 0, 1, 0);
4372 path.lineTo(1, 2);
4373 path.close();
4374 path.moveTo(1, 0);
4375 path.lineTo(1, 0);
4376 path.quadTo(3, 1, 0, 3);
4377 path.close();
4378 testSimplify(reporter, path, filename);
4379}
4380
4381static void testQuads36(skiatest::Reporter* reporter, const char* filename) {
4382 SkPath path;
4383 path.moveTo(1, 0);
4384 path.quadTo(2, 0, 1, 2);
4385 path.lineTo(2, 2);
4386 path.close();
4387 path.moveTo(1, 0);
4388 path.lineTo(1, 0);
4389 path.quadTo(3, 0, 2, 3);
4390 path.close();
4391 testSimplify(reporter, path, filename);
4392}
4393
4394static void testQuads37(skiatest::Reporter* reporter, const char* filename) {
4395 SkPath path;
4396 path.setFillType(SkPathFillType::kEvenOdd);
4397 path.moveTo(1, 0);
4398 path.quadTo(2, 0, 1, 2);
4399 path.lineTo(2, 2);
4400 path.close();
4401 path.moveTo(1, 0);
4402 path.lineTo(1, 0);
4403 path.quadTo(3, 0, 2, 3);
4404 path.close();
4405 testSimplify(reporter, path, filename);
4406}
4407
4408static void testQuads38(skiatest::Reporter* reporter, const char* filename) {
4409 SkPath path;
4410 path.moveTo(1, 0);
4411 path.quadTo(3, 0, 0, 2);
4412 path.lineTo(3, 2);
4413 path.close();
4414 path.moveTo(1, 0);
4415 path.lineTo(1, 0);
4416 path.quadTo(2, 1, 3, 1);
4417 path.close();
4418 testSimplify(reporter, path, filename);
4419}
4420
4421static void testQuads39(skiatest::Reporter* reporter, const char* filename) {
4422 SkPath path;
4423 path.moveTo(1, 0);
4424 path.quadTo(3, 0, 0, 3);
4425 path.lineTo(0, 3);
4426 path.close();
4427 path.moveTo(1, 1);
4428 path.lineTo(0, 2);
4429 path.quadTo(1, 2, 0, 3);
4430 path.close();
4431 testSimplify(reporter, path, filename);
4432}
4433static void testQuads40(skiatest::Reporter* reporter, const char* filename) {
4434 SkPath path;
4435 path.moveTo(1, 0);
4436 path.quadTo(3, 0, 3, 3);
4437 path.lineTo(3, 3);
4438 path.close();
4439 path.moveTo(2, 1);
4440 path.lineTo(2, 2);
4441 path.quadTo(3, 2, 3, 3);
4442 path.close();
4443 testSimplify(reporter, path, filename);
4444}
4445
4446static void testQuads41(skiatest::Reporter* reporter, const char* filename) {
4447 SkPath path;
4448 path.moveTo(0, 0);
4449 path.quadTo(0, 0, 1, 0);
4450 path.lineTo(2, 1);
4451 path.close();
4452 path.moveTo(0, 0);
4453 path.lineTo(0, 0);
4454 path.quadTo(0, 1, 1, 2);
4455 path.close();
4456 testSimplify(reporter, path, filename);
4457}
4458
4459
4460static void testQuads54(skiatest::Reporter* reporter, const char* filename) {
4461 SkPath path;
4462 path.moveTo(1, 0);
4463 path.quadTo(2, 0, 1, 1);
4464 path.lineTo(3, 1);
4465 path.close();
4466 path.moveTo(2, 0);
4467 path.lineTo(1, 1);
4468 path.quadTo(1, 1, 2, 3);
4469 path.close();
4470 testSimplify(reporter, path, filename);
4471}
4472static void testQuads53(skiatest::Reporter* reporter, const char* filename) {
4473 SkPath path;
4474 path.moveTo(1, 0);
4475 path.quadTo(2, 0, 1, 1);
4476 path.lineTo(3, 1);
4477 path.close();
4478 path.moveTo(2, 0);
4479 path.lineTo(1, 1);
4480 path.quadTo(2, 3, 2, 3);
4481 path.close();
4482 testSimplify(reporter, path, filename);
4483}
4484static void testQuads52(skiatest::Reporter* reporter, const char* filename) {
4485 SkPath path;
4486 path.moveTo(1, 0);
4487 path.quadTo(2, 0, 1, 1);
4488 path.lineTo(3, 1);
4489 path.close();
4490 path.moveTo(2, 0);
4491 path.lineTo(1, 1);
4492 path.quadTo(2, 3, 3, 3);
4493 path.close();
4494 testSimplify(reporter, path, filename);
4495}
4496static void testQuads51(skiatest::Reporter* reporter, const char* filename) {
4497 SkPath path;
4498 path.moveTo(2, 0);
4499 path.quadTo(3, 0, 2, 1);
4500 path.lineTo(3, 2);
4501 path.close();
4502 path.moveTo(3, 0);
4503 path.lineTo(3, 1);
4504 path.quadTo(3, 1, 1, 2);
4505 path.close();
4506 testSimplify(reporter, path, filename);
4507}
4508static void testQuads50(skiatest::Reporter* reporter, const char* filename) {
4509 SkPath path;
4510 path.moveTo(2, 0);
4511 path.quadTo(3, 0, 2, 1);
4512 path.lineTo(3, 2);
4513 path.close();
4514 path.moveTo(3, 0);
4515 path.lineTo(3, 1);
4516 path.quadTo(1, 2, 1, 2);
4517 path.close();
4518 testSimplify(reporter, path, filename);
4519}
4520static void testQuads49(skiatest::Reporter* reporter, const char* filename) {
4521 SkPath path;
4522 path.moveTo(2, 0);
4523 path.quadTo(3, 0, 2, 1);
4524 path.lineTo(3, 2);
4525 path.close();
4526 path.moveTo(3, 0);
4527 path.lineTo(2, 2);
4528 path.quadTo(2, 2, 0, 3);
4529 path.close();
4530 testSimplify(reporter, path, filename);
4531}
4532static void testQuads48(skiatest::Reporter* reporter, const char* filename) {
4533 SkPath path;
4534 path.moveTo(2, 0);
4535 path.quadTo(3, 0, 2, 1);
4536 path.lineTo(3, 2);
4537 path.close();
4538 path.moveTo(3, 0);
4539 path.lineTo(2, 2);
4540 path.quadTo(3, 2, 0, 3);
4541 path.close();
4542 testSimplify(reporter, path, filename);
4543}
4544static void testQuads47(skiatest::Reporter* reporter, const char* filename) {
4545 SkPath path;
4546 path.moveTo(2, 0);
4547 path.quadTo(3, 0, 2, 1);
4548 path.lineTo(3, 2);
4549 path.close();
4550 path.moveTo(3, 0);
4551 path.lineTo(2, 2);
4552 path.quadTo(0, 3, 0, 3);
4553 path.close();
4554 testSimplify(reporter, path, filename);
4555}
4556
4557static void testQuads46x(skiatest::Reporter* reporter, const char* filename) {
4558 SkPath path;
4559 path.setFillType(SkPathFillType::kEvenOdd);
4560 path.moveTo(2, 0);
4561 path.quadTo(0, 1, 3, 2);
4562 path.lineTo(1, 3);
4563 path.close();
4564 path.moveTo(0, 0);
4565 path.lineTo(1, 1);
4566 path.quadTo(3, 2, 1, 3);
4567 path.close();
4568 testSimplify(reporter, path, filename);
4569}
4570
4571static void testQuads45(skiatest::Reporter* reporter, const char* filename) {
4572 SkPath path;
4573 path.moveTo(2, 0);
4574 path.quadTo(3, 2, 3, 3);
4575 path.lineTo(3, 3);
4576 path.close();
4577 path.moveTo(0, 0);
4578 path.lineTo(0, 2);
4579 path.quadTo(3, 2, 3, 3);
4580 path.close();
4581 testSimplify(reporter, path, filename);
4582}
4583
4584static void testQuads44(skiatest::Reporter* reporter, const char* filename) {
4585 SkPath path;
4586 path.moveTo(2, 0);
4587 path.quadTo(3, 2, 3, 3);
4588 path.lineTo(3, 3);
4589 path.close();
4590 path.moveTo(1, 0);
4591 path.lineTo(0, 2);
4592 path.quadTo(3, 2, 3, 3);
4593 path.close();
4594 testSimplify(reporter, path, filename);
4595}
4596
4597static void testQuads43(skiatest::Reporter* reporter, const char* filename) {
4598 SkPath path;
4599 path.moveTo(2, 0);
4600 path.quadTo(2, 3, 3, 3);
4601 path.lineTo(3, 3);
4602 path.close();
4603 path.moveTo(0, 2);
4604 path.lineTo(0, 2);
4605 path.quadTo(2, 3, 3, 3);
4606 path.close();
4607 testSimplify(reporter, path, filename);
4608}
4609
4610static void testQuads42(skiatest::Reporter* reporter, const char* filename) {
4611 SkPath path;
4612 path.moveTo(2, 0);
4613 path.quadTo(3, 2, 3, 3);
4614 path.lineTo(3, 3);
4615 path.close();
4616 path.moveTo(2, 0);
4617 path.lineTo(0, 2);
4618 path.quadTo(3, 2, 3, 3);
4619 path.close();
4620 testSimplify(reporter, path, filename);
4621}
4622
4623static void testQuads56(skiatest::Reporter* reporter, const char* filename) {
4624 SkPath path;
4625 path.moveTo(2, 0);
4626 path.quadTo(3, 1, 0, 2);
4627 path.lineTo(3, 2);
4628 path.close();
4629 path.moveTo(3, 0);
4630 path.lineTo(2, 1);
4631 path.quadTo(2, 1, 3, 3);
4632 path.close();
4633 testSimplify(reporter, path, filename);
4634}
4635
4636static void testQuads57(skiatest::Reporter* reporter, const char* filename) {
4637 SkPath path;
4638 path.moveTo(1, 0);
4639 path.quadTo(3, 0, 3, 1);
4640 path.lineTo(2, 2);
4641 path.close();
4642 path.moveTo(2, 0);
4643 path.lineTo(3, 1);
4644 path.quadTo(2, 2, 3, 2);
4645 path.close();
4646 testSimplify(reporter, path, filename);
4647}
4648
4649static void testQuads58(skiatest::Reporter* reporter, const char* filename) {
4650 SkPath path;
4651 path.moveTo(1, 0);
4652 path.quadTo(3, 0, 3, 1);
4653 path.lineTo(1, 3);
4654 path.close();
4655 path.moveTo(2, 0);
4656 path.lineTo(3, 1);
4657 path.quadTo(2, 2, 3, 2);
4658 path.close();
4659 testSimplify(reporter, path, filename);
4660}
4661
4662static void testQuads59(skiatest::Reporter* reporter, const char* filename) {
4663 SkPath path;
4664 path.moveTo(3, 0);
4665 path.quadTo(3, 1, 3, 1);
4666 path.lineTo(2, 2);
4667 path.close();
4668 path.moveTo(2, 0);
4669 path.lineTo(3, 1);
4670 path.quadTo(2, 2, 3, 2);
4671 path.close();
4672 testSimplify(reporter, path, filename);
4673}
4674
4675static void testQuads60(skiatest::Reporter* reporter, const char* filename) {
4676 SkPath path;
4677 path.moveTo(2, 1);
4678 path.quadTo(0, 2, 3, 2);
4679 path.lineTo(2, 3);
4680 path.close();
4681 path.moveTo(0, 0);
4682 path.lineTo(2, 0);
4683 path.quadTo(1, 1, 2, 2);
4684 path.close();
4685 testSimplify(reporter, path, filename);
4686}
4687
4688static void testQuads61(skiatest::Reporter* reporter, const char* filename) {
4689 SkPath path;
4690 path.setFillType(SkPathFillType::kEvenOdd);
4691 path.moveTo(0, 0);
4692 path.quadTo(0, 0, 2, 0);
4693 path.lineTo(1, 1);
4694 path.close();
4695 path.moveTo(0, 0);
4696 path.lineTo(0, 0);
4697 path.quadTo(1, 0, 2, 2);
4698 path.close();
4699 testSimplify(reporter, path, filename);
4700}
4701
4702static void testQuadralateral10(skiatest::Reporter* reporter, const char* filename) {
4703 SkPath path;
4704 path.setFillType(SkPathFillType::kWinding);
4705 path.moveTo(0, 0);
4706 path.lineTo(0, 0);
4707 path.lineTo(0, 0);
4708 path.lineTo(2, 2);
4709 path.close();
4710 path.moveTo(1, 0);
4711 path.lineTo(1, 1);
4712 path.lineTo(2, 2);
4713 path.lineTo(1, 3);
4714 path.close();
4715 testSimplify(reporter, path, filename);
4716}
4717
4718static void testRect3(skiatest::Reporter* reporter, const char* filename) {
4719 SkPath path;
4720 path.setFillType(SkPathFillType::kEvenOdd);
4721 path.addRect(0, 0, 60, 60, SkPathDirection::kCCW);
4722 path.addRect(10, 30, 40, 30, SkPathDirection::kCCW);
4723 path.addRect(24, 6, 36, 36, SkPathDirection::kCCW);
4724 path.addRect(32, 6, 36, 41, SkPathDirection::kCCW);
4725 testSimplify(reporter, path, filename);
4726}
4727
4728static void testRect4(skiatest::Reporter* reporter, const char* filename) {
4729 SkPath path;
4730 path.setFillType(SkPathFillType::kEvenOdd);
4731 path.addRect(0, 0, 30, 60, SkPathDirection::kCCW);
4732 path.addRect(10, 0, 40, 30, SkPathDirection::kCCW);
4733 path.addRect(20, 0, 30, 40, SkPathDirection::kCCW);
4734 path.addRect(32, 0, 36, 41, SkPathDirection::kCCW);
4735 testSimplify(reporter, path, filename);
4736}
4737
4738static void testQuads62(skiatest::Reporter* reporter, const char* filename) {
4739 SkPath path;
4740 path.moveTo(3, 2);
4741 path.quadTo(1, 3, 3, 3);
4742 path.lineTo(3, 3);
4743 path.close();
4744 path.moveTo(0, 0);
4745 path.lineTo(2, 0);
4746 path.quadTo(1, 3, 3, 3);
4747 path.close();
4748 testSimplify(reporter, path, filename);
4749}
4750
4751static void testQuads63(skiatest::Reporter* reporter,const char* filename) {
4752 SkPath path;
4753 path.moveTo(3, 0);
4754 path.quadTo(0, 1, 1, 2);
4755 path.lineTo(3, 3);
4756 path.close();
4757 path.moveTo(0, 0);
4758 path.lineTo(1, 1);
4759 path.quadTo(0, 2, 3, 3);
4760 path.close();
4761 testSimplify(reporter, path, filename);
4762}
4763
4764static void testQuads64(skiatest::Reporter* reporter,const char* filename) {
4765 SkPath path;
4766 path.moveTo(3, 0);
4767 path.quadTo(0, 1, 1, 2);
4768 path.lineTo(2, 2);
4769 path.close();
4770 path.moveTo(1, 0);
4771 path.lineTo(1, 1);
4772 path.quadTo(0, 2, 3, 3);
4773 path.close();
4774 testSimplify(reporter, path, filename);
4775}
4776
4777static void testTriangle1(skiatest::Reporter* reporter,const char* filename) {
4778 SkPath path;
4779 path.moveTo(0, 0);
4780 path.lineTo(1, 0);
4781 path.lineTo(2, 3);
4782 path.close();
4783 path.moveTo(0, 0);
4784 path.lineTo(1, 2);
4785 path.lineTo(1, 0);
4786 path.close();
4787 testSimplify(reporter, path, filename);
4788}
4789
4790static void testTriangle2(skiatest::Reporter* reporter,const char* filename) {
4791 SkPath path;
4792 path.moveTo(0, 0);
4793 path.lineTo(1, 0);
4794 path.lineTo(0, 1);
4795 path.close();
4796 path.moveTo(2, 0);
4797 path.lineTo(0, 2);
4798 path.lineTo(2, 2);
4799 path.close();
4800 testSimplify(reporter, path, filename);
4801}
4802
4803static void testArc(skiatest::Reporter* reporter,const char* filename) {
4804 SkRect r = SkRect::MakeWH(150, 100);
4805 SkPath path;
4806 path.arcTo(r, 0, 0.0025f, false);
4807 testSimplify(reporter, path, filename);
4808}
4809
4810static void testIssue3838(skiatest::Reporter* reporter,const char* filename) {
4811 SkPath path;
4812 path.moveTo(220, 170);
4813 path.lineTo(200, 170);
4814 path.lineTo(200, 190);
4815 path.lineTo(180, 190);
4816 path.lineTo(180, 210);
4817 path.lineTo(200, 210);
4818 path.lineTo(200, 250);
4819 path.lineTo(260, 250);
4820 path.lineTo(260, 190);
4821 path.lineTo(220, 190);
4822 path.lineTo(220, 170);
4823 path.close();
4824 path.moveTo(220, 210);
4825 path.lineTo(220, 230);
4826 path.lineTo(240, 230);
4827 path.lineTo(240, 210);
4828 path.lineTo(220, 210);
4829 path.close();
4830 testSimplify(reporter, path, filename);
4831}
4832
4833static void testIssue3838_3(skiatest::Reporter* reporter,const char* filename) {
4834 SkPath path;
4835 path.moveTo(40, 10);
4836 path.lineTo(60, 10);
4837 path.lineTo(60, 30);
4838 path.lineTo(40, 30);
4839 path.lineTo(40, 10);
4840 path.moveTo(41, 11);
4841 path.lineTo(41, 29);
4842 path.lineTo(59, 29);
4843 path.lineTo(59, 11);
4844 path.lineTo(41, 11);
4845 testSimplify(reporter, path, filename);
4846}
4847
4848static void testQuads65(skiatest::Reporter* reporter,const char* filename) {
4849 SkPath path;
4850 path.moveTo(1, 2);
4851 path.quadTo(3, 2, 0, 3);
4852 path.lineTo(1, 3);
4853 path.close();
4854 path.moveTo(1, 0);
4855 path.lineTo(1, 2);
4856 path.quadTo(3, 2, 1, 3);
4857 path.close();
4858 testSimplify(reporter, path, filename);
4859}
4860
4861static void fuzz864a(skiatest::Reporter* reporter,const char* filename) {
4862 SkPath path;
4863 path.moveTo(10, 90);
4864 path.lineTo(10, 90);
4865 path.lineTo(10, 30);
4866 path.lineTo(10, 30);
4867 path.lineTo(10, 90);
4868 path.close();
4869 path.moveTo(10, 90);
4870 path.lineTo(10, 90);
4871 path.lineTo(10, 30);
4872 path.lineTo(10, 30);
4873 path.lineTo(10, 90);
4874 path.close();
4875 path.moveTo(10, 90);
4876 path.lineTo(110, 90);
4877 path.lineTo(110, 30);
4878 path.lineTo(10, 30);
4879 path.lineTo(10, 90);
4880 path.close();
4881 path.moveTo(10, 30);
4882 path.lineTo(32678, 30);
4883 path.lineTo(32678, 30);
4884 path.lineTo(10, 30);
4885 path.close();
4886 path.moveTo(10, 3.35545e+07f);
4887 path.lineTo(110, 3.35545e+07f);
4888 path.lineTo(110, 30);
4889 path.lineTo(10, 30);
4890 path.lineTo(10, 3.35545e+07f);
4891 path.close();
4892 path.moveTo(10, 315);
4893 path.lineTo(110, 315);
4894 path.lineTo(110, 255);
4895 path.lineTo(10, 255);
4896 path.lineTo(10, 315);
4897 path.close();
4898 path.moveTo(0, 60);
4899 path.lineTo(100, 60);
4900 path.lineTo(100, 0);
4901 path.lineTo(0, 0);
4902 path.lineTo(0, 60);
4903 path.close();
4904 path.moveTo(10, 90);
4905 path.lineTo(110, 90);
4906 path.lineTo(110, 30);
4907 path.lineTo(10, 30);
4908 path.lineTo(10, 90);
4909 path.close();
4910 path.moveTo(10, 3.35545e+07f);
4911 path.lineTo(110, 3.35545e+07f);
4912 path.lineTo(110, 30);
4913 path.lineTo(10, 30);
4914 path.lineTo(10, 3.35545e+07f);
4915 path.close();
4916 path.moveTo(10, 90);
4917 path.lineTo(110, 90);
4918 path.lineTo(110, 30);
4919 path.lineTo(10, 30);
4920 path.lineTo(10, 90);
4921 path.close();
4922 testSimplify(reporter, path, filename);
4923}
4924
4925static void cr514118(skiatest::Reporter* reporter,const char* filename) {
4926 SkPath path;
4927path.moveTo(SkBits2Float(0x42c80000), SkBits2Float(0x42480000)); // 100, 50
4928path.conicTo(SkBits2Float(0x42c80000), SkBits2Float(0x00000000), SkBits2Float(0x42480000), SkBits2Float(0x00000000), SkBits2Float(0x3f3504f3)); // 100, 0, 50, 0, 0.707107f
4929path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x42480000), SkBits2Float(0x3f3504f3)); // 0, 0, 0, 50, 0.707107f
4930path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x42c80000), SkBits2Float(0x42480000), SkBits2Float(0x42c80000), SkBits2Float(0x3f3504f3)); // 0, 100, 50, 100, 0.707107f
4931path.conicTo(SkBits2Float(0x42c80000), SkBits2Float(0x42c80000), SkBits2Float(0x42c80000), SkBits2Float(0x42480000), SkBits2Float(0x3f3504f3)); // 100, 100, 100, 50, 0.707107f
4932path.close();
4933path.moveTo(SkBits2Float(0x42c80133), SkBits2Float(0x42480000)); // 100.002f, 50
4934path.conicTo(SkBits2Float(0x42c80133), SkBits2Float(0x00000000), SkBits2Float(0x42480267), SkBits2Float(0x00000000), SkBits2Float(0x3f3504f3)); // 100.002f, 0, 50.0023f, 0, 0.707107f
4935path.conicTo(SkBits2Float(0x3b19b530), SkBits2Float(0x00000000), SkBits2Float(0x3b19b530), SkBits2Float(0x42480000), SkBits2Float(0x3f3504f3)); // 0.00234539f, 0, 0.00234539f, 50, 0.707107f
4936path.conicTo(SkBits2Float(0x3b19b530), SkBits2Float(0x42c80000), SkBits2Float(0x42480267), SkBits2Float(0x42c80000), SkBits2Float(0x3f3504f3)); // 0.00234539f, 100, 50.0023f, 100, 0.707107f
4937path.conicTo(SkBits2Float(0x42c80133), SkBits2Float(0x42c80000), SkBits2Float(0x42c80133), SkBits2Float(0x42480000), SkBits2Float(0x3f3504f3)); // 100.002f, 100, 100.002f, 50, 0.707107f
4938path.close();
4939 testSimplify(reporter, path, filename);
4940}
4941
4942static void fuzz994s_11(skiatest::Reporter* reporter, const char* filename) {
4943 SkPath path;
4944 path.setFillType((SkPathFillType) 0);
4945path.moveTo(SkBits2Float(0x41200000), SkBits2Float(0x42b40000)); // 10, 90
4946path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x42b40000)); // 10, 90
4947path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x41f00000)); // 10, 30
4948path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x41f00000)); // 10, 30
4949path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x42b40000)); // 10, 90
4950path.close();
4951path.moveTo(SkBits2Float(0x41200000), SkBits2Float(0x42b40000)); // 10, 90
4952path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x42b40000)); // 10, 90
4953path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x41f00000)); // 10, 30
4954path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x41f00000)); // 10, 30
4955path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x42b40000)); // 10, 90
4956path.close();
4957path.moveTo(SkBits2Float(0x41200000), SkBits2Float(0x42b40000)); // 10, 90
4958path.lineTo(SkBits2Float(0x42dc0000), SkBits2Float(0x42b40000)); // 110, 90
4959path.lineTo(SkBits2Float(0x42dc0000), SkBits2Float(0x41f00000)); // 110, 30
4960path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x41f00000)); // 10, 30
4961path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x42b40000)); // 10, 90
4962path.close();
4963path.moveTo(SkBits2Float(0x41200000), SkBits2Float(0x41f00000)); // 10, 30
4964path.lineTo(SkBits2Float(0x46ff4c00), SkBits2Float(0x41f00000)); // 32678, 30
4965path.lineTo(SkBits2Float(0x46ff4c00), SkBits2Float(0x41f00000)); // 32678, 30
4966path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x41f00000)); // 10, 30
4967path.close();
4968path.moveTo(SkBits2Float(0x41200000), SkBits2Float(0x4c000006)); // 10, 3.35545e+07f
4969path.lineTo(SkBits2Float(0x42dc0000), SkBits2Float(0x4c000006)); // 110, 3.35545e+07f
4970path.lineTo(SkBits2Float(0x42dc0000), SkBits2Float(0x41f00000)); // 110, 30
4971path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x41f00000)); // 10, 30
4972path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x4c000006)); // 10, 3.35545e+07f
4973path.close();
4974path.moveTo(SkBits2Float(0x41200000), SkBits2Float(0x439d8000)); // 10, 315
4975path.lineTo(SkBits2Float(0x42dc0000), SkBits2Float(0x439d8000)); // 110, 315
4976path.lineTo(SkBits2Float(0x42dc0000), SkBits2Float(0x437f0000)); // 110, 255
4977path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x437f0000)); // 10, 255
4978path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x439d8000)); // 10, 315
4979path.close();
4980path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x42700000)); // 0, 60
4981path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x42700000)); // 100, 60
4982path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x00000000)); // 100, 0
4983path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
4984path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x42700000)); // 0, 60
4985path.close();
4986path.moveTo(SkBits2Float(0x41200000), SkBits2Float(0x42b40000)); // 10, 90
4987path.lineTo(SkBits2Float(0x42dc0000), SkBits2Float(0x42b40000)); // 110, 90
4988path.lineTo(SkBits2Float(0x42dc0000), SkBits2Float(0x41f00000)); // 110, 30
4989path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x41f00000)); // 10, 30
4990path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x42b40000)); // 10, 90
4991path.close();
4992path.moveTo(SkBits2Float(0x41200000), SkBits2Float(0x4c000006)); // 10, 3.35545e+07f
4993path.lineTo(SkBits2Float(0x42dc0000), SkBits2Float(0x4c000006)); // 110, 3.35545e+07f
4994path.lineTo(SkBits2Float(0x42dc0000), SkBits2Float(0x41f00000)); // 110, 30
4995path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x41f00000)); // 10, 30
4996path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x4c000006)); // 10, 3.35545e+07f
4997path.close();
4998path.moveTo(SkBits2Float(0x41200000), SkBits2Float(0x42b40000)); // 10, 90
4999path.lineTo(SkBits2Float(0x42dc0000), SkBits2Float(0x42b40000)); // 110, 90
5000path.lineTo(SkBits2Float(0x42dc0000), SkBits2Float(0x41f00000)); // 110, 30
5001path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x41f00000)); // 10, 30
5002path.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x42b40000)); // 10, 90
5003path.close();
5004
5005 testSimplify(reporter, path, filename);
5006}
5007
5008static void fuzz994s_3414(skiatest::Reporter* reporter, const char* filename) {
5009 SkPath path;
5010 path.setFillType((SkPathFillType) 0);
5011path.moveTo(SkBits2Float(0x42c80000), SkBits2Float(0x42480000)); // 100, 50
5012path.conicTo(SkBits2Float(0x42c80000), SkBits2Float(0x00000000), SkBits2Float(0x42480000), SkBits2Float(0x00000000), SkBits2Float(0x3f3504f3)); // 100, 0, 50, 0, 0.707107f
5013path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x42480000), SkBits2Float(0x3f3504f3)); // 0, 0, 0, 50, 0.707107f
5014path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x42c80000), SkBits2Float(0x42480000), SkBits2Float(0x42c80000), SkBits2Float(0x3f3504f3)); // 0, 100, 50, 100, 0.707107f
5015path.conicTo(SkBits2Float(0x42c80000), SkBits2Float(0x42c80000), SkBits2Float(0x42c80000), SkBits2Float(0x42480000), SkBits2Float(0x3f3504f3)); // 100, 100, 100, 50, 0.707107f
5016path.close();
5017path.moveTo(SkBits2Float(0x42c84964), SkBits2Float(0x42480000)); // 100.143f, 50
5018path.conicTo(SkBits2Float(0x42c84964), SkBits2Float(0x00000000), SkBits2Float(0x424892c8), SkBits2Float(0x00000000), SkBits2Float(0x3f3504f3)); // 100.143f, 0, 50.1433f, 0, 0.707107f
5019path.conicTo(SkBits2Float(0x3e12c788), SkBits2Float(0x00000000), SkBits2Float(0x3e12c788), SkBits2Float(0x42480000), SkBits2Float(0x3f3504f3)); // 0.143339f, 0, 0.143339f, 50, 0.707107f
5020path.conicTo(SkBits2Float(0x3e12c788), SkBits2Float(0x42c80000), SkBits2Float(0x424892c8), SkBits2Float(0x42c80000), SkBits2Float(0x3f3504f3)); // 0.143339f, 100, 50.1433f, 100, 0.707107f
5021path.conicTo(SkBits2Float(0x42c84964), SkBits2Float(0x42c80000), SkBits2Float(0x42c84964), SkBits2Float(0x42480000), SkBits2Float(0x3f3504f3)); // 100.143f, 100, 100.143f, 50, 0.707107f
5022path.close();
5023path.moveTo(SkBits2Float(0x42c80000), SkBits2Float(0x42480000)); // 100, 50
5024path.conicTo(SkBits2Float(0x42c80000), SkBits2Float(0x00000000), SkBits2Float(0x42480000), SkBits2Float(0x00000000), SkBits2Float(0x3f3504f3)); // 100, 0, 50, 0, 0.707107f
5025path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x42480000), SkBits2Float(0x3f3504f3)); // 0, 0, 0, 50, 0.707107f
5026path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x42c80000), SkBits2Float(0x42480000), SkBits2Float(0x42c80000), SkBits2Float(0x3f3504f3)); // 0, 100, 50, 100, 0.707107f
5027path.conicTo(SkBits2Float(0x42c80000), SkBits2Float(0x42c80000), SkBits2Float(0x42c80000), SkBits2Float(0x42480000), SkBits2Float(0x3f3504f3)); // 100, 100, 100, 50, 0.707107f
5028path.close();
5029path.moveTo(SkBits2Float(0x4c00006b), SkBits2Float(0x424c0000)); // 3.35549e+07f, 51
5030path.conicTo(SkBits2Float(0x4c00006b), SkBits2Float(0xcbffffe5), SkBits2Float(0x43d6e720), SkBits2Float(0xcbffffe5), SkBits2Float(0x3f3504f3)); // 3.35549e+07f, -3.35544e+07f, 429.806f, -3.35544e+07f, 0.707107f
5031path.conicTo(SkBits2Float(0xcbffff28), SkBits2Float(0xcbffffe5), SkBits2Float(0xcbffff28), SkBits2Float(0x424c0000), SkBits2Float(0x3f3504f3)); // -3.3554e+07f, -3.35544e+07f, -3.3554e+07f, 51, 0.707107f
5032path.conicTo(SkBits2Float(0xcbffff28), SkBits2Float(0x4c00000c), SkBits2Float(0x43d6e720), SkBits2Float(0x4c00000c), SkBits2Float(0x3f3504f3)); // -3.3554e+07f, 3.35545e+07f, 429.806f, 3.35545e+07f, 0.707107f
5033path.conicTo(SkBits2Float(0x4c00006b), SkBits2Float(0x4c00000c), SkBits2Float(0x4c00006b), SkBits2Float(0x424c0000), SkBits2Float(0x3f3504f3)); // 3.35549e+07f, 3.35545e+07f, 3.35549e+07f, 51, 0.707107f
5034path.close();
5035path.moveTo(SkBits2Float(0x43ef6720), SkBits2Float(0x42480000)); // 478.806f, 50
5036path.conicTo(SkBits2Float(0x43ef6720), SkBits2Float(0x00000000), SkBits2Float(0x43d66720), SkBits2Float(0x00000000), SkBits2Float(0x3f3504f3)); // 478.806f, 0, 428.806f, 0, 0.707107f
5037path.conicTo(SkBits2Float(0x43bd6720), SkBits2Float(0x00000000), SkBits2Float(0x43bd6720), SkBits2Float(0x42480000), SkBits2Float(0x3f3504f3)); // 378.806f, 0, 378.806f, 50, 0.707107f
5038path.conicTo(SkBits2Float(0x43bd6720), SkBits2Float(0x42c80000), SkBits2Float(0x43d66720), SkBits2Float(0x42c80000), SkBits2Float(0x3f3504f3)); // 378.806f, 100, 428.806f, 100, 0.707107f
5039path.conicTo(SkBits2Float(0x43ef6720), SkBits2Float(0x42c80000), SkBits2Float(0x43ef6720), SkBits2Float(0x42480000), SkBits2Float(0x3f3504f3)); // 478.806f, 100, 478.806f, 50, 0.707107f
5040path.close();
5041
5042 testSimplify(reporter, path, filename);
5043}
5044
5045static void fuzz_twister(skiatest::Reporter* reporter, const char* filename) {
5046 SkPath path;
5047 path.setFillType((SkPathFillType) 0);
5048path.moveTo(0, 600);
5049path.lineTo(3.35544e+07f, 600);
5050path.lineTo(3.35544e+07f, 0);
5051path.lineTo(0, 0);
5052path.lineTo(0, 600);
5053path.close();
5054path.moveTo(63, 600);
5055path.lineTo(3.35545e+07f, 600);
5056path.lineTo(3.35545e+07f, 0);
5057path.lineTo(63, 0);
5058path.lineTo(63, 600);
5059path.close();
5060path.moveTo(93, 600);
5061path.lineTo(3.35545e+07f, 600);
5062path.lineTo(3.35545e+07f, 0);
5063path.lineTo(93, 0);
5064path.lineTo(93, 600);
5065path.close();
5066path.moveTo(123, 600);
5067path.lineTo(3.35546e+07f, 600);
5068path.lineTo(3.35546e+07f, 0);
5069path.lineTo(123, 0);
5070path.lineTo(123, 600);
5071path.close();
5072 testSimplify(reporter, path, filename);
5073}
5074
5075static void fuzz_twister2(skiatest::Reporter* reporter, const char* filename) {
5076 SkPath path;
5077
5078path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x44160000)); // 0, 600
5079path.lineTo(SkBits2Float(0x4bfffffe), SkBits2Float(0x44160000)); // 3.35544e+07f, 600
5080path.lineTo(SkBits2Float(0x4bfffffe), SkBits2Float(0x00000000)); // 3.35544e+07f, 0
5081path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
5082path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x44160000)); // 0, 600
5083path.close();
5084
5085path.moveTo(SkBits2Float(0x427c0000), SkBits2Float(0x00000000)); // 63, 0
5086path.lineTo(SkBits2Float(0x4c00000f), SkBits2Float(0x00000000)); // 3.35545e+07f, 0
5087path.lineTo(SkBits2Float(0x4c00000f), SkBits2Float(0x00000000)); // 3.35545e+07f, 0
5088path.lineTo(SkBits2Float(0x427c0000), SkBits2Float(0x00000000)); // 63, 0
5089path.close();
5090
5091path.moveTo(SkBits2Float(0x42ba0000), SkBits2Float(0x00000000)); // 93, 0
5092path.lineTo(SkBits2Float(0x4c000016), SkBits2Float(0x00000000)); // 3.35545e+07f, 0
5093path.lineTo(SkBits2Float(0x4c000016), SkBits2Float(0x00000000)); // 3.35545e+07f, 0
5094path.lineTo(SkBits2Float(0x42ba0000), SkBits2Float(0x00000000)); // 93, 0
5095path.close();
5096
5097path.moveTo(SkBits2Float(0x42f60000), SkBits2Float(0x00000000)); // 123, 0
5098path.lineTo(SkBits2Float(0x4c00001e), SkBits2Float(0x00000000)); // 3.35546e+07f, 0
5099path.lineTo(SkBits2Float(0x4c00001e), SkBits2Float(0x00000000)); // 3.35546e+07f, 0
5100path.lineTo(SkBits2Float(0x42f60000), SkBits2Float(0x00000000)); // 123, 0
5101path.close();
5102
5103 testSimplify(reporter, path, filename);
5104}
5105
5106static void fuzz763_4713_b(skiatest::Reporter* reporter, const char* filename) {
5107 SkPath path;
5108 path.setFillType((SkPathFillType) 0);
5109path.moveTo(SkBits2Float(0x42240000), SkBits2Float(0x42040000));
5110path.quadTo(SkBits2Float(0x42240000), SkBits2Float(0x4211413d), SkBits2Float(0x421aa09e), SkBits2Float(0x421aa09e));
5111path.quadTo(SkBits2Float(0x4211413d), SkBits2Float(0x42240000), SkBits2Float(0x42040000), SkBits2Float(0x42240000));
5112path.quadTo(SkBits2Float(0x41ed7d86), SkBits2Float(0x42240000), SkBits2Float(0x41dabec3), SkBits2Float(0x421aa09e));
5113path.quadTo(SkBits2Float(0x41c80000), SkBits2Float(0x4211413d), SkBits2Float(0x41c80000), SkBits2Float(0x42040000));
5114path.quadTo(SkBits2Float(0x41c80000), SkBits2Float(0x41ed7d86), SkBits2Float(0x41dabec3), SkBits2Float(0x41dabec3));
5115path.quadTo(SkBits2Float(0x41ed7d86), SkBits2Float(0x41c80000), SkBits2Float(0x42040000), SkBits2Float(0x41c80000));
5116path.quadTo(SkBits2Float(0x4211413d), SkBits2Float(0x41c80000), SkBits2Float(0x421aa09e), SkBits2Float(0x41dabec3));
5117path.quadTo(SkBits2Float(0x42240000), SkBits2Float(0x41ed7d86), SkBits2Float(0x42240000), SkBits2Float(0x42040000));
5118path.close();
5119
5120path.moveTo(SkBits2Float(0x4204f72e), SkBits2Float(0x41c56cd2));
5121path.quadTo(SkBits2Float(0x42123842), SkBits2Float(0x41c52adf), SkBits2Float(0x421baed7), SkBits2Float(0x41d7bac6));
5122path.quadTo(SkBits2Float(0x4225256d), SkBits2Float(0x41ea4aad), SkBits2Float(0x42254667), SkBits2Float(0x4202666b));
5123path.quadTo(SkBits2Float(0x42256760), SkBits2Float(0x420fa77f), SkBits2Float(0x421c1f6c), SkBits2Float(0x42191e14));
5124path.quadTo(SkBits2Float(0x421bff97), SkBits2Float(0x42193e89), SkBits2Float(0x421bdf6b), SkBits2Float(0x42195eb8));
5125path.quadTo(SkBits2Float(0x421bbff6), SkBits2Float(0x42197f32), SkBits2Float(0x421ba03b), SkBits2Float(0x42199f57));
5126path.quadTo(SkBits2Float(0x421b605e), SkBits2Float(0x4219e00a), SkBits2Float(0x421b1fa8), SkBits2Float(0x421a1f22));
5127path.quadTo(SkBits2Float(0x421ae0f1), SkBits2Float(0x421a604b), SkBits2Float(0x421aa09e), SkBits2Float(0x421aa09e));
5128path.quadTo(SkBits2Float(0x4211413d), SkBits2Float(0x42240000), SkBits2Float(0x42040000), SkBits2Float(0x42240000));
5129path.quadTo(SkBits2Float(0x41ed7d86), SkBits2Float(0x42240000), SkBits2Float(0x41dabec3), SkBits2Float(0x421aa09e));
5130path.quadTo(SkBits2Float(0x41c80000), SkBits2Float(0x4211413d), SkBits2Float(0x41c80000), SkBits2Float(0x42040000));
5131path.quadTo(SkBits2Float(0x41c80000), SkBits2Float(0x41ed7d86), SkBits2Float(0x41dabec3), SkBits2Float(0x41dabec3));
5132path.quadTo(SkBits2Float(0x41db19b1), SkBits2Float(0x41da63d5), SkBits2Float(0x41db755b), SkBits2Float(0x41da0a9b));
5133path.quadTo(SkBits2Float(0x41dbce01), SkBits2Float(0x41d9ae59), SkBits2Float(0x41dc285e), SkBits2Float(0x41d952ce));
5134path.quadTo(SkBits2Float(0x41dc55b6), SkBits2Float(0x41d924df), SkBits2Float(0x41dc82cd), SkBits2Float(0x41d8f7cd));
5135path.quadTo(SkBits2Float(0x41dcaf1e), SkBits2Float(0x41d8ca01), SkBits2Float(0x41dcdc4c), SkBits2Float(0x41d89bf0));
5136path.quadTo(SkBits2Float(0x41ef6c33), SkBits2Float(0x41c5aec5), SkBits2Float(0x4204f72e), SkBits2Float(0x41c56cd2));
5137path.close();
5138testSimplify(reporter, path, filename);
5139}
5140
5141static void dean4(skiatest::Reporter* reporter, const char* filename) {
5142 SkPath path;
5143
5144 // start region
5145 // start loop, contour: 1
5146 // Segment 1145.3381097316742 2017.6783947944641 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1145.3381097316742 2017.0033947825432
5147 path.moveTo(1145.3381347656250, 2017.6783447265625);
5148 path.lineTo(1145.3381347656250, 2017.0034179687500);
5149 // Segment 1145.3381097316742 2017.0033947825432 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1143.6927231521568 2017.0033947825432
5150 path.lineTo(1143.6927490234375, 2017.0034179687500);
5151 // Segment 1143.6927231521568 2017.0033947825432 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1144.8640675112890 2018.1589246992417
5152 path.lineTo(1144.8640136718750, 2018.1589355468750);
5153 // Segment 1144.8640675112890 2018.1589246992417 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1145.3381097316742 2017.6783947944641
5154 path.lineTo(1145.3381347656250, 2017.6783447265625);
5155 path.close();
5156 // start loop, contour: 2
5157 // Segment 1145.3381097316742 2016.3216052055359 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1144.8640675258462 2015.8410752863977
5158 path.moveTo(1145.3381347656250, 2016.3216552734375);
5159 path.lineTo(1144.8640136718750, 2015.8410644531250);
5160 // Segment 1144.8640675258462 2015.8410752863977 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1143.6927230811802 2016.9966052174568
5161 path.lineTo(1143.6927490234375, 2016.9965820312500);
5162 // Segment 1143.6927230811802 2016.9966052174568 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1145.3381097316742 2016.9966052174568
5163 path.lineTo(1145.3381347656250, 2016.9965820312500);
5164 // Segment 1145.3381097316742 2016.9966052174568 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1145.3381097316742 2016.3216052055359
5165 path.lineTo(1145.3381347656250, 2016.3216552734375);
5166 path.close();
5167 // start loop, contour: 3
5168 // Segment 1147.3323798179626 2014.3542600870132 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1147.8064220239557 2014.8347900059885
5169 path.moveTo(1147.3323974609375, 2014.3542480468750);
5170 path.lineTo(1147.8063964843750, 2014.8348388671875);
5171 // Segment 1147.8064220239557 2014.8347900059885 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1147.8064220516883 2014.8347899786306
5172 path.lineTo(1147.8063964843750, 2014.8348388671875);
5173 // Segment 1147.8064220516883 2014.8347899786306 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1147.3323798179626 2014.3542600870132
5174 path.lineTo(1147.3323974609375, 2014.3542480468750);
5175 path.close();
5176 // start loop, contour: 4
5177 // Segment 1146.3696286678314 2013.4045072346926 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.8436708778083 2013.8850371497379
5178 path.moveTo(1146.3696289062500, 2013.4045410156250);
5179 path.lineTo(1146.8436279296875, 2013.8850097656250);
5180 // Segment 1146.8436708778083 2013.8850371497379 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.8436709015571 2013.8850371263100
5181 path.lineTo(1146.8436279296875, 2013.8850097656250);
5182 // Segment 1146.8436709015571 2013.8850371263100 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.3696286678314 2013.4045072346926
5183 path.lineTo(1146.3696289062500, 2013.4045410156250);
5184 path.close();
5185 // start loop, contour: 5
5186 // Segment 1143.2063037902117 2016.5251235961914 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1142.7322615802348 2016.0445936811461
5187 path.moveTo(1143.2062988281250, 2016.5251464843750);
5188 path.lineTo(1142.7322998046875, 2016.0445556640625);
5189 // Segment 1142.7322615802348 2016.0445936811461 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1142.7322615564860 2016.0445937045740
5190 path.lineTo(1142.7322998046875, 2016.0445556640625);
5191 // Segment 1142.7322615564860 2016.0445937045740 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1143.2063037902117 2016.5251235961914
5192 path.lineTo(1143.2062988281250, 2016.5251464843750);
5193 path.close();
5194 // start loop, contour: 6
5195 // Segment 1143.0687679275870 2016.7286419868469 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1143.5428101613127 2017.2091718784643
5196 path.moveTo(1143.0687255859375, 2016.7286376953125);
5197 path.lineTo(1143.5428466796875, 2017.2092285156250);
5198 // Segment 1143.5428101613127 2017.2091718784643 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1143.7437679395080 2017.0109272411960
5199 path.lineTo(1143.7437744140625, 2017.0109863281250);
5200 // Segment 1143.7437679395080 2017.0109272411960 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1143.7437679395080 2016.7286419868469
5201 path.lineTo(1143.7437744140625, 2016.7286376953125);
5202 // Segment 1143.7437679395080 2016.7286419868469 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1143.0687679275870 2016.7286419868469
5203 path.lineTo(1143.0687255859375, 2016.7286376953125);
5204 path.close();
5205 // start loop, contour: 7
5206 // Segment 1143.2063037902117 2017.4748764038086 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1142.7322615603032 2017.9554062991915
5207 path.moveTo(1143.2062988281250, 2017.4748535156250);
5208 path.lineTo(1142.7322998046875, 2017.9554443359375);
5209 // Segment 1142.7322615603032 2017.9554062991915 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1142.7322615746241 2017.9554063133189
5210 path.lineTo(1142.7322998046875, 2017.9554443359375);
5211 // Segment 1142.7322615746241 2017.9554063133189 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1143.2063037902117 2017.4748764038086
5212 path.lineTo(1143.2062988281250, 2017.4748535156250);
5213 path.close();
5214 // start loop, contour: 8
5215 // Segment 1146.3696286678314 2020.5954928398132 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.8436708977399 2020.1149629444303
5216 path.moveTo(1146.3696289062500, 2020.5954589843750);
5217 path.lineTo(1146.8436279296875, 2020.1149902343750);
5218 // Segment 1146.8436708977399 2020.1149629444303 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.8436708834190 2020.1149629303029
5219 path.lineTo(1146.8436279296875, 2020.1149902343750);
5220 // Segment 1146.8436708834190 2020.1149629303029 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.3696286678314 2020.5954928398132
5221 path.lineTo(1146.3696289062500, 2020.5954589843750);
5222 path.close();
5223 // start loop, contour: 9
5224 // Segment 1147.3323798179626 2019.6457400321960 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1147.8064220484741 2019.1652101374082
5225 path.moveTo(1147.3323974609375, 2019.6457519531250);
5226 path.lineTo(1147.8063964843750, 2019.1651611328125);
5227 // Segment 1147.8064220484741 2019.1652101374082 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1147.8064220383478 2019.1652101274185
5228 path.lineTo(1147.8063964843750, 2019.1651611328125);
5229 // Segment 1147.8064220383478 2019.1652101274185 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1147.3323798179626 2019.6457400321960
5230 path.lineTo(1147.3323974609375, 2019.6457519531250);
5231 path.close();
5232 // start loop, contour: 10
5233 // Segment 1145.3381097316742 2018.3533948063850 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1156.6848182678223 2018.3533948063850
5234 path.moveTo(1145.3381347656250, 2018.3533935546875);
5235 path.lineTo(1156.6848144531250, 2018.3533935546875);
5236 // Segment 1156.6848182678223 2018.3533948063850 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1156.6848182678223 2017.0033947825432
5237 path.lineTo(1156.6848144531250, 2017.0034179687500);
5238 // Segment 1156.6848182678223 2017.0033947825432 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1145.3381097316742 2017.0033947825432
5239 path.lineTo(1145.3381347656250, 2017.0034179687500);
5240 // Segment 1145.3381097316742 2017.0033947825432 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1145.3381097316742 2018.3533948063850
5241 path.lineTo(1145.3381347656250, 2018.3533935546875);
5242 path.close();
5243 // start loop, contour: 11
5244 // Segment 1156.6848182678223 2018.3533948063850 0.3569631313191 0.0000000000000 -0.2645167304388 0.2609454237780 1157.6574279406423 2017.9723661860094
5245 path.moveTo(1156.6848144531250, 2018.3533935546875);
5246 path.cubicTo(1157.0417480468750, 2018.3533935546875, 1157.3929443359375, 2018.2332763671875, 1157.6574707031250, 2017.9724121093750);
5247 // Segment 1157.6574279406423 2017.9723661860094 0.2653344079822 -0.2617520616521 0.0000000000000 0.3596905289350 1158.0474975705147 2017.0000000000000
5248 path.cubicTo(1157.9227294921875, 2017.7105712890625, 1158.0474853515625, 2017.3597412109375, 1158.0474853515625, 2017.0000000000000);
5249 // Segment 1158.0474975705147 2017.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1156.6974975466728 2017.0000000000000
5250 path.lineTo(1156.6975097656250, 2017.0000000000000);
5251 // Segment 1156.6974975466728 2017.0000000000000 0.0028009248351 0.0403311981485 0.0118595244351 -0.0220843520393 1156.6941780622435 2017.0325257649940
5252 path.cubicTo(1156.7003173828125, 2017.0402832031250, 1156.7060546875000, 2017.0104980468750, 1156.6942138671875, 2017.0324707031250);
5253 // Segment 1156.6941780622435 2017.0325257649940 -0.0032637855860 0.0184860248562 0.0120617528380 -0.0065934603083 1156.7093435710913 2017.0113063061967
5254 path.cubicTo(1156.6909179687500, 2017.0510253906250, 1156.7214355468750, 2017.0047607421875, 1156.7093505859375, 2017.0113525390625);
5255 // split at 0.4496445953846
5256 // path.cubicTo(1156.6927490234375, 2017.0407714843750, 1156.6981201171875, 2017.0360107421875, 1156.7033691406250, 2017.0289306640625);
5257 // path.cubicTo(1156.7097167968750, 2017.0201416015625, 1156.7159423828125, 2017.0076904296875, 1156.7093505859375, 2017.0113525390625);
5258 // Segment 1156.7093435710913 2017.0113063061967 -0.0070717276929 0.0122220954353 0.0203483811973 -0.0039136894418 1156.7268834554304 2016.9985353221975
5259 path.cubicTo(1156.7022705078125, 2017.0235595703125, 1156.7471923828125, 2016.9946289062500, 1156.7269287109375, 2016.9985351562500);
5260 // Segment 1156.7268834554304 2016.9985353221975 -0.0244396787691 0.0123649140586 0.0433322464027 0.0026558844666 1156.6848182678223 2017.0033947825432
5261 path.cubicTo(1156.7023925781250, 2017.0108642578125, 1156.7281494140625, 2017.0061035156250, 1156.6848144531250, 2017.0034179687500);
5262 // split at 0.4418420493603
5263 // path.cubicTo(1156.7160644531250, 2017.0040283203125, 1156.7150878906250, 2017.0061035156250, 1156.7136230468750, 2017.0065917968750);
5264 // path.cubicTo(1156.7116699218750, 2017.0070800781250, 1156.7089843750000, 2017.0048828125000, 1156.6848144531250, 2017.0034179687500);
5265 // Segment 1156.6848182678223 2017.0033947825432 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1156.6848182678223 2018.3533948063850
5266 path.lineTo(1156.6848144531250, 2018.3533935546875);
5267 path.close();
5268 // start loop, contour: 12
5269 // Segment 1158.0474975705147 2017.0000000000000 0.0000000000000 -0.3596905289350 0.2653344079822 0.2617520616521 1157.6574279406423 2016.0276338139906
5270 path.moveTo(1158.0474853515625, 2017.0000000000000);
5271 path.cubicTo(1158.0474853515625, 2016.6402587890625, 1157.9227294921875, 2016.2894287109375, 1157.6574707031250, 2016.0275878906250);
5272 // Segment 1157.6574279406423 2016.0276338139906 -0.2645167304388 -0.2609454237780 0.3569631313191 0.0000000000000 1156.6848182678223 2015.6466051936150
5273 path.cubicTo(1157.3929443359375, 2015.7667236328125, 1157.0417480468750, 2015.6466064453125, 1156.6848144531250, 2015.6466064453125);
5274 // split at 0.5481675863266
5275 // path.cubicTo(1157.5124511718750, 2015.8846435546875, 1157.3414306640625, 2015.7839355468750, 1157.1577148437500, 2015.7220458984375);
5276 // path.cubicTo(1157.0062255859375, 2015.6711425781250, 1156.8460693359375, 2015.6466064453125, 1156.6848144531250, 2015.6466064453125);
5277 // Segment 1156.6848182678223 2015.6466051936150 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1156.6848182678223 2016.9966052174568
5278 path.lineTo(1156.6848144531250, 2016.9965820312500);
5279 // Segment 1156.6848182678223 2016.9966052174568 0.0433322464027 -0.0026558844666 -0.0244396787691 -0.0123649140586 1156.7268834554304 2017.0014646778025
5280 path.cubicTo(1156.7281494140625, 2016.9938964843750, 1156.7023925781250, 2016.9891357421875, 1156.7269287109375, 2017.0014648437500);
5281 // split at 0.5581579208374
5282 // path.cubicTo(1156.7089843750000, 2016.9951171875000, 1156.7116699218750, 2016.9929199218750, 1156.7136230468750, 2016.9934082031250);
5283 // path.cubicTo(1156.7150878906250, 2016.9938964843750, 1156.7160644531250, 2016.9959716796875, 1156.7269287109375, 2017.0014648437500);
5284 // Segment 1156.7268834554304 2017.0014646778025 0.0203483811973 0.0039136894418 -0.0070717276929 -0.0122220954353 1156.7093435710913 2016.9886936938033
5285 path.cubicTo(1156.7471923828125, 2017.0053710937500, 1156.7022705078125, 2016.9764404296875, 1156.7093505859375, 2016.9886474609375);
5286 // Segment 1156.7093435710913 2016.9886936938033 0.0120617528380 0.0065934603083 -0.0032637855860 -0.0184860248562 1156.6941780622435 2016.9674742350060
5287 path.cubicTo(1156.7214355468750, 2016.9952392578125, 1156.6909179687500, 2016.9489746093750, 1156.6942138671875, 2016.9675292968750);
5288 // Segment 1156.6941780622435 2016.9674742350060 0.0118595244351 0.0220843520393 0.0028009248351 -0.0403311981485 1156.6974975466728 2017.0000000000000
5289 path.cubicTo(1156.7060546875000, 2016.9895019531250, 1156.7003173828125, 2016.9597167968750, 1156.6975097656250, 2017.0000000000000);
5290 // split at 0.4572408795357
5291 // path.cubicTo(1156.6995849609375, 2016.9775390625000, 1156.7014160156250, 2016.9768066406250, 1156.7014160156250, 2016.9768066406250);
5292 // path.cubicTo(1156.7014160156250, 2016.9769287109375, 1156.6989746093750, 2016.9781494140625, 1156.6975097656250, 2017.0000000000000);
5293 // Segment 1156.6974975466728 2017.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1158.0474975705147 2017.0000000000000
5294 path.lineTo(1158.0474853515625, 2017.0000000000000);
5295 path.close();
5296 // start loop, contour: 13
5297 // Segment 1156.6848182678223 2015.6466051936150 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1145.3381097316742 2015.6466051936150
5298 path.moveTo(1156.6848144531250, 2015.6466064453125);
5299 path.lineTo(1145.3381347656250, 2015.6466064453125);
5300 // Segment 1145.3381097316742 2015.6466051936150 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1145.3381097316742 2016.9966052174568
5301 path.lineTo(1145.3381347656250, 2016.9965820312500);
5302 // Segment 1145.3381097316742 2016.9966052174568 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1156.6848182678223 2016.9966052174568
5303 path.lineTo(1156.6848144531250, 2016.9965820312500);
5304 // Segment 1156.6848182678223 2016.9966052174568 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1156.6848182678223 2015.6466051936150
5305 path.lineTo(1156.6848144531250, 2015.6466064453125);
5306 path.close();
5307 // start loop, contour: 14
5308 // Segment 1145.8121519375022 2016.8021351246741 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1147.8064220237907 2014.8347900061515
5309 path.moveTo(1145.8121337890625, 2016.8021240234375);
5310 path.lineTo(1147.8063964843750, 2014.8348388671875);
5311 // Segment 1147.8064220237907 2014.8347900061515 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.8583376121346 2013.8737301678750
5312 path.lineTo(1146.8583984375000, 2013.8737792968750);
5313 // Segment 1146.8583376121346 2013.8737301678750 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1144.8640675258462 2015.8410752863977
5314 path.lineTo(1144.8640136718750, 2015.8410644531250);
5315 // Segment 1144.8640675258462 2015.8410752863977 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1145.8121519375022 2016.8021351246741
5316 path.lineTo(1145.8121337890625, 2016.8021240234375);
5317 path.close();
5318 // start loop, contour: 15
5319 // Segment 1147.8064220516883 2014.8347899786306 0.5430154146087 -0.5356841365729 0.5430154146087 0.5356841365729 1147.8064220516883 2012.9239773430752
5320 path.moveTo(1147.8063964843750, 2014.8348388671875);
5321 path.cubicTo(1148.3494873046875, 2014.2990722656250, 1148.3494873046875, 2013.4597167968750, 1147.8063964843750, 2012.9239501953125);
5322 // Segment 1147.8064220516883 2012.9239773430752 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.8583375842370 2013.8850371263100
5323 path.lineTo(1146.8583984375000, 2013.8850097656250);
5324 // Segment 1146.8583375842370 2013.8850371263100 0.0071280060876 0.0070317705240 0.0071280060876 -0.0070317705240 1146.8583375842370 2013.8737301953959
5325 path.cubicTo(1146.8654785156250, 2013.8920898437500, 1146.8654785156250, 2013.8666992187500, 1146.8583984375000, 2013.8737792968750);
5326 // Segment 1146.8583375842370 2013.8737301953959 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1147.8064220516883 2014.8347899786306
5327 path.lineTo(1147.8063964843750, 2014.8348388671875);
5328 path.close();
5329 // start loop, contour: 16
5330 // Segment 1147.8064220516883 2012.9239773430752 -0.5379138488298 -0.5306514472866 0.5379138488298 -0.5306514472866 1145.8955864341058 2012.9239773430752
5331 path.moveTo(1147.8063964843750, 2012.9239501953125);
5332 path.cubicTo(1147.2685546875000, 2012.3933105468750, 1146.4334716796875, 2012.3933105468750, 1145.8956298828125, 2012.9239501953125);
5333 // Segment 1145.8955864341058 2012.9239773430752 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.8436709015571 2013.8850371263100
5334 path.lineTo(1146.8436279296875, 2013.8850097656250);
5335 // Segment 1146.8436709015571 2013.8850371263100 0.0122295718664 -0.0120644598103 -0.0122295718664 -0.0120644598103 1146.8583375842370 2013.8850371263100
5336 path.cubicTo(1146.8559570312500, 2013.8729248046875, 1146.8460693359375, 2013.8729248046875, 1146.8583984375000, 2013.8850097656250);
5337 // Segment 1146.8583375842370 2013.8850371263100 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1147.8064220516883 2012.9239773430752
5338 path.lineTo(1147.8063964843750, 2012.9239501953125);
5339 path.close();
5340 // start loop, contour: 17
5341 // Segment 1145.8955864579798 2012.9239773195236 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1142.7322615803600 2016.0445936810224
5342 path.moveTo(1145.8956298828125, 2012.9239501953125);
5343 path.lineTo(1142.7322998046875, 2016.0445556640625);
5344 // Segment 1142.7322615803600 2016.0445936810224 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1143.6803460000633 2017.0056535113604
5345 path.lineTo(1143.6802978515625, 2017.0056152343750);
5346 // Segment 1143.6803460000633 2017.0056535113604 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.8436708776831 2013.8850371498615
5347 path.lineTo(1146.8436279296875, 2013.8850097656250);
5348 // Segment 1146.8436708776831 2013.8850371498615 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1145.8955864579798 2012.9239773195236
5349 path.lineTo(1145.8956298828125, 2012.9239501953125);
5350 path.close();
5351 // start loop, contour: 18
5352 // Segment 1142.7322615564860 2016.0445937045740 -0.0343838913237 0.0339196727021 0.0561572931720 -0.0710493024751 1142.5744069596683 2016.2183613784646
5353 path.moveTo(1142.7322998046875, 2016.0445556640625);
5354 path.cubicTo(1142.6978759765625, 2016.0784912109375, 1142.6306152343750, 2016.1473388671875, 1142.5744628906250, 2016.2183837890625);
5355 // Segment 1142.5744069596683 2016.2183613784646 -0.0547779032556 0.0720510806539 0.0000000000000 -0.2570904015602 1142.3937679156661 2016.7286419868469
5356 path.cubicTo(1142.5196533203125, 2016.2904052734375, 1142.3937988281250, 2016.4715576171875, 1142.3937988281250, 2016.7286376953125);
5357 // Segment 1142.3937679156661 2016.7286419868469 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1143.7437679395080 2016.7286419868469
5358 path.lineTo(1143.7437744140625, 2016.7286376953125);
5359 // Segment 1143.7437679395080 2016.7286419868469 -0.0051909534315 0.0665915567290 0.0133980913650 -0.0361675066532 1143.6976291086639 2016.9514128270803
5360 path.cubicTo(1143.7385253906250, 2016.7952880859375, 1143.7110595703125, 2016.9152832031250, 1143.6976318359375, 2016.9514160156250);
5361 // Segment 1143.6976291086639 2016.9514128270803 -0.0142876819622 0.0277028472317 0.0040377216094 -0.0063254385208 1143.6490888124401 2017.0354042045738
5362 path.cubicTo(1143.6833496093750, 2016.9791259765625, 1143.6530761718750, 2017.0290527343750, 1143.6490478515625, 2017.0354003906250);
5363 // Segment 1143.6490888124401 2017.0354042045738 -0.0045813437564 0.0032098513409 -0.0343840362634 0.0339198156850 1143.6803460239373 2017.0056534878088
5364 path.cubicTo(1143.6445312500000, 2017.0385742187500, 1143.6459960937500, 2017.0395507812500, 1143.6802978515625, 2017.0056152343750);
5365 // Segment 1143.6803460239373 2017.0056534878088 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1142.7322615564860 2016.0445937045740
5366 path.lineTo(1142.7322998046875, 2016.0445556640625);
5367 path.close();
5368 // start loop, contour: 19
5369 // Segment 1142.5947256938614 2016.2481120952295 -0.1857487117715 0.1832409092043 0.0167379373694 -0.0990717748979 1142.3430278987244 2016.7518748698508
5370 path.moveTo(1142.5947265625000, 2016.2481689453125);
5371 path.cubicTo(1142.4089355468750, 2016.4313964843750, 1142.3597412109375, 2016.6528320312500, 1142.3430175781250, 2016.7518310546875);
5372 // Segment 1142.3430278987244 2016.7518748698508 -0.0156657977007 0.1069052535795 0.0000000000000 -0.0339197441936 1142.3249999880791 2017.0000000000000
5373 path.cubicTo(1142.3273925781250, 2016.8587646484375, 1142.3249511718750, 2016.9660644531250, 1142.3249511718750, 2017.0000000000000);
5374 // Segment 1142.3249999880791 2017.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1143.6750000119209 2017.0000000000000
5375 path.lineTo(1143.6750488281250, 2017.0000000000000);
5376 // Segment 1143.6750000119209 2017.0000000000000 0.0000000000000 -0.0339197441936 -0.0015261841961 -0.0051459911965 1143.6741640831724 2016.9767671169961
5377 path.cubicTo(1143.6750488281250, 2016.9660644531250, 1143.6726074218750, 2016.9716796875000, 1143.6741943359375, 2016.9768066406250);
5378 // Segment 1143.6741640831724 2016.9767671169961 -0.0007886982052 0.0013596649622 0.0074114058388 -0.0224954551713 1143.6525251830094 2017.0486861571169
5379 path.cubicTo(1143.6733398437500, 2016.9781494140625, 1143.6599121093750, 2017.0262451171875, 1143.6524658203125, 2017.0487060546875);
5380 // split at 0.4203657805920
5381 // path.cubicTo(1143.6738281250000, 2016.9774169921875, 1143.6712646484375, 2016.9862060546875, 1143.6678466796875, 2016.9979248046875);
5382 // path.cubicTo(1143.6630859375000, 2017.0140380859375, 1143.6567382812500, 2017.0356445312500, 1143.6524658203125, 2017.0487060546875);
5383 // Segment 1143.6525251830094 2017.0486861571169 -0.0119644334077 0.0236755853369 0.0381324473830 -0.0447670202574 1143.5428101613127 2017.2091718784643
5384 path.cubicTo(1143.6405029296875, 2017.0723876953125, 1143.5809326171875, 2017.1644287109375, 1143.5428466796875, 2017.2092285156250);
5385 // Segment 1143.5428101613127 2017.2091718784643 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1142.5947256938614 2016.2481120952295
5386 path.lineTo(1142.5947265625000, 2016.2481689453125);
5387 path.close();
5388 // start loop, contour: 20
5389 // Segment 1142.3249999880791 2017.0000000000000 0.0000000000000 0.0339197441936 -0.0156657977007 -0.1069052535795 1142.3430278987244 2017.2481251301492
5390 path.moveTo(1142.3249511718750, 2017.0000000000000);
5391 path.cubicTo(1142.3249511718750, 2017.0339355468750, 1142.3273925781250, 2017.1412353515625, 1142.3430175781250, 2017.2481689453125);
5392 // Segment 1142.3430278987244 2017.2481251301492 0.0167379373694 0.0990717748979 -0.1857487117715 -0.1832409092043 1142.5947256938614 2017.7518879047705
5393 path.cubicTo(1142.3597412109375, 2017.3471679687500, 1142.4089355468750, 2017.5686035156250, 1142.5947265625000, 2017.7518310546875);
5394 // split at 0.4008532166481
5395 // path.cubicTo(1142.3497314453125, 2017.2878417968750, 1142.3616943359375, 2017.3471679687500, 1142.3854980468750, 2017.4158935546875);
5396 // path.cubicTo(1142.4211425781250, 2017.5185546875000, 1142.4833984375000, 2017.6420898437500, 1142.5947265625000, 2017.7518310546875);
5397 // Segment 1142.5947256938614 2017.7518879047705 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1143.5428101613127 2016.7908281215357
5398 path.lineTo(1143.5428466796875, 2016.7907714843750);
5399 // Segment 1143.5428101613127 2016.7908281215357 0.0381324473830 0.0447670202574 -0.0119644334077 -0.0236755853369 1143.6525251830094 2016.9513138428831
5400 path.cubicTo(1143.5809326171875, 2016.8355712890625, 1143.6405029296875, 2016.9276123046875, 1143.6524658203125, 2016.9512939453125);
5401 // Segment 1143.6525251830094 2016.9513138428831 0.0074114058388 0.0224954551713 -0.0007886982052 -0.0013596649622 1143.6741640831724 2017.0232328830039
5402 path.cubicTo(1143.6599121093750, 2016.9737548828125, 1143.6733398437500, 2017.0218505859375, 1143.6741943359375, 2017.0231933593750);
5403 // Segment 1143.6741640831724 2017.0232328830039 -0.0015261841961 0.0051459911965 0.0000000000000 0.0339197441936 1143.6750000119209 2017.0000000000000
5404 path.cubicTo(1143.6726074218750, 2017.0283203125000, 1143.6750488281250, 2017.0339355468750, 1143.6750488281250, 2017.0000000000000);
5405 // Segment 1143.6750000119209 2017.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1142.3249999880791 2017.0000000000000
5406 path.lineTo(1142.3249511718750, 2017.0000000000000);
5407 path.close();
5408 // start loop, contour: 21
5409 // Segment 1142.5947256938614 2017.7518879047705 -0.0799271403989 -0.1522613934208 -0.2174629955730 -0.2879403701950 1142.7322615564860 2017.9554062954260
5410 path.moveTo(1142.5947265625000, 2017.7518310546875);
5411 path.cubicTo(1142.5147705078125, 2017.5996093750000, 1142.5147705078125, 2017.6674804687500, 1142.7322998046875, 2017.9554443359375);
5412 // Segment 1142.7322615564860 2017.9554062954260 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1143.6803460239373 2016.9943465121912
5413 path.lineTo(1143.6802978515625, 2016.9943847656250);
5414 // Segment 1143.6803460239373 2016.9943465121912 0.0799271403989 0.1522613934208 0.2174629955730 0.2879403701950 1143.5428101613127 2016.7908281215357
5415 path.cubicTo(1143.7602539062500, 2017.1466064453125, 1143.7602539062500, 2017.0787353515625, 1143.5428466796875, 2016.7907714843750);
5416 // Segment 1143.5428101613127 2016.7908281215357 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1142.5947256938614 2017.7518879047705
5417 path.lineTo(1142.5947265625000, 2017.7518310546875);
5418 path.close();
5419 // start loop, contour: 22
5420 // Segment 1142.7322615746241 2017.9554063133189 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1145.8955864522438 2021.0760227493236
5421 path.moveTo(1142.7322998046875, 2017.9554443359375);
5422 path.lineTo(1145.8956298828125, 2021.0760498046875);
5423 // Segment 1145.8955864522438 2021.0760227493236 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.8436708834190 2020.1149629303029
5424 path.lineTo(1146.8436279296875, 2020.1149902343750);
5425 // Segment 1146.8436708834190 2020.1149629303029 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1143.6803460057993 2016.9943464942983
5426 path.lineTo(1143.6802978515625, 2016.9943847656250);
5427 // Segment 1143.6803460057993 2016.9943464942983 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1142.7322615746241 2017.9554063133189
5428 path.lineTo(1142.7322998046875, 2017.9554443359375);
5429 path.close();
5430 // start loop, contour: 23
5431 // Segment 1145.8955864341058 2021.0760227314306 0.2730164534637 0.2693304447891 -0.3016608168437 0.0000000000000 1146.8510041236877 2021.4740112423897
5432 path.moveTo(1145.8956298828125, 2021.0760498046875);
5433 path.cubicTo(1146.1685791015625, 2021.3453369140625, 1146.5493164062500, 2021.4739990234375, 1146.8509521484375, 2021.4739990234375);
5434 // Segment 1146.8510041236877 2021.4740112423897 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.8510041236877 2020.1240112185478
5435 path.lineTo(1146.8509521484375, 2020.1240234375000);
5436 // Segment 1146.8510041236877 2020.1240112185478 -0.0031276099109 0.0031991747760 0.0281856144058 0.0140930868099 1146.8580791488898 2020.1202473991566
5437 path.cubicTo(1146.8479003906250, 2020.1271972656250, 1146.8862304687500, 2020.1343994140625, 1146.8580322265625, 2020.1202392578125);
5438 // split at 0.3845077157021
5439 // path.cubicTo(1146.8497314453125, 2020.1252441406250, 1146.8547363281250, 2020.1270751953125, 1146.8596191406250, 2020.1280517578125);
5440 // path.cubicTo(1146.8675537109375, 2020.1296386718750, 1146.8753662109375, 2020.1289062500000, 1146.8580322265625, 2020.1202392578125);
5441 // Segment 1146.8580791488898 2020.1202473991566 -0.0369995545027 -0.0123195805663 0.0067223483810 0.0136883790721 1146.8436709015571 2020.1149629481959
5442 path.cubicTo(1146.8210449218750, 2020.1079101562500, 1146.8503417968750, 2020.1286621093750, 1146.8436279296875, 2020.1149902343750);
5443 // Segment 1146.8436709015571 2020.1149629481959 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1145.8955864341058 2021.0760227314306
5444 path.lineTo(1145.8956298828125, 2021.0760498046875);
5445 path.close();
5446 // start loop, contour: 24
5447 // Segment 1146.8510041236877 2021.4740112423897 0.3016605789999 0.0000000000000 -0.2730166120260 0.2693306012106 1147.8064220516883 2021.0760227314306
5448 path.moveTo(1146.8509521484375, 2021.4739990234375);
5449 path.cubicTo(1147.1527099609375, 2021.4739990234375, 1147.5334472656250, 2021.3453369140625, 1147.8063964843750, 2021.0760498046875);
5450 // Segment 1147.8064220516883 2021.0760227314306 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.8583375842370 2020.1149629481959
5451 path.lineTo(1146.8583984375000, 2020.1149902343750);
5452 // Segment 1146.8583375842370 2020.1149629481959 -0.0067222671256 0.0136883164611 0.0369996293611 -0.0123196021258 1146.8439293663473 2020.1202473404985
5453 path.cubicTo(1146.8515625000000, 2020.1286621093750, 1146.8809814453125, 2020.1079101562500, 1146.8438720703125, 2020.1202392578125);
5454 // Segment 1146.8439293663473 2020.1202473404985 -0.0281857033438 0.0140931104690 0.0031276541428 0.0031991704542 1146.8510041236877 2020.1240112185478
5455 path.cubicTo(1146.8157958984375, 2020.1343994140625, 1146.8541259765625, 2020.1271972656250, 1146.8509521484375, 2020.1240234375000);
5456 // Segment 1146.8510041236877 2020.1240112185478 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.8510041236877 2021.4740112423897
5457 path.lineTo(1146.8509521484375, 2021.4739990234375);
5458 path.close();
5459 // start loop, contour: 25
5460 // Segment 1147.8064220516883 2021.0760227314306 0.5430154146087 -0.5356841365729 0.5430154146087 0.5356841365729 1147.8064220516883 2019.1652101405787
5461 path.moveTo(1147.8063964843750, 2021.0760498046875);
5462 path.cubicTo(1148.3494873046875, 2020.5402832031250, 1148.3494873046875, 2019.7009277343750, 1147.8063964843750, 2019.1651611328125);
5463 // Segment 1147.8064220516883 2019.1652101405787 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.8583375842370 2020.1262699238134
5464 path.lineTo(1146.8583984375000, 2020.1262207031250);
5465 // Segment 1146.8583375842370 2020.1262699238134 0.0071280060876 0.0070317705240 0.0071280060876 -0.0070317705240 1146.8583375842370 2020.1149629481959
5466 path.cubicTo(1146.8654785156250, 2020.1333007812500, 1146.8654785156250, 2020.1079101562500, 1146.8583984375000, 2020.1149902343750);
5467 // Segment 1146.8583375842370 2020.1149629481959 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1147.8064220516883 2021.0760227314306
5468 path.lineTo(1147.8063964843750, 2021.0760498046875);
5469 path.close();
5470 // start loop, contour: 26
5471 // Segment 1147.8064220383478 2019.1652101274185 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1145.8121519520594 2017.1978648896866
5472 path.moveTo(1147.8063964843750, 2019.1651611328125);
5473 path.lineTo(1145.8121337890625, 2017.1978759765625);
5474 // Segment 1145.8121519520594 2017.1978648896866 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1144.8640675112890 2018.1589246992417
5475 path.lineTo(1144.8640136718750, 2018.1589355468750);
5476 // Segment 1144.8640675112890 2018.1589246992417 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1146.8583375975775 2020.1262699369736
5477 path.lineTo(1146.8583984375000, 2020.1262207031250);
5478 // Segment 1146.8583375975775 2020.1262699369736 0.0000000000000 0.0000000000000 0.0000000000000 0.0000000000000 1147.8064220383478 2019.1652101274185
5479 path.lineTo(1147.8063964843750, 2019.1651611328125);
5480 path.close();
5481
5482testSimplify(reporter, path, filename);
5483}
5484
5485static void testQuads66(skiatest::Reporter* reporter,const char* filename) {
5486 SkPath path;
5487 path.moveTo(2, 0);
5488 path.quadTo(3, 1, 2, 2);
5489 path.lineTo(2, 3);
5490 path.close();
5491 path.moveTo(2, 1);
5492 path.lineTo(2, 1);
5493 path.quadTo(1, 2, 2, 2);
5494 path.close();
5495 testSimplify(reporter, path, filename);
5496}
5497
5498static void testQuads67(skiatest::Reporter* reporter,const char* filename) {
5499 SkPath path;
5500 path.moveTo(3, 2);
5501 path.quadTo(1, 3, 3, 3);
5502 path.lineTo(3, 3);
5503 path.close();
5504 path.moveTo(0, 0);
5505 path.lineTo(1, 0);
5506 path.quadTo(2, 3, 3, 3);
5507 path.close();
5508 testSimplify(reporter, path, filename);
5509}
5510
5511static void testQuads68(skiatest::Reporter* reporter,const char* filename) {
5512 SkPath path;
5513 path.moveTo(1, 2);
5514 path.quadTo(0, 3, 2, 3);
5515 path.lineTo(2, 3);
5516 path.close();
5517 path.moveTo(1, 0);
5518 path.lineTo(0, 1);
5519 path.quadTo(1, 3, 2, 3);
5520 path.close();
5521 testSimplify(reporter, path, filename);
5522}
5523
5524static void testQuads69(skiatest::Reporter* reporter,const char* filename) {
5525 SkPath path;
5526 path.moveTo(1, 0);
5527 path.quadTo(2, 2, 2, 3);
5528 path.lineTo(2, 3);
5529 path.close();
5530 path.moveTo(1, 0);
5531 path.lineTo(1, 0);
5532 path.quadTo(3, 0, 1, 3);
5533 path.close();
5534 testSimplify(reporter, path, filename);
5535}
5536
5537static void testQuads70(skiatest::Reporter* reporter, const char* filename) {
5538 SkPath path;
5539 path.moveTo(1, 1);
5540 path.quadTo(2, 3, 3, 3);
5541 path.lineTo(3, 3);
5542 path.close();
5543 path.moveTo(2, 0);
5544 path.lineTo(2, 2);
5545 path.quadTo(1, 3, 3, 3);
5546 path.close();
5547 testSimplify(reporter, path, filename);
5548}
5549
5550static void testQuads71(skiatest::Reporter* reporter, const char* filename) {
5551 SkPath path;
5552 path.moveTo(1, 1);
5553 path.quadTo(2, 3, 3, 3);
5554 path.lineTo(3, 3);
5555 path.close();
5556 path.moveTo(3, 0);
5557 path.lineTo(2, 2);
5558 path.quadTo(1, 3, 3, 3);
5559 path.close();
5560 testSimplify(reporter, path, filename);
5561}
5562
5563static void testQuads72(skiatest::Reporter* reporter, const char* filename) {
5564 SkPath path;
5565 path.moveTo(1, 1);
5566 path.quadTo(2, 3, 3, 3);
5567 path.lineTo(3, 3);
5568 path.close();
5569 path.moveTo(0, 1);
5570 path.lineTo(2, 2);
5571 path.quadTo(1, 3, 3, 3);
5572 path.close();
5573 testSimplify(reporter, path, filename);
5574}
5575
5576static void testQuads73(skiatest::Reporter* reporter, const char* filename) {
5577 SkPath path;
5578 path.moveTo(0, 0);
5579 path.quadTo(0, 1, 1, 2);
5580 path.lineTo(0, 3);
5581 path.close();
5582 path.moveTo(0, 0);
5583 path.lineTo(0, 0);
5584 path.quadTo(0, 1, 1, 1);
5585 path.close();
5586 testSimplify(reporter, path, filename);
5587}
5588
5589static void bug5169(skiatest::Reporter* reporter, const char* filename) {
5590 SkPath path;
5591path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x4281c71c)); // 0, 64.8889f
5592path.cubicTo(SkBits2Float(0x434e0000), SkBits2Float(0x4281c71c), SkBits2Float(0x00000000), SkBits2Float(0xc2a238e4), SkBits2Float(0x00000000), SkBits2Float(0x4281c71c)); // 206, 64.8889f, 0, -81.1111f, 0, 64.8889f
5593path.moveTo(SkBits2Float(0x43300000), SkBits2Float(0x41971c72)); // 176, 18.8889f
5594path.cubicTo(SkBits2Float(0xc29e0000), SkBits2Float(0xc25c71c7), SkBits2Float(0x42b20000), SkBits2Float(0x42fbc71c), SkBits2Float(0x43300000), SkBits2Float(0x41971c72)); // -79, -55.1111f, 89, 125.889f, 176, 18.8889f
5595 testSimplify(reporter, path, filename);
5596}
5597
5598static void tiger8_393(skiatest::Reporter* reporter, const char* filename) {
5599 SkPath path;
5600 path.setFillType((SkPathFillType) 0);
5601path.moveTo(SkBits2Float(0x42b93333), SkBits2Float(0x43d5a666)); // 92.6f, 427.3f
5602path.cubicTo(SkBits2Float(0x42b93333), SkBits2Float(0x43d5a666), SkBits2Float(0x42b5cccd), SkBits2Float(0x43da1999), SkBits2Float(0x42b80000), SkBits2Float(0x43ddf333)); // 92.6f, 427.3f, 90.9f, 436.2f, 92, 443.9f
5603path.cubicTo(SkBits2Float(0x42b80000), SkBits2Float(0x43ddf333), SkBits2Float(0x42b30000), SkBits2Float(0x43e17333), SkBits2Float(0x42cf999a), SkBits2Float(0x43e1b333)); // 92, 443.9f, 89.5f, 450.9f, 103.8f, 451.4f
5604path.cubicTo(SkBits2Float(0x42ec3334), SkBits2Float(0x43e14ccd), SkBits2Float(0x42e73334), SkBits2Float(0x43ddf333), SkBits2Float(0x42e73334), SkBits2Float(0x43ddf333)); // 118.1f, 450.6f, 115.6f, 443.9f, 115.6f, 443.9f
5605path.cubicTo(SkBits2Float(0x42e7999a), SkBits2Float(0x43de8000), SkBits2Float(0x42ea6667), SkBits2Float(0x43db4000), SkBits2Float(0x42e60001), SkBits2Float(0x43d5a666)); // 115.8f, 445, 117.2f, 438.5f, 115, 427.3f
5606 testSimplify(reporter, path, filename);
5607}
5608
5609// triggers angle assert from distance field code
5610static void carsvg_1(skiatest::Reporter* reporter, const char* filename) {
5611 SkPath path;
5612 path.setFillType((SkPathFillType) 0);
5613path.moveTo(SkBits2Float(0x4393d61e), SkBits2Float(0x43e768f9)); // 295.673f, 462.82f
5614path.cubicTo(SkBits2Float(0x4396b50e), SkBits2Float(0x43e63c20), SkBits2Float(0x43998931), SkBits2Float(0x43e6c43e), SkBits2Float(0x439cb6a8), SkBits2Float(0x43e70ef9)); // 301.414f, 460.47f, 307.072f, 461.533f, 313.427f, 462.117f
5615path.cubicTo(SkBits2Float(0x439dfc1e), SkBits2Float(0x43e72ce0), SkBits2Float(0x439a285c), SkBits2Float(0x43e717fb), SkBits2Float(0x4398e23c), SkBits2Float(0x43e7027c)); // 315.97f, 462.351f, 308.315f, 462.187f, 305.767f, 462.019f
5616path.cubicTo(SkBits2Float(0x4398136f), SkBits2Float(0x43e6f4db), SkBits2Float(0x439a7e14), SkBits2Float(0x43e6d390), SkBits2Float(0x439b4ba9), SkBits2Float(0x43e6b956)); // 304.152f, 461.913f, 308.985f, 461.653f, 310.591f, 461.448f
5617path.cubicTo(SkBits2Float(0x439c2b19), SkBits2Float(0x43e68603), SkBits2Float(0x43abf4df), SkBits2Float(0x43e9ca9e), SkBits2Float(0x43a1daea), SkBits2Float(0x43e912a5)); // 312.337f, 461.047f, 343.913f, 467.583f, 323.71f, 466.146f
5618path.cubicTo(SkBits2Float(0x43a4f45a), SkBits2Float(0x43e78baf), SkBits2Float(0x43a2a391), SkBits2Float(0x43e86a82), SkBits2Float(0x43a946bd), SkBits2Float(0x43e90c56)); // 329.909f, 463.091f, 325.278f, 464.832f, 338.553f, 466.096f
5619path.lineTo(SkBits2Float(0x43a4250b), SkBits2Float(0x43e998dc)); // 328.289f, 467.194f
5620path.cubicTo(SkBits2Float(0x43a8a9c8), SkBits2Float(0x43e8f06c), SkBits2Float(0x43a95cb5), SkBits2Float(0x43e84ea6), SkBits2Float(0x43a6f7c1), SkBits2Float(0x43e9bdb5)); // 337.326f, 465.878f, 338.724f, 464.614f, 333.936f, 467.482f
5621path.cubicTo(SkBits2Float(0x43a59ed0), SkBits2Float(0x43e9d2ca), SkBits2Float(0x4395ea4d), SkBits2Float(0x43e92afe), SkBits2Float(0x43a06569), SkBits2Float(0x43e7773d)); // 331.241f, 467.647f, 299.83f, 466.336f, 320.792f, 462.932f
5622path.cubicTo(SkBits2Float(0x438bf0ff), SkBits2Float(0x43ea0fef), SkBits2Float(0x43a0e17a), SkBits2Float(0x43e5f41b), SkBits2Float(0x4398f3fb), SkBits2Float(0x43e804c8)); // 279.883f, 468.124f, 321.762f, 459.907f, 305.906f, 464.037f
5623path.lineTo(SkBits2Float(0x4393d61e), SkBits2Float(0x43e768f9)); // 295.673f, 462.82f
5624path.close();
5625
5626 testSimplify(reporter, path, filename);
5627}
5628
5629static void simplifyTest_1(skiatest::Reporter* reporter, const char* filename) {
5630 SkPath path;
5631 path.setFillType((SkPathFillType) 0);
5632path.moveTo(SkBits2Float(0x42bfefd4), SkBits2Float(0x42ef80ef)); // 95.9684f, 119.752f
5633path.quadTo(SkBits2Float(0x42c26810), SkBits2Float(0x42e214b8), SkBits2Float(0x42cdcad5), SkBits2Float(0x42d82aa2)); // 97.2032f, 113.04f, 102.896f, 108.083f
5634path.lineTo(SkBits2Float(0x42cdcb21), SkBits2Float(0x42d82a61)); // 102.897f, 108.083f
5635path.quadTo(SkBits2Float(0x42d5e3c8), SkBits2Float(0x42d12140), SkBits2Float(0x42e20ee8), SkBits2Float(0x42cdc937)); // 106.945f, 104.565f, 113.029f, 102.893f
5636path.lineTo(SkBits2Float(0x42e256e3), SkBits2Float(0x42cdbc92)); // 113.17f, 102.868f
5637path.lineTo(SkBits2Float(0x42f5eadb), SkBits2Float(0x42cc2cb3)); // 122.959f, 102.087f
5638path.lineTo(SkBits2Float(0x42f746a6), SkBits2Float(0x42cccf85)); // 123.638f, 102.405f
5639path.quadTo(SkBits2Float(0x42fa586c), SkBits2Float(0x42d126c4), SkBits2Float(0x42f6c657), SkBits2Float(0x42d5d315)); // 125.173f, 104.576f, 123.387f, 106.912f
5640path.lineTo(SkBits2Float(0x42f591eb), SkBits2Float(0x42d4e76d)); // 122.785f, 106.452f
5641path.lineTo(SkBits2Float(0x42f6c6e0), SkBits2Float(0x42d5d261)); // 123.388f, 106.911f
5642path.quadTo(SkBits2Float(0x42f6bb33), SkBits2Float(0x42d5e1bb), SkBits2Float(0x42f6a3d8), SkBits2Float(0x42d6007c)); // 123.366f, 106.941f, 123.32f, 107.001f
5643path.quadTo(SkBits2Float(0x42ea3850), SkBits2Float(0x42e65af0), SkBits2Float(0x42d97a6e), SkBits2Float(0x42ed841c)); // 117.11f, 115.178f, 108.739f, 118.758f
5644path.lineTo(SkBits2Float(0x42d91d92), SkBits2Float(0x42ed9ec0)); // 108.558f, 118.81f
5645path.lineTo(SkBits2Float(0x42c1a959), SkBits2Float(0x42f146b0)); // 96.8308f, 120.638f
5646path.lineTo(SkBits2Float(0x42bfefd4), SkBits2Float(0x42ef80f0)); // 95.9684f, 119.752f
5647path.lineTo(SkBits2Float(0x42bfefd4), SkBits2Float(0x42ef80ef)); // 95.9684f, 119.752f
5648path.close();
5649path.moveTo(SkBits2Float(0x42c2eb4e), SkBits2Float(0x42f00d68)); // 97.4596f, 120.026f
5650path.lineTo(SkBits2Float(0x42c16d91), SkBits2Float(0x42efc72c)); // 96.714f, 119.889f
5651path.lineTo(SkBits2Float(0x42c131c9), SkBits2Float(0x42ee47a8)); // 96.5972f, 119.14f
5652path.lineTo(SkBits2Float(0x42d8a602), SkBits2Float(0x42ea9fb8)); // 108.324f, 117.312f
5653path.lineTo(SkBits2Float(0x42d8e1ca), SkBits2Float(0x42ec1f3c)); // 108.441f, 118.061f
5654path.lineTo(SkBits2Float(0x42d84926), SkBits2Float(0x42eaba5c)); // 108.143f, 117.364f
5655path.quadTo(SkBits2Float(0x42e84a40), SkBits2Float(0x42e3e1f0), SkBits2Float(0x42f439a2), SkBits2Float(0x42d42af8)); // 116.145f, 113.941f, 122.113f, 106.084f
5656path.quadTo(SkBits2Float(0x42f45121), SkBits2Float(0x42d40c08), SkBits2Float(0x42f45cf6), SkBits2Float(0x42d3fc79)); // 122.158f, 106.023f, 122.182f, 105.993f
5657path.lineTo(SkBits2Float(0x42f45d7f), SkBits2Float(0x42d3fbc5)); // 122.183f, 105.992f
5658path.quadTo(SkBits2Float(0x42f69510), SkBits2Float(0x42d114f4), SkBits2Float(0x42f4ccce), SkBits2Float(0x42ce8fb7)); // 123.291f, 104.541f, 122.4f, 103.281f
5659path.lineTo(SkBits2Float(0x42f609ba), SkBits2Float(0x42cdaf9e)); // 123.019f, 102.843f
5660path.lineTo(SkBits2Float(0x42f62899), SkBits2Float(0x42cf3289)); // 123.079f, 103.599f
5661path.lineTo(SkBits2Float(0x42e294a1), SkBits2Float(0x42d0c268)); // 113.29f, 104.38f
5662path.lineTo(SkBits2Float(0x42e275c2), SkBits2Float(0x42cf3f7d)); // 113.23f, 103.624f
5663path.lineTo(SkBits2Float(0x42e2dc9c), SkBits2Float(0x42d0b5c3)); // 113.431f, 104.355f
5664path.quadTo(SkBits2Float(0x42d75bb8), SkBits2Float(0x42d3df08), SkBits2Float(0x42cfc853), SkBits2Float(0x42da7457)); // 107.679f, 105.936f, 103.891f, 109.227f
5665path.lineTo(SkBits2Float(0x42cec9ba), SkBits2Float(0x42d94f5c)); // 103.394f, 108.655f
5666path.lineTo(SkBits2Float(0x42cfc89f), SkBits2Float(0x42da7416)); // 103.892f, 109.227f
5667path.quadTo(SkBits2Float(0x42c53268), SkBits2Float(0x42e3ac00), SkBits2Float(0x42c2eb4e), SkBits2Float(0x42f00d67)); // 98.5984f, 113.836f, 97.4596f, 120.026f
5668path.lineTo(SkBits2Float(0x42c2eb4e), SkBits2Float(0x42f00d68)); // 97.4596f, 120.026f
5669path.close();
5670
5671 testSimplify(reporter, path, filename);
5672}
5673
5674static void joel_1(skiatest::Reporter* reporter, const char* filename) {
5675 SkPath path;
5676 path.setFillType((SkPathFillType) 0);
5677path.moveTo(144.859f, 285.172f);
5678path.lineTo(144.859f, 285.172f);
5679path.lineTo(144.859f, 285.172f);
5680path.lineTo(143.132f, 284.617f);
5681path.lineTo(144.859f, 285.172f);
5682path.close();
5683path.moveTo(135.922f, 286.844f);
5684path.lineTo(135.922f, 286.844f);
5685path.lineTo(135.922f, 286.844f);
5686path.lineTo(135.367f, 288.571f);
5687path.lineTo(135.922f, 286.844f);
5688path.close();
5689path.moveTo(135.922f, 286.844f);
5690path.cubicTo(137.07f, 287.219f, 138.242f, 287.086f, 139.242f, 286.578f);
5691path.cubicTo(140.234f, 286.078f, 141.031f, 285.203f, 141.406f, 284.055f);
5692path.lineTo(144.859f, 285.172f);
5693path.cubicTo(143.492f, 289.375f, 138.992f, 291.656f, 134.797f, 290.297f);
5694path.lineTo(135.922f, 286.844f);
5695path.close();
5696path.moveTo(129.68f, 280.242f);
5697path.lineTo(129.68f, 280.242f);
5698path.lineTo(129.68f, 280.242f);
5699path.lineTo(131.407f, 280.804f);
5700path.lineTo(129.68f, 280.242f);
5701path.close();
5702path.moveTo(133.133f, 281.367f);
5703path.cubicTo(132.758f, 282.508f, 132.883f, 283.687f, 133.391f, 284.679f);
5704path.cubicTo(133.907f, 285.679f, 134.774f, 286.468f, 135.922f, 286.843f);
5705path.lineTo(134.797f, 290.296f);
5706path.cubicTo(130.602f, 288.929f, 128.313f, 284.437f, 129.68f, 280.241f);
5707path.lineTo(133.133f, 281.367f);
5708path.close();
5709path.moveTo(139.742f, 275.117f);
5710path.lineTo(139.742f, 275.117f);
5711path.lineTo(139.18f, 276.844f);
5712path.lineTo(139.742f, 275.117f);
5713path.close();
5714path.moveTo(138.609f, 278.57f);
5715path.cubicTo(137.461f, 278.203f, 136.297f, 278.328f, 135.297f, 278.836f);
5716path.cubicTo(134.297f, 279.344f, 133.508f, 280.219f, 133.133f, 281.367f);
5717path.lineTo(129.68f, 280.242f);
5718path.cubicTo(131.047f, 276.039f, 135.539f, 273.758f, 139.742f, 275.117f);
5719path.lineTo(138.609f, 278.57f);
5720path.close();
5721path.moveTo(141.406f, 284.055f);
5722path.cubicTo(141.773f, 282.907f, 141.648f, 281.735f, 141.148f, 280.735f);
5723path.cubicTo(140.625f, 279.735f, 139.757f, 278.946f, 138.609f, 278.571f);
5724path.lineTo(139.742f, 275.118f);
5725path.cubicTo(143.937f, 276.493f, 146.219f, 280.977f, 144.859f, 285.173f);
5726path.lineTo(141.406f, 284.055f);
5727path.close();
5728 testSimplify(reporter, path, filename);
5729}
5730
5731static void joel_2(skiatest::Reporter* reporter, const char* filename) {
5732 SkPath path;
5733 path.setFillType((SkPathFillType) 0);
5734
5735path.moveTo(403.283f, 497.197f);
5736path.cubicTo(403.424f, 497.244f, 391.111f, 495.556f, 391.111f, 495.556f);
5737path.lineTo(392.291f, 493.165f);
5738path.cubicTo(392.291f, 493.165f, 388.994f, 492.056f, 386.65f, 491.821f);
5739path.cubicTo(384.244f, 491.454f, 381.603f, 490.774f, 381.603f, 490.774f);
5740path.lineTo(383.392f, 488.383f);
5741path.cubicTo(383.392f, 488.383f, 379.119f, 487.453f, 378.939f, 485.695f);
5742path.cubicTo(378.791f, 483.57f, 383.064f, 485.25f, 384.877f, 485.843f);
5743path.lineTo(387.697f, 484.351f);
5744path.cubicTo(382.752f, 483.835f, 376.595f, 482.124f, 374.478f, 480.312f);
5745path.lineTo(356.22f, 496.304f);
5746path.lineTo(368.095f, 510.499f);
5747path.lineTo(373.884f, 510.202f);
5748path.lineTo(374.478f, 509.007f);
5749path.lineTo(370.916f, 506.913f);
5750path.lineTo(371.807f, 506.022f);
5751path.cubicTo(371.807f, 506.022f, 374.807f, 507.28f, 377.752f, 507.514f);
5752path.cubicTo(380.752f, 507.881f, 387.4f, 508.108f, 387.4f, 508.108f);
5753path.lineTo(388.884f, 506.764f);
5754path.cubicTo(388.884f, 506.764f, 378.345f, 504.998f, 378.345f, 504.819f);
5755path.lineTo(378.04f, 503.03f);
5756path.cubicTo(378.04f, 503.03f, 391.415f, 505.796f, 391.399f, 505.866f);
5757path.lineTo(386.063f, 502.132f);
5758path.lineTo(387.547f, 500.335f);
5759path.lineTo(398.375f, 501.976f);
5760path.lineTo(403.283f, 497.197f);
5761path.lineTo(403.283f, 497.197f);
5762path.close();
5763 testSimplify(reporter, path, filename);
5764}
5765
5766static void joel_3(skiatest::Reporter* reporter, const char* filename) {
5767 SkPath path;
5768 path.setFillType((SkPathFillType) 0);
5769path.moveTo(391.097f, 334.453f);
5770path.lineTo(390.761f, 334.617f);
5771path.lineTo(390.425f, 333.937f);
5772path.lineTo(390.761f, 333.765f);
5773path.lineTo(391.097f, 334.453f);
5774path.close();
5775path.moveTo(391.128f, 334.438f);
5776path.lineTo(390.808f, 334.633f);
5777path.lineTo(390.402f, 333.992f);
5778path.lineTo(390.73f, 333.781f);
5779path.lineTo(391.128f, 334.438f);
5780path.lineTo(391.128f, 334.438f);
5781path.close();
5782path.moveTo(455.073f, 302.219f);
5783path.lineTo(455.018f, 302.375f);
5784path.lineTo(454.87f, 302.453f);
5785path.lineTo(454.706f, 302.109f);
5786path.lineTo(455.073f, 302.219f);
5787path.close();
5788path.moveTo(454.87f, 302.453f);
5789path.lineTo(391.097f, 334.453f);
5790path.lineTo(390.761f, 333.765f);
5791path.lineTo(454.534f, 301.765f);
5792path.lineTo(454.87f, 302.453f);
5793path.close();
5794path.moveTo(456.245f, 296.867f);
5795path.lineTo(456.659f, 296.953f);
5796path.lineTo(456.526f, 297.351f);
5797path.lineTo(456.174f, 297.242f);
5798path.lineTo(456.245f, 296.867f);
5799path.lineTo(456.245f, 296.867f);
5800path.close();
5801path.moveTo(456.526f, 297.352f);
5802path.lineTo(455.073f, 302.219f);
5803path.lineTo(454.339f, 302);
5804path.lineTo(455.808f, 297.133f);
5805path.lineTo(456.526f, 297.352f);
5806path.lineTo(456.526f, 297.352f);
5807path.close();
5808path.moveTo(450.979f, 295.891f);
5809path.lineTo(451.112f, 295.813f);
5810path.lineTo(451.26f, 295.836f);
5811path.lineTo(451.19f, 296.211f);
5812path.lineTo(450.979f, 295.891f);
5813path.close();
5814path.moveTo(451.261f, 295.836f);
5815path.lineTo(456.245f, 296.867f);
5816path.lineTo(456.089f, 297.617f);
5817path.lineTo(451.105f, 296.586f);
5818path.lineTo(451.261f, 295.836f);
5819path.close();
5820path.moveTo(390.729f, 333.781f);
5821path.lineTo(450.979f, 295.89f);
5822path.lineTo(451.385f, 296.531f);
5823path.lineTo(391.127f, 334.437f);
5824path.lineTo(390.729f, 333.781f);
5825path.close();
5826 testSimplify(reporter, path, filename);
5827}
5828
5829static void joel_4(skiatest::Reporter* reporter, const char* filename) {
5830 SkPath path;
5831 path.setFillType((SkPathFillType) 0);
5832path.moveTo(SkBits2Float(0x4199d4fe), SkBits2Float(0x4265ac08)); // 19.229f, 57.418f
5833path.cubicTo(SkBits2Float(0x419be979), SkBits2Float(0x426574bc), SkBits2Float(0x419c2b02), SkBits2Float(0x42653c6a), SkBits2Float(0x419af5c3), SkBits2Float(0x42645f3b)); // 19.489f, 57.364f, 19.521f, 57.309f, 19.37f, 57.093f
5834path.cubicTo(SkBits2Float(0x419a1894), SkBits2Float(0x4263a3d7), SkBits2Float(0x4198cccd), SkBits2Float(0x4262f2b0), SkBits2Float(0x4197c290), SkBits2Float(0x4262374b)); // 19.262f, 56.91f, 19.1f, 56.737f, 18.97f, 56.554f
5835path.cubicTo(SkBits2Float(0x41960832), SkBits2Float(0x42610c49), SkBits2Float(0x41944dd4), SkBits2Float(0x425fd709), SkBits2Float(0x41927cee), SkBits2Float(0x425ea0c4)); // 18.754f, 56.262f, 18.538f, 55.96f, 18.311f, 55.657f
5836path.cubicTo(SkBits2Float(0x4191b646), SkBits2Float(0x425e1cab), SkBits2Float(0x418edd30), SkBits2Float(0x425ca4dd), SkBits2Float(0x418f4bc7), SkBits2Float(0x425bdd2e)); // 18.214f, 55.528f, 17.858f, 55.161f, 17.912f, 54.966f
5837path.lineTo(SkBits2Float(0x41903f7d), SkBits2Float(0x425b6e96)); // 18.031f, 54.858f
5838path.cubicTo(SkBits2Float(0x41921062), SkBits2Float(0x425aa6e8), SkBits2Float(0x4193872b), SkBits2Float(0x425bd1ea), SkBits2Float(0x41947ae1), SkBits2Float(0x425c77cd)); // 18.258f, 54.663f, 18.441f, 54.955f, 18.56f, 55.117f
5839path.cubicTo(SkBits2Float(0x4195dd2f), SkBits2Float(0x425d6b83), SkBits2Float(0x4197ae14), SkBits2Float(0x425e1caa), SkBits2Float(0x419924dd), SkBits2Float(0x425ef9d9)); // 18.733f, 55.355f, 18.96f, 55.528f, 19.143f, 55.744f
5840path.cubicTo(SkBits2Float(0x419a1893), SkBits2Float(0x425f9479), SkBits2Float(0x419adf3b), SkBits2Float(0x42601997), SkBits2Float(0x419bd2f1), SkBits2Float(0x42609db0)); // 19.262f, 55.895f, 19.359f, 56.025f, 19.478f, 56.154f
5841path.cubicTo(SkBits2Float(0x419c147a), SkBits2Float(0x4260c9b8), SkBits2Float(0x419c8312), SkBits2Float(0x4260e03f), SkBits2Float(0x419cb020), SkBits2Float(0x42610104)); // 19.51f, 56.197f, 19.564f, 56.219f, 19.586f, 56.251f
5842path.cubicTo(SkBits2Float(0x419d0830), SkBits2Float(0x42613850), SkBits2Float(0x419da3d6), SkBits2Float(0x4261bd6e), SkBits2Float(0x419e126e), SkBits2Float(0x4261d2f0)); // 19.629f, 56.305f, 19.705f, 56.435f, 19.759f, 56.456f
5843path.lineTo(SkBits2Float(0x419e28f5), SkBits2Float(0x4261d2f0)); // 19.77f, 56.456f
5844path.lineTo(SkBits2Float(0x419e28f5), SkBits2Float(0x4261f4bb)); // 19.77f, 56.489f
5845path.cubicTo(SkBits2Float(0x419e3d70), SkBits2Float(0x4261fef8), SkBits2Float(0x419e53f7), SkBits2Float(0x4261f4bb), SkBits2Float(0x419e8105), SkBits2Float(0x4261fef8)); // 19.78f, 56.499f, 19.791f, 56.489f, 19.813f, 56.499f
5846path.cubicTo(SkBits2Float(0x419eac07), SkBits2Float(0x426220c3), SkBits2Float(0x419eac07), SkBits2Float(0x42624187), SkBits2Float(0x419eef9d), SkBits2Float(0x4262580f)); // 19.834f, 56.532f, 19.834f, 56.564f, 19.867f, 56.586f
5847path.cubicTo(SkBits2Float(0x419fe353), SkBits2Float(0x4262f2af), SkBits2Float(0x41a0eb84), SkBits2Float(0x426377cd), SkBits2Float(0x41a1b22c), SkBits2Float(0x4263fbe6)); // 19.986f, 56.737f, 20.115f, 56.867f, 20.212f, 56.996f
5848path.cubicTo(SkBits2Float(0x41a20a3c), SkBits2Float(0x42641db1), SkBits2Float(0x41a2e76b), SkBits2Float(0x4264a1c9), SkBits2Float(0x41a34188), SkBits2Float(0x4264ad0d)); // 20.255f, 57.029f, 20.363f, 57.158f, 20.407f, 57.169f
5849path.cubicTo(SkBits2Float(0x41a36c8a), SkBits2Float(0x4264ad0d), SkBits2Float(0x41a3c6a7), SkBits2Float(0x4264a1c9), SkBits2Float(0x41a3f1a9), SkBits2Float(0x4264ad0d)); // 20.428f, 57.169f, 20.472f, 57.158f, 20.493f, 57.169f
5850path.cubicTo(SkBits2Float(0x41a3f1a9), SkBits2Float(0x42648c48), SkBits2Float(0x41a41eb7), SkBits2Float(0x42648105), SkBits2Float(0x41a449b9), SkBits2Float(0x426475c1)); // 20.493f, 57.137f, 20.515f, 57.126f, 20.536f, 57.115f
5851path.cubicTo(SkBits2Float(0x41a48d4f), SkBits2Float(0x4263f1a8), SkBits2Float(0x41a46040), SkBits2Float(0x42634082), SkBits2Float(0x41a48d4f), SkBits2Float(0x4262bb63)); // 20.569f, 56.986f, 20.547f, 56.813f, 20.569f, 56.683f
5852path.cubicTo(SkBits2Float(0x41a51061), SkBits2Float(0x426122d0), SkBits2Float(0x41a63126), SkBits2Float(0x425f51ea), SkBits2Float(0x41a82d0d), SkBits2Float(0x425e0624)); // 20.633f, 56.284f, 20.774f, 55.83f, 21.022f, 55.506f
5853path.cubicTo(SkBits2Float(0x41a90a3c), SkBits2Float(0x425d820b), SkBits2Float(0x41aab01f), SkBits2Float(0x425cba5d), SkBits2Float(0x41ab0830), SkBits2Float(0x425c147a)); // 21.13f, 55.377f, 21.336f, 55.182f, 21.379f, 55.02f
5854path.cubicTo(SkBits2Float(0x41aa147a), SkBits2Float(0x425bf3b5), SkBits2Float(0x41a8df3a), SkBits2Float(0x425c0936), SkBits2Float(0x41a7d4fd), SkBits2Float(0x425c147a)); // 21.26f, 54.988f, 21.109f, 55.009f, 20.979f, 55.02f
5855path.cubicTo(SkBits2Float(0x41a74fde), SkBits2Float(0x425c147a), SkBits2Float(0x41a65e34), SkBits2Float(0x425c4082), SkBits2Float(0x41a5c28e), SkBits2Float(0x425c4082)); // 20.914f, 55.02f, 20.796f, 55.063f, 20.72f, 55.063f
5856path.cubicTo(SkBits2Float(0x41a56a7e), SkBits2Float(0x425c353e), SkBits2Float(0x41a4fbe6), SkBits2Float(0x425c147a), SkBits2Float(0x41a4ced8), SkBits2Float(0x425c0936)); // 20.677f, 55.052f, 20.623f, 55.02f, 20.601f, 55.009f
5857path.cubicTo(SkBits2Float(0x41a53d70), SkBits2Float(0x425af4bb), SkBits2Float(0x41a5ed90), SkBits2Float(0x425abd6f), SkBits2Float(0x41a85a1c), SkBits2Float(0x425aa6e8)); // 20.655f, 54.739f, 20.741f, 54.685f, 21.044f, 54.663f
5858path.cubicTo(SkBits2Float(0x41a920c4), SkBits2Float(0x425a9cab), SkBits2Float(0x41a9d0e5), SkBits2Float(0x425aa6e8), SkBits2Float(0x41aa5603), SkBits2Float(0x425a9167)); // 21.141f, 54.653f, 21.227f, 54.663f, 21.292f, 54.642f
5859path.cubicTo(SkBits2Float(0x41aa8311), SkBits2Float(0x425a8623), SkBits2Float(0x41aa9999), SkBits2Float(0x425a655f), SkBits2Float(0x41aab020), SkBits2Float(0x425a655f)); // 21.314f, 54.631f, 21.325f, 54.599f, 21.336f, 54.599f
5860path.cubicTo(SkBits2Float(0x41aa3f7c), SkBits2Float(0x42599eb7), SkBits2Float(0x41a9a5e3), SkBits2Float(0x42591998), SkBits2Float(0x41a9374b), SkBits2Float(0x42586871)); // 21.281f, 54.405f, 21.206f, 54.275f, 21.152f, 54.102f
5861path.cubicTo(SkBits2Float(0x41a8c8b3), SkBits2Float(0x4257e458), SkBits2Float(0x41a8b22c), SkBits2Float(0x42575f3a), SkBits2Float(0x41a85a1c), SkBits2Float(0x4256c49a)); // 21.098f, 53.973f, 21.087f, 53.843f, 21.044f, 53.692f
5862path.cubicTo(SkBits2Float(0x41a76666), SkBits2Float(0x42551479), SkBits2Float(0x41a68937), SkBits2Float(0x4252cabf), SkBits2Float(0x41a74fdf), SkBits2Float(0x4250a1c9)); // 20.925f, 53.27f, 20.817f, 52.698f, 20.914f, 52.158f
5863path.cubicTo(SkBits2Float(0x41a77ced), SkBits2Float(0x42500729), SkBits2Float(0x41a870a4), SkBits2Float(0x424e8417), SkBits2Float(0x41a8b22d), SkBits2Float(0x424e4ccb)); // 20.936f, 52.007f, 21.055f, 51.629f, 21.087f, 51.575f
5864path.cubicTo(SkBits2Float(0x41a8b22d), SkBits2Float(0x424e4187), SkBits2Float(0x41aa147b), SkBits2Float(0x424cc9b9), SkBits2Float(0x41aab021), SkBits2Float(0x424c2f19)); // 21.087f, 51.564f, 21.26f, 51.197f, 21.336f, 51.046f
5865path.cubicTo(SkBits2Float(0x41aac49c), SkBits2Float(0x424c1892), SkBits2Float(0x41ab49bb), SkBits2Float(0x424b9eb7), SkBits2Float(0x41ab8b44), SkBits2Float(0x424b676b)); // 21.346f, 51.024f, 21.411f, 50.905f, 21.443f, 50.851f
5866path.cubicTo(SkBits2Float(0x41ac3d71), SkBits2Float(0x424ab644), SkBits2Float(0x41ad45a2), SkBits2Float(0x424a26e8), SkBits2Float(0x41ae22d1), SkBits2Float(0x42498105)); // 21.53f, 50.678f, 21.659f, 50.538f, 21.767f, 50.376f
5867path.cubicTo(SkBits2Float(0x41ae6667), SkBits2Float(0x42496b84), SkBits2Float(0x41aeeb85), SkBits2Float(0x42491db1), SkBits2Float(0x41af0000), SkBits2Float(0x4248fbe6)); // 21.8f, 50.355f, 21.865f, 50.279f, 21.875f, 50.246f
5868path.cubicTo(SkBits2Float(0x41b0624e), SkBits2Float(0x4248353e), SkBits2Float(0x41b1db23), SkBits2Float(0x424779da), SkBits2Float(0x41b353f8), SkBits2Float(0x4246bd6f)); // 22.048f, 50.052f, 22.232f, 49.869f, 22.416f, 49.685f
5869path.cubicTo(SkBits2Float(0x41b3c083), SkBits2Float(0x42468623), SkBits2Float(0x41b445a2), SkBits2Float(0x42464ed7), SkBits2Float(0x41b4cac1), SkBits2Float(0x4246178c)); // 22.469f, 49.631f, 22.534f, 49.577f, 22.599f, 49.523f
5870path.cubicTo(SkBits2Float(0x41b56667), SkBits2Float(0x4245c9b9), SkBits2Float(0x41b62d0f), SkBits2Float(0x4245872a), SkBits2Float(0x41b6c8b5), SkBits2Float(0x4245449a)); // 22.675f, 49.447f, 22.772f, 49.382f, 22.848f, 49.317f
5871path.cubicTo(SkBits2Float(0x41b7624f), SkBits2Float(0x42450311), SkBits2Float(0x41b7e76d), SkBits2Float(0x4244a9fa), SkBits2Float(0x41b88313), SkBits2Float(0x42445d2d)); // 22.923f, 49.253f, 22.988f, 49.166f, 23.064f, 49.091f
5872path.cubicTo(SkBits2Float(0x41b949bb), SkBits2Float(0x4243ee95), SkBits2Float(0x41ba1063), SkBits2Float(0x424374ba), SkBits2Float(0x41baed92), SkBits2Float(0x42431166)); // 23.161f, 48.983f, 23.258f, 48.864f, 23.366f, 48.767f
5873path.cubicTo(SkBits2Float(0x41bb45a2), SkBits2Float(0x4242c393), SkBits2Float(0x41bbb43a), SkBits2Float(0x424276c6), SkBits2Float(0x41bc0e57), SkBits2Float(0x424228f3)); // 23.409f, 48.691f, 23.463f, 48.616f, 23.507f, 48.54f
5874path.cubicTo(SkBits2Float(0x41bc6667), SkBits2Float(0x4241e664), SkBits2Float(0x41bc7ae2), SkBits2Float(0x4241a4da), SkBits2Float(0x41bcd2f3), SkBits2Float(0x4241624b)); // 23.55f, 48.475f, 23.56f, 48.411f, 23.603f, 48.346f
5875path.cubicTo(SkBits2Float(0x41bd0001), SkBits2Float(0x42411478), SkBits2Float(0x41bd0001), SkBits2Float(0x4240c6a5), SkBits2Float(0x41bd1689), SkBits2Float(0x4240851c)); // 23.625f, 48.27f, 23.625f, 48.194f, 23.636f, 48.13f
5876path.cubicTo(SkBits2Float(0x41bd2d10), SkBits2Float(0x42404cca), SkBits2Float(0x41bdb023), SkBits2Float(0x423fd3f5), SkBits2Float(0x41bd8521), SkBits2Float(0x423f7adf)); // 23.647f, 48.075f, 23.711f, 47.957f, 23.69f, 47.87f
5877path.lineTo(SkBits2Float(0x41bd6e9a), SkBits2Float(0x423f7adf)); // 23.679f, 47.87f
5878path.cubicTo(SkBits2Float(0x41bd6e9a), SkBits2Float(0x423f7adf), SkBits2Float(0x41bd5813), SkBits2Float(0x423f4ed7), SkBits2Float(0x41bd168a), SkBits2Float(0x423f4499)); // 23.679f, 47.87f, 23.668f, 47.827f, 23.636f, 47.817f
5879path.cubicTo(SkBits2Float(0x41bc916b), SkBits2Float(0x423f22ce), SkBits2Float(0x41bc22d4), SkBits2Float(0x423f3955), SkBits2Float(0x41bb893a), SkBits2Float(0x423f178b)); // 23.571f, 47.784f, 23.517f, 47.806f, 23.442f, 47.773f
5880path.cubicTo(SkBits2Float(0x41bb2f1d), SkBits2Float(0x423f0c47), SkBits2Float(0x41bb041b), SkBits2Float(0x423ee03f), SkBits2Float(0x41baac0b), SkBits2Float(0x423ec9b8)); // 23.398f, 47.762f, 23.377f, 47.719f, 23.334f, 47.697f
5881path.cubicTo(SkBits2Float(0x41baac0b), SkBits2Float(0x423ebf7b), SkBits2Float(0x41bac086), SkBits2Float(0x423ea8f3), SkBits2Float(0x41bac086), SkBits2Float(0x423e926c)); // 23.334f, 47.687f, 23.344f, 47.665f, 23.344f, 47.643f
5882path.cubicTo(SkBits2Float(0x41bb2f1e), SkBits2Float(0x423e882f), SkBits2Float(0x41bc0e59), SkBits2Float(0x423e6664), SkBits2Float(0x41bc916b), SkBits2Float(0x423e5c26)); // 23.398f, 47.633f, 23.507f, 47.6f, 23.571f, 47.59f
5883path.cubicTo(SkBits2Float(0x41be4bc9), SkBits2Float(0x423e50e2), SkBits2Float(0x41c53542), SkBits2Float(0x423e926c), SkBits2Float(0x41c5ba61), SkBits2Float(0x423e24da)); // 23.787f, 47.579f, 24.651f, 47.643f, 24.716f, 47.536f
5884path.cubicTo(SkBits2Float(0x41c61271), SkBits2Float(0x423de24b), SkBits2Float(0x41c61271), SkBits2Float(0x423d1a9d), SkBits2Float(0x41c63f80), SkBits2Float(0x423ca1c8)); // 24.759f, 47.471f, 24.759f, 47.276f, 24.781f, 47.158f
5885path.cubicTo(SkBits2Float(0x41c68109), SkBits2Float(0x423bda1a), SkBits2Float(0x41c6ae18), SkBits2Float(0x423afceb), SkBits2Float(0x41c70628), SkBits2Float(0x423a2aff)); // 24.813f, 46.963f, 24.835f, 46.747f, 24.878f, 46.542f
5886path.cubicTo(SkBits2Float(0x41c71caf), SkBits2Float(0x42399ba3), SkBits2Float(0x41c81065), SkBits2Float(0x42379eb5), SkBits2Float(0x41c79fc2), SkBits2Float(0x4237459f)); // 24.889f, 46.402f, 25.008f, 45.905f, 24.953f, 45.818f
5887path.cubicTo(SkBits2Float(0x41c70628), SkBits2Float(0x4236e24b), SkBits2Float(0x41c4dd33), SkBits2Float(0x4237459f), SkBits2Float(0x41c45814), SkBits2Float(0x423750e3)); // 24.878f, 45.721f, 24.608f, 45.818f, 24.543f, 45.829f
5888path.cubicTo(SkBits2Float(0x41c245a5), SkBits2Float(0x42379eb6), SkBits2Float(0x41bea5e7), SkBits2Float(0x42380d4d), SkBits2Float(0x41bbf5c6), SkBits2Float(0x4237ec89)); // 24.284f, 45.905f, 23.831f, 46.013f, 23.495f, 45.981f
5889path.cubicTo(SkBits2Float(0x41b9f9df), SkBits2Float(0x4237e145), SkBits2Float(0x41b7e770), SkBits2Float(0x4237a9fa), SkBits2Float(0x41b62d12), SkBits2Float(0x4237676a)); // 23.247f, 45.97f, 22.988f, 45.916f, 22.772f, 45.851f
5890path.cubicTo(SkBits2Float(0x41b4312b), SkBits2Float(0x423724db), SkBits2Float(0x41b1f1ae), SkBits2Float(0x42369fbc), SkBits2Float(0x41af9baa), SkBits2Float(0x423673b4)); // 22.524f, 45.786f, 22.243f, 45.656f, 21.951f, 45.613f
5891path.cubicTo(SkBits2Float(0x41ae7ae5), SkBits2Float(0x42366977), SkBits2Float(0x41aced96), SkBits2Float(0x42365d2d), SkBits2Float(0x41ab8b48), SkBits2Float(0x42366977)); // 21.81f, 45.603f, 21.616f, 45.591f, 21.443f, 45.603f
5892path.cubicTo(SkBits2Float(0x41a9e771), SkBits2Float(0x42368a3c), SkBits2Float(0x41a82d13), SkBits2Float(0x4236d708), SkBits2Float(0x41a65e3a), SkBits2Float(0x4236b644)); // 21.238f, 45.635f, 21.022f, 45.71f, 20.796f, 45.678f
5893path.cubicTo(SkBits2Float(0x41a65e3a), SkBits2Float(0x4236ab00), SkBits2Float(0x41a647b3), SkBits2Float(0x42369fbd), SkBits2Float(0x41a65e3a), SkBits2Float(0x42369479)); // 20.796f, 45.667f, 20.785f, 45.656f, 20.796f, 45.645f
5894path.cubicTo(SkBits2Float(0x41a672b5), SkBits2Float(0x42366977), SkBits2Float(0x41a7a7f4), SkBits2Float(0x42363125), SkBits2Float(0x41a81898), SkBits2Float(0x42361ba4)); // 20.806f, 45.603f, 20.957f, 45.548f, 21.012f, 45.527f
5895path.cubicTo(SkBits2Float(0x41a85a21), SkBits2Float(0x42361060), SkBits2Float(0x41a8df40), SkBits2Float(0x4235d915), SkBits2Float(0x41a94dd7), SkBits2Float(0x4235cdd1)); // 21.044f, 45.516f, 21.109f, 45.462f, 21.163f, 45.451f
5896path.cubicTo(SkBits2Float(0x41ab8b48), SkBits2Float(0x42356a7d), SkBits2Float(0x41af8523), SkBits2Float(0x423575c1), SkBits2Float(0x41b249be), SkBits2Float(0x42359685)); // 21.443f, 45.354f, 21.94f, 45.365f, 22.286f, 45.397f
5897path.cubicTo(SkBits2Float(0x41b3d70e), SkBits2Float(0x4235a1c9), SkBits2Float(0x41b6168b), SkBits2Float(0x4235cdd1), SkBits2Float(0x41b7e770), SkBits2Float(0x4235ad0c)); // 22.48f, 45.408f, 22.761f, 45.451f, 22.988f, 45.419f
5898path.cubicTo(SkBits2Float(0x41bac087), SkBits2Float(0x42359685), SkBits2Float(0x41bd6e9b), SkBits2Float(0x4234fbe5), SkBits2Float(0x41c03337), SkBits2Float(0x4234af18)); // 23.344f, 45.397f, 23.679f, 45.246f, 24.025f, 45.171f
5899path.cubicTo(SkBits2Float(0x41c2cac4), SkBits2Float(0x42346145), SkBits2Float(0x41c56252), SkBits2Float(0x4234820a), SkBits2Float(0x41c81066), SkBits2Float(0x42346145)); // 24.349f, 45.095f, 24.673f, 45.127f, 25.008f, 45.095f
5900path.cubicTo(SkBits2Float(0x41c824e1), SkBits2Float(0x42340935), SkBits2Float(0x41c89378), SkBits2Float(0x42330a3b), SkBits2Float(0x41c7b649), SkBits2Float(0x4232fef7)); // 25.018f, 45.009f, 25.072f, 44.76f, 24.964f, 44.749f
5901path.cubicTo(SkBits2Float(0x41c6d91a), SkBits2Float(0x4232e976), SkBits2Float(0x41c5a3da), SkBits2Float(0x42338416), SkBits2Float(0x41c51ebc), SkBits2Float(0x4233a4da)); // 24.856f, 44.728f, 24.705f, 44.879f, 24.64f, 44.911f
5902path.cubicTo(SkBits2Float(0x41c42b06), SkBits2Float(0x4233bb61), SkBits2Float(0x41c2cac4), SkBits2Float(0x4233d0e2), SkBits2Float(0x41c1d70e), SkBits2Float(0x4233e769)); // 24.521f, 44.933f, 24.349f, 44.954f, 24.23f, 44.976f
5903path.cubicTo(SkBits2Float(0x41c08b47), SkBits2Float(0x4233f2ad), SkBits2Float(0x41bf1272), SkBits2Float(0x4233c6a4), SkBits2Float(0x41bdf3ba), SkBits2Float(0x4233bb61)); // 24.068f, 44.987f, 23.884f, 44.944f, 23.744f, 44.933f
5904path.cubicTo(SkBits2Float(0x41bcd2f5), SkBits2Float(0x4233b01d), SkBits2Float(0x41bbf5c6), SkBits2Float(0x4233b01d), SkBits2Float(0x41baed95), SkBits2Float(0x4233a4da)); // 23.603f, 44.922f, 23.495f, 44.922f, 23.366f, 44.911f
5905path.cubicTo(SkBits2Float(0x41ba26ed), SkBits2Float(0x42338f59), SkBits2Float(0x41b91cb0), SkBits2Float(0x4233580d), SkBits2Float(0x41b83f81), SkBits2Float(0x4233580d)); // 23.269f, 44.89f, 23.139f, 44.836f, 23.031f, 44.836f
5906path.cubicTo(SkBits2Float(0x41b4b43d), SkBits2Float(0x42333642), SkBits2Float(0x41b19791), SkBits2Float(0x4233a4da), SkBits2Float(0x41aea7f4), SkBits2Float(0x4233d0e2)); // 22.588f, 44.803f, 22.199f, 44.911f, 21.832f, 44.954f
5907path.cubicTo(SkBits2Float(0x41aba1cf), SkBits2Float(0x42340934), SkBits2Float(0x41a7666b), SkBits2Float(0x4233e769), SkBits2Float(0x41a4b856), SkBits2Float(0x42338415)); // 21.454f, 45.009f, 20.925f, 44.976f, 20.59f, 44.879f
5908path.cubicTo(SkBits2Float(0x41a46046), SkBits2Float(0x423378d1), SkBits2Float(0x41a3f1ae), SkBits2Float(0x4233580d), SkBits2Float(0x41a3c6ac), SkBits2Float(0x42334cc9)); // 20.547f, 44.868f, 20.493f, 44.836f, 20.472f, 44.825f
5909path.cubicTo(SkBits2Float(0x41a28f60), SkBits2Float(0x4233157d), SkBits2Float(0x41a19db6), SkBits2Float(0x42330a3a), SkBits2Float(0x41a0c087), SkBits2Float(0x4232c7aa)); // 20.32f, 44.771f, 20.202f, 44.76f, 20.094f, 44.695f
5910path.cubicTo(SkBits2Float(0x41a0eb89), SkBits2Float(0x4232bc66), SkBits2Float(0x41a0eb89), SkBits2Float(0x4232905e), SkBits2Float(0x41a10210), SkBits2Float(0x4232905e)); // 20.115f, 44.684f, 20.115f, 44.641f, 20.126f, 44.641f
5911path.cubicTo(SkBits2Float(0x41a19db6), SkBits2Float(0x42325912), SkBits2Float(0x41a2645e), SkBits2Float(0x42326f99), SkBits2Float(0x41a35608), SkBits2Float(0x42326f99)); // 20.202f, 44.587f, 20.299f, 44.609f, 20.417f, 44.609f
5912path.cubicTo(SkBits2Float(0x41a476cd), SkBits2Float(0x42324ed4), SkBits2Float(0x41a5ed95), SkBits2Float(0x4232384d), SkBits2Float(0x41a724e1), SkBits2Float(0x42320c45)); // 20.558f, 44.577f, 20.741f, 44.555f, 20.893f, 44.512f
5913path.cubicTo(SkBits2Float(0x41a8c8b8), SkBits2Float(0x4231c9b6), SkBits2Float(0x41aa999d), SkBits2Float(0x42316662), SkBits2Float(0x41ac26ed), SkBits2Float(0x4231188f)); // 21.098f, 44.447f, 21.325f, 44.35f, 21.519f, 44.274f
5914path.cubicTo(SkBits2Float(0x41af168b), SkBits2Float(0x423072ac), SkBits2Float(0x41b249be), SkBits2Float(0x42300f58), SkBits2Float(0x41b57ae5), SkBits2Float(0x422fe249)); // 21.886f, 44.112f, 22.286f, 44.015f, 22.685f, 43.971f
5915path.cubicTo(SkBits2Float(0x41b66e9b), SkBits2Float(0x422fd80c), SkBits2Float(0x41b7d0e9), SkBits2Float(0x422fee93), SkBits2Float(0x41b89791), SkBits2Float(0x422fee93)); // 22.804f, 43.961f, 22.977f, 43.983f, 23.074f, 43.983f
5916path.cubicTo(SkBits2Float(0x41bb1897), SkBits2Float(0x42300f58), SkBits2Float(0x41bd2d12), SkBits2Float(0x423024d9), SkBits2Float(0x41bfc49f), SkBits2Float(0x4230301c)); // 23.387f, 44.015f, 23.647f, 44.036f, 23.971f, 44.047f
5917path.cubicTo(SkBits2Float(0x41c0e357), SkBits2Float(0x423046a3), SkBits2Float(0x41c245a5), SkBits2Float(0x42305c24), SkBits2Float(0x41c3a7f3), SkBits2Float(0x423051e7)); // 24.111f, 44.069f, 24.284f, 44.09f, 24.457f, 44.08f
5918path.cubicTo(SkBits2Float(0x41c50835), SkBits2Float(0x423046a3), SkBits2Float(0x41c69791), SkBits2Float(0x42300f58), SkBits2Float(0x41c79fc2), SkBits2Float(0x422fb641)); // 24.629f, 44.069f, 24.824f, 44.015f, 24.953f, 43.928f
5919path.cubicTo(SkBits2Float(0x41c7f9df), SkBits2Float(0x422fa0c0), SkBits2Float(0x41c86876), SkBits2Float(0x422f5e31), SkBits2Float(0x41c8eb89), SkBits2Float(0x422f52ed)); // 24.997f, 43.907f, 25.051f, 43.842f, 25.115f, 43.831f
5920path.cubicTo(SkBits2Float(0x41c9b43d), SkBits2Float(0x422f3c66), SkBits2Float(0x41c9df3f), SkBits2Float(0x422fb641), SkBits2Float(0x41c9f5c6), SkBits2Float(0x42300f57)); // 25.213f, 43.809f, 25.234f, 43.928f, 25.245f, 44.015f
5921path.cubicTo(SkBits2Float(0x41ca0c4d), SkBits2Float(0x4230e143), SkBits2Float(0x41c9df3f), SkBits2Float(0x42319ca7), SkBits2Float(0x41c9f5c6), SkBits2Float(0x4232384d)); // 25.256f, 44.22f, 25.234f, 44.403f, 25.245f, 44.555f
5922path.cubicTo(SkBits2Float(0x41ca395c), SkBits2Float(0x4234fbe2), SkBits2Float(0x41ca22d4), SkBits2Float(0x4237cabc), SkBits2Float(0x41ca7ae5), SkBits2Float(0x423a6d8c)); // 25.278f, 45.246f, 25.267f, 45.948f, 25.31f, 46.607f
5923path.cubicTo(SkBits2Float(0x41ca916c), SkBits2Float(0x423b3f78), SkBits2Float(0x41ca645e), SkBits2Float(0x423ca1c5), SkBits2Float(0x41ca916c), SkBits2Float(0x423d9475)); // 25.321f, 46.812f, 25.299f, 47.158f, 25.321f, 47.395f
5924path.cubicTo(SkBits2Float(0x41ca916c), SkBits2Float(0x423daafc), SkBits2Float(0x41ca7ae5), SkBits2Float(0x423dd704), SkBits2Float(0x41ca916c), SkBits2Float(0x423dec85)); // 25.321f, 47.417f, 25.31f, 47.46f, 25.321f, 47.481f
5925path.cubicTo(SkBits2Float(0x41caa5e7), SkBits2Float(0x423e0e50), SkBits2Float(0x41cb0004), SkBits2Float(0x423e459c), SkBits2Float(0x41cb2b06), SkBits2Float(0x423e50df)); // 25.331f, 47.514f, 25.375f, 47.568f, 25.396f, 47.579f
5926path.cubicTo(SkBits2Float(0x41cb6e9c), SkBits2Float(0x423e5c23), SkBits2Float(0x41ce47b2), SkBits2Float(0x423e7ce7), SkBits2Float(0x41ce8b48), SkBits2Float(0x423e6660)); // 25.429f, 47.59f, 25.785f, 47.622f, 25.818f, 47.6f
5927path.lineTo(SkBits2Float(0x41ceb64a), SkBits2Float(0x423e5c23)); // 25.839f, 47.59f
5928path.cubicTo(SkBits2Float(0x41d1395c), SkBits2Float(0x423e5c23), SkBits2Float(0x41d41273), SkBits2Float(0x423e50df), SkBits2Float(0x41d6666b), SkBits2Float(0x423e6660)); // 26.153f, 47.59f, 26.509f, 47.579f, 26.8f, 47.6f
5929path.cubicTo(SkBits2Float(0x41d71898), SkBits2Float(0x423e7ce7), SkBits2Float(0x41d80a42), SkBits2Float(0x423e5c23), SkBits2Float(0x41d8a5e8), SkBits2Float(0x423e7ce7)); // 26.887f, 47.622f, 27.005f, 47.59f, 27.081f, 47.622f
5930path.cubicTo(SkBits2Float(0x41d8d2f6), SkBits2Float(0x423e882b), SkBits2Float(0x41d8d2f6), SkBits2Float(0x423e9268), SkBits2Float(0x41d8fdf8), SkBits2Float(0x423e9eb2)); // 27.103f, 47.633f, 27.103f, 47.643f, 27.124f, 47.655f
5931path.cubicTo(SkBits2Float(0x41d8e771), SkBits2Float(0x423ebf77), SkBits2Float(0x41d8fdf8), SkBits2Float(0x423ed4f8), SkBits2Float(0x41d8e771), SkBits2Float(0x423eeb7f)); // 27.113f, 47.687f, 27.124f, 47.708f, 27.113f, 47.73f
5932path.cubicTo(SkBits2Float(0x41d88f61), SkBits2Float(0x423f4496), SkBits2Float(0x41d71898), SkBits2Float(0x423f4496), SkBits2Float(0x41d6aa00), SkBits2Float(0x423f9162)); // 27.07f, 47.817f, 26.887f, 47.817f, 26.833f, 47.892f
5933path.cubicTo(SkBits2Float(0x41d547b2), SkBits2Float(0x42406e91), SkBits2Float(0x41d43d75), SkBits2Float(0x4241ba58), SkBits2Float(0x41d38d54), SkBits2Float(0x4242b952)); // 26.66f, 48.108f, 26.53f, 48.432f, 26.444f, 48.681f
5934path.cubicTo(SkBits2Float(0x41d1395c), SkBits2Float(0x4245a8f0), SkBits2Float(0x41d0b231), SkBits2Float(0x42491dac), SkBits2Float(0x41d2147f), SkBits2Float(0x424c2f15)); // 26.153f, 49.415f, 26.087f, 50.279f, 26.26f, 51.046f
5935path.cubicTo(SkBits2Float(0x41d2418d), SkBits2Float(0x424c7be2), SkBits2Float(0x41d2999e), SkBits2Float(0x424cc9b5), SkBits2Float(0x41d2b025), SkBits2Float(0x424d0c44)); // 26.282f, 51.121f, 26.325f, 51.197f, 26.336f, 51.262f
5936path.cubicTo(SkBits2Float(0x41d33544), SkBits2Float(0x424dc7a8), SkBits2Float(0x41d3a3db), SkBits2Float(0x424e8413), SkBits2Float(0x41d453fc), SkBits2Float(0x424f136f)); // 26.401f, 51.445f, 26.455f, 51.629f, 26.541f, 51.769f
5937path.cubicTo(SkBits2Float(0x41d453fc), SkBits2Float(0x424f136f), SkBits2Float(0x41d59fc3), SkBits2Float(0x42506a79), SkBits2Float(0x41d6c087), SkBits2Float(0x4250e454)); // 26.541f, 51.769f, 26.703f, 52.104f, 26.844f, 52.223f
5938path.cubicTo(SkBits2Float(0x41d6c087), SkBits2Float(0x4250ef98), SkBits2Float(0x41d6eb89), SkBits2Float(0x4251105c), SkBits2Float(0x41d70210), SkBits2Float(0x4251105c)); // 26.844f, 52.234f, 26.865f, 52.266f, 26.876f, 52.266f
5939path.cubicTo(SkBits2Float(0x41d71897), SkBits2Float(0x42511ba0), SkBits2Float(0x41d75a20), SkBits2Float(0x4251105c), SkBits2Float(0x41d7872f), SkBits2Float(0x4251105c)); // 26.887f, 52.277f, 26.919f, 52.266f, 26.941f, 52.266f
5940path.cubicTo(SkBits2Float(0x41d87ae5), SkBits2Float(0x42501ca6), SkBits2Float(0x41d9147f), SkBits2Float(0x424f136e), SkBits2Float(0x41da0835), SkBits2Float(0x424e157b)); // 27.06f, 52.028f, 27.135f, 51.769f, 27.254f, 51.521f
5941path.cubicTo(SkBits2Float(0x41da1ebc), SkBits2Float(0x424df4b6), SkBits2Float(0x41db1066), SkBits2Float(0x424d0c44), SkBits2Float(0x41db1066), SkBits2Float(0x424d0100)); // 27.265f, 51.489f, 27.383f, 51.262f, 27.383f, 51.251f
5942path.cubicTo(SkBits2Float(0x41db3d74), SkBits2Float(0x424cc9b4), SkBits2Float(0x41db9585), SkBits2Float(0x424c8725), SkBits2Float(0x41dbd91a), SkBits2Float(0x424c5b1d)); // 27.405f, 51.197f, 27.448f, 51.132f, 27.481f, 51.089f
5943path.cubicTo(SkBits2Float(0x41dc5e39), SkBits2Float(0x424bcbc1), SkBits2Float(0x41dcf7d2), SkBits2Float(0x424b301b), SkBits2Float(0x41dd7cf1), SkBits2Float(0x424aac02)); // 27.546f, 50.949f, 27.621f, 50.797f, 27.686f, 50.668f
5944path.cubicTo(SkBits2Float(0x41ddd501), SkBits2Float(0x424a5e2f), SkBits2Float(0x41ddeb89), SkBits2Float(0x424a105c), SkBits2Float(0x41de4399), SkBits2Float(0x4249b84c)); // 27.729f, 50.592f, 27.74f, 50.516f, 27.783f, 50.43f
5945path.cubicTo(SkBits2Float(0x41de70a7), SkBits2Float(0x4249a1c5), SkBits2Float(0x41def5c6), SkBits2Float(0x42490725), SkBits2Float(0x41df20c8), SkBits2Float(0x4248e660)); // 27.805f, 50.408f, 27.87f, 50.257f, 27.891f, 50.225f
5946path.cubicTo(SkBits2Float(0x41df8f60), SkBits2Float(0x42488206), SkBits2Float(0x41e0c49f), SkBits2Float(0x42474cc6), SkBits2Float(0x41e10835), SkBits2Float(0x42472c02)); // 27.945f, 50.127f, 28.096f, 49.825f, 28.129f, 49.793f
5947path.cubicTo(SkBits2Float(0x41e11ebc), SkBits2Float(0x42472c02), SkBits2Float(0x41e13337), SkBits2Float(0x4246fef4), SkBits2Float(0x41e13337), SkBits2Float(0x4246f4b6)); // 28.14f, 49.793f, 28.15f, 49.749f, 28.15f, 49.739f
5948path.cubicTo(SkBits2Float(0x41e149be), SkBits2Float(0x4246c7a8), SkBits2Float(0x41e226ed), SkBits2Float(0x42461787), SkBits2Float(0x41e253fc), SkBits2Float(0x4245df35)); // 28.161f, 49.695f, 28.269f, 49.523f, 28.291f, 49.468f
5949path.cubicTo(SkBits2Float(0x41e27efe), SkBits2Float(0x4245d3f1), SkBits2Float(0x41e2ac0c), SkBits2Float(0x42459ca6), SkBits2Float(0x41e2ac0c), SkBits2Float(0x42459162)); // 28.312f, 49.457f, 28.334f, 49.403f, 28.334f, 49.392f
5950path.cubicTo(SkBits2Float(0x41e372b4), SkBits2Float(0x4244e141), SkBits2Float(0x41e4666a), SkBits2Float(0x42445c23), SkBits2Float(0x41e4eb89), SkBits2Float(0x42437ef3)); // 28.431f, 49.22f, 28.55f, 49.09f, 28.615f, 48.874f
5951path.cubicTo(SkBits2Float(0x41e4a7f3), SkBits2Float(0x424373af), SkBits2Float(0x41e47ae5), SkBits2Float(0x42435e2e), SkBits2Float(0x41e4666a), SkBits2Float(0x42435e2e)); // 28.582f, 48.863f, 28.56f, 48.842f, 28.55f, 48.842f
5952path.cubicTo(SkBits2Float(0x41e3893b), SkBits2Float(0x42433c63), SkBits2Float(0x41e1fbeb), SkBits2Float(0x4243686b), SkBits2Float(0x41e18b47), SkBits2Float(0x42431b9f)); // 28.442f, 48.809f, 28.248f, 48.852f, 28.193f, 48.777f
5953path.cubicTo(SkBits2Float(0x41e16045), SkBits2Float(0x4242f9d4), SkBits2Float(0x41e18b47), SkBits2Float(0x4242ee91), SkBits2Float(0x41e16045), SkBits2Float(0x4242d910)); // 28.172f, 48.744f, 28.193f, 48.733f, 28.172f, 48.712f
5954path.cubicTo(SkBits2Float(0x41e1a1ce), SkBits2Float(0x4242b84b), SkBits2Float(0x41e1fbeb), SkBits2Float(0x42429681), SkBits2Float(0x41e226ed), SkBits2Float(0x42429681)); // 28.204f, 48.68f, 28.248f, 48.647f, 28.269f, 48.647f
5955path.cubicTo(SkBits2Float(0x41e3cac4), SkBits2Float(0x42425f35), SkBits2Float(0x41e9c087), SkBits2Float(0x4242b84c), SkBits2Float(0x41ea5c2c), SkBits2Float(0x424248ae)); // 28.474f, 48.593f, 29.219f, 48.68f, 29.295f, 48.571f
5956path.cubicTo(SkBits2Float(0x41eacac4), SkBits2Float(0x4241fbe1), SkBits2Float(0x41eacac4), SkBits2Float(0x42414aba), SkBits2Float(0x41eaf7d2), SkBits2Float(0x4240d0df)); // 29.349f, 48.496f, 29.349f, 48.323f, 29.371f, 48.204f
5957path.cubicTo(SkBits2Float(0x41eb395b), SkBits2Float(0x4240580a), SkBits2Float(0x41eba7f3), SkBits2Float(0x423fb121), SkBits2Float(0x41ebd501), SkBits2Float(0x423f21c4)); // 29.403f, 48.086f, 29.457f, 47.923f, 29.479f, 47.783f
5958path.cubicTo(SkBits2Float(0x41ec2d11), SkBits2Float(0x423e4fd8), SkBits2Float(0x41ec5813), SkBits2Float(0x423d936e), SkBits2Float(0x41ecb230), SkBits2Float(0x423cb63f)); // 29.522f, 47.578f, 29.543f, 47.394f, 29.587f, 47.178f
5959path.cubicTo(SkBits2Float(0x41ecc8b7), SkBits2Float(0x423c5e2f), SkBits2Float(0x41edba61), SkBits2Float(0x423b332d), SkBits2Float(0x41ed8f5f), SkBits2Float(0x423ac495)); // 29.598f, 47.092f, 29.716f, 46.8f, 29.695f, 46.692f
5960path.cubicTo(SkBits2Float(0x41ed6251), SkBits2Float(0x423a8d49), SkBits2Float(0x41ec9ba9), SkBits2Float(0x423a407c), SkBits2Float(0x41ec2d11), SkBits2Float(0x423a3539)); // 29.673f, 46.638f, 29.576f, 46.563f, 29.522f, 46.552f
5961path.cubicTo(SkBits2Float(0x41ec0003), SkBits2Float(0x423a29f5), SkBits2Float(0x41ebeb88), SkBits2Float(0x423a3539), SkBits2Float(0x41ebd501), SkBits2Float(0x423a3539)); // 29.5f, 46.541f, 29.49f, 46.552f, 29.479f, 46.552f
5962path.cubicTo(SkBits2Float(0x41eb6669), SkBits2Float(0x423a29f5), SkBits2Float(0x41ea72b3), SkBits2Float(0x4239f2aa), SkBits2Float(0x41e9c086), SkBits2Float(0x423a0931)); // 29.425f, 46.541f, 29.306f, 46.487f, 29.219f, 46.509f
5963path.cubicTo(SkBits2Float(0x41e99584), SkBits2Float(0x423a0931), SkBits2Float(0x41e96876), SkBits2Float(0x423a29f6), SkBits2Float(0x41e953fb), SkBits2Float(0x423a3539)); // 29.198f, 46.509f, 29.176f, 46.541f, 29.166f, 46.552f
5964path.cubicTo(SkBits2Float(0x41e96876), SkBits2Float(0x423a8d49), SkBits2Float(0x41e9c086), SkBits2Float(0x423acfd9), SkBits2Float(0x41e9d70d), SkBits2Float(0x423b28ef)); // 29.176f, 46.638f, 29.219f, 46.703f, 29.23f, 46.79f
5965path.cubicTo(SkBits2Float(0x41ea041b), SkBits2Float(0x423bd910), SkBits2Float(0x41e8fbea), SkBits2Float(0x423c73b0), SkBits2Float(0x41e849bd), SkBits2Float(0x423cac01)); // 29.252f, 46.962f, 29.123f, 47.113f, 29.036f, 47.168f
5966path.cubicTo(SkBits2Float(0x41e75607), SkBits2Float(0x423cf8ce), SkBits2Float(0x41e5f3b9), SkBits2Float(0x423ced8a), SkBits2Float(0x41e4eb88), SkBits2Float(0x423cd809)); // 28.917f, 47.243f, 28.744f, 47.232f, 28.615f, 47.211f
5967path.cubicTo(SkBits2Float(0x41e372b3), SkBits2Float(0x423cb63e), SkBits2Float(0x41e2ac0b), SkBits2Float(0x423c0517), SkBits2Float(0x41e10834), SkBits2Float(0x423c52ea)); // 28.431f, 47.178f, 28.334f, 47.005f, 28.129f, 47.081f
5968path.cubicTo(SkBits2Float(0x41e0db26), SkBits2Float(0x423cd809), SkBits2Float(0x41e0999c), SkBits2Float(0x423d46a0), SkBits2Float(0x41dfd0e8), SkBits2Float(0x423d72a8)); // 28.107f, 47.211f, 28.075f, 47.319f, 27.977f, 47.362f
5969path.cubicTo(SkBits2Float(0x41deb230), SkBits2Float(0x423dcab8), SkBits2Float(0x41dd3b67), SkBits2Float(0x423d8829), SkBits2Float(0x41dc312a), SkBits2Float(0x423d46a0)); // 27.837f, 47.448f, 27.654f, 47.383f, 27.524f, 47.319f
5970path.cubicTo(SkBits2Float(0x41dae563), SkBits2Float(0x423cf8cd), SkBits2Float(0x41d98316), SkBits2Float(0x423cccc5), SkBits2Float(0x41d8645d), SkBits2Float(0x423c6971)); // 27.362f, 47.243f, 27.189f, 47.2f, 27.049f, 47.103f
5971path.cubicTo(SkBits2Float(0x41d7df3e), SkBits2Float(0x423c52ea), SkBits2Float(0x41d72d11), SkBits2Float(0x423c311f), SkBits2Float(0x41d6a9ff), SkBits2Float(0x423c0517)); // 26.984f, 47.081f, 26.897f, 47.048f, 26.833f, 47.005f
5972path.cubicTo(SkBits2Float(0x41d67cf1), SkBits2Float(0x423bfada), SkBits2Float(0x41d572b3), SkBits2Float(0x423b967f), SkBits2Float(0x41d5893a), SkBits2Float(0x423b967f)); // 26.811f, 46.995f, 26.681f, 46.897f, 26.692f, 46.897f
5973path.cubicTo(SkBits2Float(0x41d5893a), SkBits2Float(0x423b967f), SkBits2Float(0x41d5b648), SkBits2Float(0x423b6a77), SkBits2Float(0x41d5ccd0), SkBits2Float(0x423b6a77)); // 26.692f, 46.897f, 26.714f, 46.854f, 26.725f, 46.854f
5974path.cubicTo(SkBits2Float(0x41d6eb88), SkBits2Float(0x423b3e6f), SkBits2Float(0x41d8374f), SkBits2Float(0x423b967f), SkBits2Float(0x41d8fdf7), SkBits2Float(0x423bad06)); // 26.865f, 46.811f, 27.027f, 46.897f, 27.124f, 46.919f
5975path.cubicTo(SkBits2Float(0x41d9c6ab), SkBits2Float(0x423bb84a), SkBits2Float(0x41da49be), SkBits2Float(0x423bb84a), SkBits2Float(0x41db1066), SkBits2Float(0x423bd90e)); // 27.222f, 46.93f, 27.286f, 46.93f, 27.383f, 46.962f
5976path.cubicTo(SkBits2Float(0x41db810a), SkBits2Float(0x423bd90e), SkBits2Float(0x41dc5e39), SkBits2Float(0x423bfad9), SkBits2Float(0x41dcf7d3), SkBits2Float(0x423bef95)); // 27.438f, 46.962f, 27.546f, 46.995f, 27.621f, 46.984f
5977path.cubicTo(SkBits2Float(0x41ddd502), SkBits2Float(0x423bc38d), SkBits2Float(0x41dd4fe3), SkBits2Float(0x423b332b), SkBits2Float(0x41dd7cf2), SkBits2Float(0x423ab94f)); // 27.729f, 46.941f, 27.664f, 46.8f, 27.686f, 46.681f
5978path.cubicTo(SkBits2Float(0x41dda7f4), SkBits2Float(0x423a77c6), SkBits2Float(0x41de2d13), SkBits2Float(0x423a29f3), SkBits2Float(0x41de70a8), SkBits2Float(0x423a136c)); // 27.707f, 46.617f, 27.772f, 46.541f, 27.805f, 46.519f
5979path.cubicTo(SkBits2Float(0x41dfba62), SkBits2Float(0x4239c69f), SkBits2Float(0x41e253fc), SkBits2Float(0x423a092f), SkBits2Float(0x41e372b4), SkBits2Float(0x423a4bbe)); // 27.966f, 46.444f, 28.291f, 46.509f, 28.431f, 46.574f
5980path.cubicTo(SkBits2Float(0x41e40e5a), SkBits2Float(0x423a6c83), SkBits2Float(0x41e49379), SkBits2Float(0x423a8d47), SkBits2Float(0x41e55a21), SkBits2Float(0x423ab94f)); // 28.507f, 46.606f, 28.572f, 46.638f, 28.669f, 46.681f
5981path.lineTo(SkBits2Float(0x41e58523), SkBits2Float(0x423acfd6)); // 28.69f, 46.703f
5982path.cubicTo(SkBits2Float(0x41e5b231), SkBits2Float(0x423acfd6), SkBits2Float(0x41e60a42), SkBits2Float(0x423ac492), SkBits2Float(0x41e66252), SkBits2Float(0x423acfd6)); // 28.712f, 46.703f, 28.755f, 46.692f, 28.798f, 46.703f
5983path.cubicTo(SkBits2Float(0x41e66252), SkBits2Float(0x423ab94f), SkBits2Float(0x41e68f60), SkBits2Float(0x423ab94f), SkBits2Float(0x41e6a5e8), SkBits2Float(0x423aae0b)); // 28.798f, 46.681f, 28.82f, 46.681f, 28.831f, 46.67f
5984path.cubicTo(SkBits2Float(0x41e6fdf8), SkBits2Float(0x423a136b), SkBits2Float(0x41e5dd34), SkBits2Float(0x423978cc), SkBits2Float(0x41e68f61), SkBits2Float(0x4238fef0)); // 28.874f, 46.519f, 28.733f, 46.368f, 28.82f, 46.249f
5985path.cubicTo(SkBits2Float(0x41e72b07), SkBits2Float(0x42389058), SkBits2Float(0x41eaf7d4), SkBits2Float(0x42391577), SkBits2Float(0x41ec5815), SkBits2Float(0x4238f3ac)); // 28.896f, 46.141f, 29.371f, 46.271f, 29.543f, 46.238f
5986path.cubicTo(SkBits2Float(0x41ef1cb1), SkBits2Float(0x4238bd66), SkBits2Float(0x41ed6252), SkBits2Float(0x4237d4f4), SkBits2Float(0x41ede771), SkBits2Float(0x42369eae)); // 29.889f, 46.185f, 29.673f, 45.958f, 29.738f, 45.655f
5987path.cubicTo(SkBits2Float(0x41ee28fa), SkBits2Float(0x423651e1), SkBits2Float(0x41ee8317), SkBits2Float(0x42366868), SkBits2Float(0x41eedb27), SkBits2Float(0x42365c1f)); // 29.77f, 45.58f, 29.814f, 45.602f, 29.857f, 45.59f
5988path.cubicTo(SkBits2Float(0x41ef0629), SkBits2Float(0x4236a9f2), SkBits2Float(0x41ef3337), SkBits2Float(0x42371889), SkBits2Float(0x41ef3337), SkBits2Float(0x42375b19)); // 29.878f, 45.666f, 29.9f, 45.774f, 29.9f, 45.839f
5989path.cubicTo(SkBits2Float(0x41ef49be), SkBits2Float(0x4237e038), SkBits2Float(0x41ef3337), SkBits2Float(0x42386450), SkBits2Float(0x41ef49be), SkBits2Float(0x4238d2e8)); // 29.911f, 45.969f, 29.9f, 46.098f, 29.911f, 46.206f
5990path.cubicTo(SkBits2Float(0x41ef8b47), SkBits2Float(0x42394cc3), SkBits2Float(0x41eff9df), SkBits2Float(0x4239e763), SkBits2Float(0x41f026ed), SkBits2Float(0x423a613e)); // 29.943f, 46.325f, 29.997f, 46.476f, 30.019f, 46.595f
5991path.cubicTo(SkBits2Float(0x41f0ac0c), SkBits2Float(0x423b967d), SkBits2Float(0x41f11897), SkBits2Float(0x423ca0bb), SkBits2Float(0x41f1893b), SkBits2Float(0x423dd5fa)); // 30.084f, 46.897f, 30.137f, 47.157f, 30.192f, 47.459f
5992path.cubicTo(SkBits2Float(0x41f19db6), SkBits2Float(0x423e1889), SkBits2Float(0x41f1f5c6), SkBits2Float(0x423e7bdd), SkBits2Float(0x41f20e5a), SkBits2Float(0x423ebe6d)); // 30.202f, 47.524f, 30.245f, 47.621f, 30.257f, 47.686f
5993path.cubicTo(SkBits2Float(0x41f27ae5), SkBits2Float(0x423f9059), SkBits2Float(0x41f2be7b), SkBits2Float(0x42406d88), SkBits2Float(0x41f3168b), SkBits2Float(0x424128ec)); // 30.31f, 47.891f, 30.343f, 48.107f, 30.386f, 48.29f
5994path.cubicTo(SkBits2Float(0x41f35814), SkBits2Float(0x42418203), SkBits2Float(0x41f35814), SkBits2Float(0x4241e556), SkBits2Float(0x41f38523), SkBits2Float(0x42423329)); // 30.418f, 48.377f, 30.418f, 48.474f, 30.44f, 48.55f
5995path.cubicTo(SkBits2Float(0x41f3b025), SkBits2Float(0x424248aa), SkBits2Float(0x41f420c9), SkBits2Float(0x424275b8), SkBits2Float(0x41f46252), SkBits2Float(0x424280fc)); // 30.461f, 48.571f, 30.516f, 48.615f, 30.548f, 48.626f
5996path.cubicTo(SkBits2Float(0x41f4fdf8), SkBits2Float(0x4242967d), SkBits2Float(0x41f5db27), SkBits2Float(0x424275b8), SkBits2Float(0x41f674c1), SkBits2Float(0x424280fc)); // 30.624f, 48.647f, 30.732f, 48.615f, 30.807f, 48.626f
5997path.cubicTo(SkBits2Float(0x41f8f5c7), SkBits2Float(0x4242967d), SkBits2Float(0x41fc5609), SkBits2Float(0x424280fc), SkBits2Float(0x41feeb8a), SkBits2Float(0x4242a1c1)); // 31.12f, 48.647f, 31.542f, 48.626f, 31.865f, 48.658f
5998path.cubicTo(SkBits2Float(0x41ff45a7), SkBits2Float(0x4242a1c1), SkBits2Float(0x41ffdf40), SkBits2Float(0x424280fc), SkBits2Float(0x4200322f), SkBits2Float(0x4242a1c1)); // 31.909f, 48.658f, 31.984f, 48.626f, 32.049f, 48.658f
5999path.cubicTo(SkBits2Float(0x420048b6), SkBits2Float(0x4242a1c1), SkBits2Float(0x42005e37), SkBits2Float(0x4242c286), SkBits2Float(0x420074be), SkBits2Float(0x4242d90d)); // 32.071f, 48.658f, 32.092f, 48.69f, 32.114f, 48.712f
6000path.cubicTo(SkBits2Float(0x420074be), SkBits2Float(0x4242ee8e), SkBits2Float(0x42008002), SkBits2Float(0x42431b9c), SkBits2Float(0x420074be), SkBits2Float(0x4243311d)); // 32.114f, 48.733f, 32.125f, 48.777f, 32.114f, 48.798f
6001path.lineTo(SkBits2Float(0x420052f3), SkBits2Float(0x42433c61)); // 32.081f, 48.809f
6002path.cubicTo(SkBits2Float(0x42001cad), SkBits2Float(0x42439fb5), SkBits2Float(0x41ff2f1d), SkBits2Float(0x42436869), SkBits2Float(0x41fe7cf0), SkBits2Float(0x4243aaf9)); // 32.028f, 48.906f, 31.898f, 48.852f, 31.811f, 48.917f
6003path.cubicTo(SkBits2Float(0x41fe24e0), SkBits2Float(0x4243cbbe), SkBits2Float(0x41fd3336), SkBits2Float(0x4244cab7), SkBits2Float(0x41fd0627), SkBits2Float(0x42450203)); // 31.768f, 48.949f, 31.65f, 49.198f, 31.628f, 49.252f
6004path.cubicTo(SkBits2Float(0x41fcc291), SkBits2Float(0x4245438c), SkBits2Float(0x41fcc291), SkBits2Float(0x42457bde), SkBits2Float(0x41fcae17), SkBits2Float(0x4245be6d)); // 31.595f, 49.316f, 31.595f, 49.371f, 31.585f, 49.436f
6005path.cubicTo(SkBits2Float(0x41fc9790), SkBits2Float(0x4245fff6), SkBits2Float(0x41fc28f8), SkBits2Float(0x4246634a), SkBits2Float(0x41fc1271), SkBits2Float(0x4246b11d)); // 31.574f, 49.5f, 31.52f, 49.597f, 31.509f, 49.673f
6006path.cubicTo(SkBits2Float(0x41fbba61), SkBits2Float(0x42478e4c), SkBits2Float(0x41fba3d9), SkBits2Float(0x424880fc), SkBits2Float(0x41fbba61), SkBits2Float(0x424974b2)); // 31.466f, 49.889f, 31.455f, 50.126f, 31.466f, 50.364f
6007path.cubicTo(SkBits2Float(0x41fbd0e8), SkBits2Float(0x424a7de9), SkBits2Float(0x41fc8109), SkBits2Float(0x424b5b18), SkBits2Float(0x41fd47b1), SkBits2Float(0x424c4ecf)); // 31.477f, 50.623f, 31.563f, 50.839f, 31.66f, 51.077f
6008path.cubicTo(SkBits2Float(0x41fd8b47), SkBits2Float(0x424c915e), SkBits2Float(0x41fdccd0), SkBits2Float(0x424cde2b), SkBits2Float(0x41fe3b67), SkBits2Float(0x424d167d)); // 31.693f, 51.142f, 31.725f, 51.217f, 31.779f, 51.272f
6009path.cubicTo(SkBits2Float(0x41fe9377), SkBits2Float(0x424d4dc9), SkBits2Float(0x41fec086), SkBits2Float(0x424d8f52), SkBits2Float(0x41ff2f1d), SkBits2Float(0x424dc69e)); // 31.822f, 51.326f, 31.844f, 51.39f, 31.898f, 51.444f
6010path.cubicTo(SkBits2Float(0x41ff70a6), SkBits2Float(0x424df3ac), SkBits2Float(0x41ffdf3e), SkBits2Float(0x424e092d), SkBits2Float(0x42000626), SkBits2Float(0x424e3536)); // 31.93f, 51.488f, 31.984f, 51.509f, 32.006f, 51.552f
6011path.cubicTo(SkBits2Float(0x42003d72), SkBits2Float(0x424e6c82), SkBits2Float(0x4200c18a), SkBits2Float(0x424f3e6d), SkBits2Float(0x4201041a), SkBits2Float(0x424f49b1)); // 32.06f, 51.606f, 32.189f, 51.811f, 32.254f, 51.822f
6012path.cubicTo(SkBits2Float(0x420172b2), SkBits2Float(0x424f6b7c), SkBits2Float(0x4201ec8d), SkBits2Float(0x424e8309), SkBits2Float(0x42020d51), SkBits2Float(0x424e4bbd)); // 32.362f, 51.855f, 32.481f, 51.628f, 32.513f, 51.574f
6013path.cubicTo(SkBits2Float(0x4202be78), SkBits2Float(0x424d5807), SkBits2Float(0x42037ae2), SkBits2Float(0x424c6557), SkBits2Float(0x42044cce), SkBits2Float(0x424b9265)); // 32.686f, 51.336f, 32.87f, 51.099f, 33.075f, 50.893f
6014path.cubicTo(SkBits2Float(0x42049aa1), SkBits2Float(0x424b4598), SkBits2Float(0x4204e874), SkBits2Float(0x424ae13e), SkBits2Float(0x42054084), SkBits2Float(0x424a9471)); // 33.151f, 50.818f, 33.227f, 50.72f, 33.313f, 50.645f
6015path.cubicTo(SkBits2Float(0x42058d51), SkBits2Float(0x424a51e2), SkBits2Float(0x4206ef9f), SkBits2Float(0x4248fad7), SkBits2Float(0x42071063), SkBits2Float(0x4248cecf)); // 33.388f, 50.58f, 33.734f, 50.245f, 33.766f, 50.202f
6016path.cubicTo(SkBits2Float(0x42075e36), SkBits2Float(0x424876bf), SkBits2Float(0x4207cccd), SkBits2Float(0x4248342f), SkBits2Float(0x42083021), SkBits2Float(0x4247e65c)); // 33.842f, 50.116f, 33.95f, 50.051f, 34.047f, 49.975f
6017path.cubicTo(SkBits2Float(0x42088831), SkBits2Float(0x42478308), SkBits2Float(0x4208f6c9), SkBits2Float(0x4247363b), SkBits2Float(0x420970a4), SkBits2Float(0x4246f3ac)); // 34.133f, 49.878f, 34.241f, 49.803f, 34.36f, 49.738f
6018path.cubicTo(SkBits2Float(0x4209f5c3), SkBits2Float(0x42469a95), SkBits2Float(0x420a645a), SkBits2Float(0x42464285), SkBits2Float(0x420add2f), SkBits2Float(0x4245f4b2)); // 34.49f, 49.651f, 34.598f, 49.565f, 34.716f, 49.489f
6019path.cubicTo(SkBits2Float(0x420b2b02), SkBits2Float(0x4245be6c), SkBits2Float(0x420bc5a2), SkBits2Float(0x42455a12), SkBits2Float(0x420b8418), SkBits2Float(0x4244eb7b)); // 34.792f, 49.436f, 34.943f, 49.338f, 34.879f, 49.23f
6020path.cubicTo(SkBits2Float(0x420b624d), SkBits2Float(0x4244cab6), SkBits2Float(0x420b1fbe), SkBits2Float(0x42449eae), SkBits2Float(0x420b0a3d), SkBits2Float(0x42448827)); // 34.846f, 49.198f, 34.781f, 49.155f, 34.76f, 49.133f
6021path.cubicTo(SkBits2Float(0x420abd70), SkBits2Float(0x424450db), SkBits2Float(0x420a9ba5), SkBits2Float(0x42440e4c), SkBits2Float(0x420a5916), SkBits2Float(0x4243d700)); // 34.685f, 49.079f, 34.652f, 49.014f, 34.587f, 48.96f
6022path.cubicTo(SkBits2Float(0x420a3851), SkBits2Float(0x4243b63b), SkBits2Float(0x420a21ca), SkBits2Float(0x4243b63b), SkBits2Float(0x4209f5c2), SkBits2Float(0x42439fb4)); // 34.555f, 48.928f, 34.533f, 48.928f, 34.49f, 48.906f
6023path.cubicTo(SkBits2Float(0x4209ea7e), SkBits2Float(0x42439470), SkBits2Float(0x4209ea7e), SkBits2Float(0x424373ac), SkBits2Float(0x4209d3f7), SkBits2Float(0x42436868)); // 34.479f, 48.895f, 34.479f, 48.863f, 34.457f, 48.852f
6024path.cubicTo(SkBits2Float(0x4209b332), SkBits2Float(0x424352e7), SkBits2Float(0x42099db1), SkBits2Float(0x42435e2b), SkBits2Float(0x42097be7), SkBits2Float(0x424352e7)); // 34.425f, 48.831f, 34.404f, 48.842f, 34.371f, 48.831f
6025path.cubicTo(SkBits2Float(0x420970a3), SkBits2Float(0x42433c60), SkBits2Float(0x42096560), SkBits2Float(0x42431b9b), SkBits2Float(0x4209449b), SkBits2Float(0x42431b9b)); // 34.36f, 48.809f, 34.349f, 48.777f, 34.317f, 48.777f
6026path.cubicTo(SkBits2Float(0x4208f6c8), SkBits2Float(0x4242e349), SkBits2Float(0x42089eb8), SkBits2Float(0x4242c284), SkBits2Float(0x42083020), SkBits2Float(0x4242a1c0)); // 34.241f, 48.722f, 34.155f, 48.69f, 34.047f, 48.658f
6027path.cubicTo(SkBits2Float(0x42080f5b), SkBits2Float(0x4242967c), SkBits2Float(0x4207d810), SkBits2Float(0x42425f31), SkBits2Float(0x4207c188), SkBits2Float(0x42425f31)); // 34.015f, 48.647f, 33.961f, 48.593f, 33.939f, 48.593f
6028path.cubicTo(SkBits2Float(0x420748b3), SkBits2Float(0x424227e5), SkBits2Float(0x42066040), SkBits2Float(0x4241fbdd), SkBits2Float(0x4205b957), SkBits2Float(0x42421ca2)); // 33.821f, 48.539f, 33.594f, 48.496f, 33.431f, 48.528f
6029path.cubicTo(SkBits2Float(0x4204c6a7), SkBits2Float(0x42423329), SkBits2Float(0x42041580), SkBits2Float(0x4242ad04), SkBits2Float(0x42032d0d), SkBits2Float(0x4242c285)); // 33.194f, 48.55f, 33.021f, 48.669f, 32.794f, 48.69f
6030path.cubicTo(SkBits2Float(0x42032d0d), SkBits2Float(0x4242b848), SkBits2Float(0x420322d0), SkBits2Float(0x4242a1c0), SkBits2Float(0x42032d0d), SkBits2Float(0x4242a1c0)); // 32.794f, 48.68f, 32.784f, 48.658f, 32.794f, 48.658f
6031path.cubicTo(SkBits2Float(0x42032d0d), SkBits2Float(0x424280fb), SkBits2Float(0x42036459), SkBits2Float(0x424275b8), SkBits2Float(0x42036f9c), SkBits2Float(0x42426a74)); // 32.794f, 48.626f, 32.848f, 48.615f, 32.859f, 48.604f
6032path.cubicTo(SkBits2Float(0x4203e977), SkBits2Float(0x4241cfd4), SkBits2Float(0x4204580f), SkBits2Float(0x42418201), SkBits2Float(0x420529fa), SkBits2Float(0x42413f72)); // 32.978f, 48.453f, 33.086f, 48.377f, 33.291f, 48.312f
6033path.lineTo(SkBits2Float(0x42054abf), SkBits2Float(0x424128eb)); // 33.323f, 48.29f
6034path.cubicTo(SkBits2Float(0x4205cfde), SkBits2Float(0x4240fde9), SkBits2Float(0x420649b9), SkBits2Float(0x4240fde9), SkBits2Float(0x4206b850), SkBits2Float(0x4240b016)); // 33.453f, 48.248f, 33.572f, 48.248f, 33.68f, 48.172f
6035path.cubicTo(SkBits2Float(0x4206a1c9), SkBits2Float(0x4240998f), SkBits2Float(0x4206b850), SkBits2Float(0x42408e4b), SkBits2Float(0x4206a1c9), SkBits2Float(0x424078ca)); // 33.658f, 48.15f, 33.68f, 48.139f, 33.658f, 48.118f
6036path.cubicTo(SkBits2Float(0x42068104), SkBits2Float(0x4240363b), SkBits2Float(0x42054081), SkBits2Float(0x423fb11c), SkBits2Float(0x4204d1ea), SkBits2Float(0x423f9057)); // 33.626f, 48.053f, 33.313f, 47.923f, 33.205f, 47.891f
6037path.cubicTo(SkBits2Float(0x42044ccb), SkBits2Float(0x423f79d0), SkBits2Float(0x42035915), SkBits2Float(0x423f644f), SkBits2Float(0x4202be75), SkBits2Float(0x423f8513)); // 33.075f, 47.869f, 32.837f, 47.848f, 32.686f, 47.88f
6038path.cubicTo(SkBits2Float(0x42022f19), SkBits2Float(0x423f9b9a), SkBits2Float(0x4201c081), SkBits2Float(0x423fde2a), SkBits2Float(0x420125e2), SkBits2Float(0x423ff3ab)); // 32.546f, 47.902f, 32.438f, 47.967f, 32.287f, 47.988f
6039path.lineTo(SkBits2Float(0x42010f5b), SkBits2Float(0x423fc7a3)); // 32.265f, 47.945f
6040path.cubicTo(SkBits2Float(0x4201a9fb), SkBits2Float(0x423f167c), SkBits2Float(0x42036459), SkBits2Float(0x423d5c1e), SkBits2Float(0x4204580f), SkBits2Float(0x423d198f)); // 32.416f, 47.772f, 32.848f, 47.34f, 33.086f, 47.275f
6041path.cubicTo(SkBits2Float(0x4205b957), SkBits2Float(0x423cabfe), SkBits2Float(0x4207c188), SkBits2Float(0x423cd806), SkBits2Float(0x42090d4e), SkBits2Float(0x423d24d3)); // 33.431f, 47.168f, 33.939f, 47.211f, 34.263f, 47.286f
6042path.cubicTo(SkBits2Float(0x420ae871), SkBits2Float(0x423d936b), SkBits2Float(0x420c9892), SkBits2Float(0x423e7bdd), SkBits2Float(0x420e6871), SkBits2Float(0x423ed3ee)); // 34.727f, 47.394f, 35.149f, 47.621f, 35.602f, 47.707f
6043path.cubicTo(SkBits2Float(0x42103956), SkBits2Float(0x423f438c), SkBits2Float(0x42121479), SkBits2Float(0x423f0b3a), SkBits2Float(0x4213c49a), SkBits2Float(0x423e2e0b)); // 36.056f, 47.816f, 36.52f, 47.761f, 36.942f, 47.545f
6044path.cubicTo(SkBits2Float(0x4214cdd1), SkBits2Float(0x423db536), SkBits2Float(0x4215c081), SkBits2Float(0x423d24d4), SkBits2Float(0x42169db1), SkBits2Float(0x423c696f)); // 37.201f, 47.427f, 37.438f, 47.286f, 37.654f, 47.103f
6045path.cubicTo(SkBits2Float(0x4216eb84), SkBits2Float(0x423c26e0), SkBits2Float(0x4217df3a), SkBits2Float(0x423afbde), SkBits2Float(0x4218580f), SkBits2Float(0x423b75b9)); // 37.73f, 47.038f, 37.968f, 46.746f, 38.086f, 46.865f
6046path.cubicTo(SkBits2Float(0x42189a9e), SkBits2Float(0x423bad05), SkBits2Float(0x421820c3), SkBits2Float(0x423c1b9c), SkBits2Float(0x4217ffff), SkBits2Float(0x423c311d)); // 38.151f, 46.919f, 38.032f, 47.027f, 38, 47.048f
6047path.cubicTo(SkBits2Float(0x4217a6e8), SkBits2Float(0x423c9577), SkBits2Float(0x42173851), SkBits2Float(0x423ced87), SkBits2Float(0x4216cac0), SkBits2Float(0x423d5c1f)); // 37.913f, 47.146f, 37.805f, 47.232f, 37.698f, 47.34f
6048path.cubicTo(SkBits2Float(0x42168831), SkBits2Float(0x423d9eae), SkBits2Float(0x421650e5), SkBits2Float(0x423deb7b), SkBits2Float(0x4215f7ce), SkBits2Float(0x423e23cd)); // 37.633f, 47.405f, 37.579f, 47.48f, 37.492f, 47.535f
6049path.lineTo(SkBits2Float(0x4215f7ce), SkBits2Float(0x423e4492)); // 37.492f, 47.567f
6050path.cubicTo(SkBits2Float(0x4215ed91), SkBits2Float(0x423e4fd6), SkBits2Float(0x4215d709), SkBits2Float(0x423e4492), SkBits2Float(0x4215cbc6), SkBits2Float(0x423e4fd6)); // 37.482f, 47.578f, 37.46f, 47.567f, 37.449f, 47.578f
6051path.cubicTo(SkBits2Float(0x42158937), SkBits2Float(0x423e8722), SkBits2Float(0x42153126), SkBits2Float(0x423f00fd), SkBits2Float(0x4214ee97), SkBits2Float(0x423f3849)); // 37.384f, 47.632f, 37.298f, 47.751f, 37.233f, 47.805f
6052path.cubicTo(SkBits2Float(0x4214d810), SkBits2Float(0x423f438d), SkBits2Float(0x4214cdd2), SkBits2Float(0x423f590e), SkBits2Float(0x4214cdd2), SkBits2Float(0x423f590e)); // 37.211f, 47.816f, 37.201f, 47.837f, 37.201f, 47.837f
6053path.lineTo(SkBits2Float(0x4214b74b), SkBits2Float(0x423f590e)); // 37.179f, 47.837f
6054path.lineTo(SkBits2Float(0x4214b74b), SkBits2Float(0x423f79d3)); // 37.179f, 47.869f
6055path.cubicTo(SkBits2Float(0x42147fff), SkBits2Float(0x423f905a), SkBits2Float(0x421474bc), SkBits2Float(0x423fb11f), SkBits2Float(0x421448b3), SkBits2Float(0x423fc7a6)); // 37.125f, 47.891f, 37.114f, 47.923f, 37.071f, 47.945f
6056path.lineTo(SkBits2Float(0x421448b3), SkBits2Float(0x423fdd27)); // 37.071f, 47.966f
6057path.lineTo(SkBits2Float(0x42143332), SkBits2Float(0x423fdd27)); // 37.05f, 47.966f
6058path.lineTo(SkBits2Float(0x4213b957), SkBits2Float(0x424077c7)); // 36.931f, 48.117f
6059path.cubicTo(SkBits2Float(0x4213a2d0), SkBits2Float(0x4240830b), SkBits2Float(0x4213b957), SkBits2Float(0x4240988c), SkBits2Float(0x4213b957), SkBits2Float(0x4240988c)); // 36.909f, 48.128f, 36.931f, 48.149f, 36.931f, 48.149f
6060path.cubicTo(SkBits2Float(0x4213c49b), SkBits2Float(0x4240988c), SkBits2Float(0x4213b957), SkBits2Float(0x4240ba57), SkBits2Float(0x4213da1c), SkBits2Float(0x4240af13)); // 36.942f, 48.149f, 36.931f, 48.182f, 36.963f, 48.171f
6061path.cubicTo(SkBits2Float(0x42141cab), SkBits2Float(0x4240af13), SkBits2Float(0x4214a1ca), SkBits2Float(0x42405703), SkBits2Float(0x4214ee97), SkBits2Float(0x42403538)); // 37.028f, 48.171f, 37.158f, 48.085f, 37.233f, 48.052f
6062path.cubicTo(SkBits2Float(0x42153126), SkBits2Float(0x42401473), SkBits2Float(0x42157ef9), SkBits2Float(0x423ffdec), SkBits2Float(0x4215cbc6), SkBits2Float(0x423fd1e4)); // 37.298f, 48.02f, 37.374f, 47.998f, 37.449f, 47.955f
6063path.cubicTo(SkBits2Float(0x421650e5), SkBits2Float(0x423f8f55), SkBits2Float(0x4216cac0), SkBits2Float(0x423f4288), SkBits2Float(0x42178624), SkBits2Float(0x423f20bd)); // 37.579f, 47.89f, 37.698f, 47.815f, 37.881f, 47.782f
6064path.cubicTo(SkBits2Float(0x42177ae0), SkBits2Float(0x423f8f55), SkBits2Float(0x421770a3), SkBits2Float(0x423fc6a0), SkBits2Float(0x42174395), SkBits2Float(0x423ffdec)); // 37.87f, 47.89f, 37.86f, 47.944f, 37.816f, 47.998f
6065path.cubicTo(SkBits2Float(0x4216bf7c), SkBits2Float(0x4240ba56), SkBits2Float(0x4215ab02), SkBits2Float(0x4241332b), SkBits2Float(0x4214f9db), SkBits2Float(0x4241c38e)); // 37.687f, 48.182f, 37.417f, 48.3f, 37.244f, 48.441f
6066path.cubicTo(SkBits2Float(0x42143333), SkBits2Float(0x424274b5), SkBits2Float(0x42136b85), SkBits2Float(0x42433019), SkBits2Float(0x4212c5a2), SkBits2Float(0x4243f7c7)); // 37.05f, 48.614f, 36.855f, 48.797f, 36.693f, 48.992f
6067path.cubicTo(SkBits2Float(0x42115917), SkBits2Float(0x42459b9e), SkBits2Float(0x421022d1), SkBits2Float(0x42476c83), SkBits2Float(0x420f0313), SkBits2Float(0x4249311f)); // 36.337f, 49.402f, 36.034f, 49.856f, 35.753f, 50.298f
6068path.cubicTo(SkBits2Float(0x420e1ba6), SkBits2Float(0x424a936d), SkBits2Float(0x420d75c3), SkBits2Float(0x424c21c3), SkBits2Float(0x420cdb23), SkBits2Float(0x424dba56)); // 35.527f, 50.644f, 35.365f, 51.033f, 35.214f, 51.432f
6069path.cubicTo(SkBits2Float(0x420c3f7d), SkBits2Float(0x424f6a77), SkBits2Float(0x420b8419), SkBits2Float(0x42510e4e), SkBits2Float(0x420b1fbf), SkBits2Float(0x4252d3f0)); // 35.062f, 51.854f, 34.879f, 52.264f, 34.781f, 52.707f
6070path.cubicTo(SkBits2Float(0x420ad2f2), SkBits2Float(0x42548e4e), SkBits2Float(0x420ab127), SkBits2Float(0x42565e2d), SkBits2Float(0x420a9063), SkBits2Float(0x4258188c)); // 34.706f, 53.139f, 34.673f, 53.592f, 34.641f, 54.024f
6071path.cubicTo(SkBits2Float(0x420a7ae2), SkBits2Float(0x4258882a), SkBits2Float(0x420a9ba7), SkBits2Float(0x4258e03a), SkBits2Float(0x420a9ba7), SkBits2Float(0x42594ed2)); // 34.62f, 54.133f, 34.652f, 54.219f, 34.652f, 54.327f
6072path.cubicTo(SkBits2Float(0x420aa6eb), SkBits2Float(0x425e301a), SkBits2Float(0x420c820d), SkBits2Float(0x4262c495), SkBits2Float(0x420ecbc8), SkBits2Float(0x4266fff9)); // 34.663f, 55.547f, 35.127f, 56.692f, 35.699f, 57.75f
6073path.cubicTo(SkBits2Float(0x420eed93), SkBits2Float(0x426721c4), SkBits2Float(0x420f0e57), SkBits2Float(0x42674dcc), SkBits2Float(0x420f3022), SkBits2Float(0x42676e91)); // 35.732f, 57.783f, 35.764f, 57.826f, 35.797f, 57.858f
6074path.cubicTo(SkBits2Float(0x420f7df5), SkBits2Float(0x42680a37), SkBits2Float(0x420fbf7e), SkBits2Float(0x42689993), SkBits2Float(0x42100d51), SkBits2Float(0x42693433)); // 35.873f, 58.01f, 35.937f, 58.15f, 36.013f, 58.301f
6075path.cubicTo(SkBits2Float(0x42102e16), SkBits2Float(0x426955fe), SkBits2Float(0x42105a1e), SkBits2Float(0x426976c2), SkBits2Float(0x42106561), SkBits2Float(0x42698d4a)); // 36.045f, 58.334f, 36.088f, 58.366f, 36.099f, 58.388f
6076path.cubicTo(SkBits2Float(0x4210872c), SkBits2Float(0x4269e55a), SkBits2Float(0x4210a7f0), SkBits2Float(0x426a3d6b), SkBits2Float(0x4210ea80), SkBits2Float(0x426a6a79)); // 36.132f, 58.474f, 36.164f, 58.56f, 36.229f, 58.604f
6077path.cubicTo(SkBits2Float(0x42119aa1), SkBits2Float(0x426acdcd), SkBits2Float(0x42131376), SkBits2Float(0x426a48ae), SkBits2Float(0x4213e561), SkBits2Float(0x426a6a79)); // 36.401f, 58.701f, 36.769f, 58.571f, 36.974f, 58.604f
6078path.cubicTo(SkBits2Float(0x4213fae2), SkBits2Float(0x426a75bd), SkBits2Float(0x42141cad), SkBits2Float(0x426a8b3e), SkBits2Float(0x42143d71), SkBits2Float(0x426a8b3e)); // 36.995f, 58.615f, 37.028f, 58.636f, 37.06f, 58.636f
6079path.cubicTo(SkBits2Float(0x42141cac), SkBits2Float(0x426acdcd), SkBits2Float(0x42143334), SkBits2Float(0x426aee92), SkBits2Float(0x42141cac), SkBits2Float(0x426b25de)); // 37.028f, 58.701f, 37.05f, 58.733f, 37.028f, 58.787f
6080path.cubicTo(SkBits2Float(0x4213e560), SkBits2Float(0x426b9fb9), SkBits2Float(0x4212dc29), SkBits2Float(0x426d0d4b), SkBits2Float(0x4212f1aa), SkBits2Float(0x426da7ea)); // 36.974f, 58.906f, 36.715f, 59.263f, 36.736f, 59.414f
6081path.cubicTo(SkBits2Float(0x4212f1aa), SkBits2Float(0x426dfffa), SkBits2Float(0x4213b958), SkBits2Float(0x426ed1e6), SkBits2Float(0x4213c49c), SkBits2Float(0x426edd29)); // 36.736f, 59.5f, 36.931f, 59.705f, 36.942f, 59.716f
6082path.cubicTo(SkBits2Float(0x4213e561), SkBits2Float(0x426f1fb8), SkBits2Float(0x42143d71), SkBits2Float(0x426f9993), SkBits2Float(0x421448b5), SkBits2Float(0x426ffce7)); // 36.974f, 59.781f, 37.06f, 59.9f, 37.071f, 59.997f
6083path.cubicTo(SkBits2Float(0x421448b5), SkBits2Float(0x427076c2), SkBits2Float(0x4214072c), SkBits2Float(0x4270ef97), SkBits2Float(0x4213fae2), SkBits2Float(0x427148ae)); // 37.071f, 60.116f, 37.007f, 60.234f, 36.995f, 60.321f
6084path.cubicTo(SkBits2Float(0x4213e561), SkBits2Float(0x42717ffa), SkBits2Float(0x4213fae2), SkBits2Float(0x42718b3d), SkBits2Float(0x4213e561), SkBits2Float(0x4271b746)); // 36.974f, 60.375f, 36.995f, 60.386f, 36.974f, 60.429f
6085path.cubicTo(SkBits2Float(0x4213da1d), SkBits2Float(0x4271ccc7), SkBits2Float(0x4213b959), SkBits2Float(0x42721a9a), SkBits2Float(0x4213a2d2), SkBits2Float(0x42721a9a)); // 36.963f, 60.45f, 36.931f, 60.526f, 36.909f, 60.526f
6086path.cubicTo(SkBits2Float(0x42134ac2), SkBits2Float(0x42723c65), SkBits2Float(0x4212d0e6), SkBits2Float(0x427225de), SkBits2Float(0x42126d93), SkBits2Float(0x427225de)); // 36.823f, 60.559f, 36.704f, 60.537f, 36.607f, 60.537f
6087path.cubicTo(SkBits2Float(0x42124bc8), SkBits2Float(0x427225de), SkBits2Float(0x4211bc6c), SkBits2Float(0x42723c65), SkBits2Float(0x42119064), SkBits2Float(0x42723c65)); // 36.574f, 60.537f, 36.434f, 60.559f, 36.391f, 60.559f
6088path.cubicTo(SkBits2Float(0x4210d3fa), SkBits2Float(0x427246a2), SkBits2Float(0x420ff6ca), SkBits2Float(0x4272301b), SkBits2Float(0x420f676e), SkBits2Float(0x4272686d)); // 36.207f, 60.569f, 35.991f, 60.547f, 35.851f, 60.602f
6089path.cubicTo(SkBits2Float(0x420eb647), SkBits2Float(0x4272b53a), SkBits2Float(0x420e52f3), SkBits2Float(0x42737ce8), SkBits2Float(0x420dc291), SkBits2Float(0x4273f5bd)); // 35.678f, 60.677f, 35.581f, 60.872f, 35.44f, 60.99f
6090path.cubicTo(SkBits2Float(0x420d116a), SkBits2Float(0x4274861f), SkBits2Float(0x420c5606), SkBits2Float(0x4274e973), SkBits2Float(0x420b999b), SkBits2Float(0x4275580b)); // 35.267f, 61.131f, 35.084f, 61.228f, 34.9f, 61.336f
6091path.cubicTo(SkBits2Float(0x420a9ba7), SkBits2Float(0x4275fdee), SkBits2Float(0x4209b335), SkBits2Float(0x42768d4a), SkBits2Float(0x42089eba), SkBits2Float(0x4276f1a5)); // 34.652f, 61.498f, 34.425f, 61.638f, 34.155f, 61.736f
6092path.cubicTo(SkBits2Float(0x4207ab04), SkBits2Float(0x42773e72), SkBits2Float(0x4206a1cc), SkBits2Float(0x42778101), SkBits2Float(0x4205b95a), SkBits2Float(0x4277c391)); // 33.917f, 61.811f, 33.658f, 61.876f, 33.431f, 61.941f
6093path.cubicTo(SkBits2Float(0x4203bd73), SkBits2Float(0x42786974), SkBits2Float(0x4201cbc9), SkBits2Float(0x42793b60), SkBits2Float(0x4200ac0a), SkBits2Float(0x427af5be)); // 32.935f, 62.103f, 32.449f, 62.308f, 32.168f, 62.74f
6094path.cubicTo(SkBits2Float(0x420074be), SkBits2Float(0x427b428b), SkBits2Float(0x41ffb43d), SkBits2Float(0x427c4cc8), SkBits2Float(0x41ff872f), SkBits2Float(0x427ca4d9)); // 32.114f, 62.815f, 31.963f, 63.075f, 31.941f, 63.161f
6095path.cubicTo(SkBits2Float(0x41ff872f), SkBits2Float(0x427cbb60), SkBits2Float(0x41ff9db6), SkBits2Float(0x427cd0e1), SkBits2Float(0x41ff872f), SkBits2Float(0x427ce768)); // 31.941f, 63.183f, 31.952f, 63.204f, 31.941f, 63.226f
6096path.cubicTo(SkBits2Float(0x41ffb43d), SkBits2Float(0x427cfce9), SkBits2Float(0x41ffb43d), SkBits2Float(0x427cfce9), SkBits2Float(0x41ffdf3f), SkBits2Float(0x427d1370)); // 31.963f, 63.247f, 31.963f, 63.247f, 31.984f, 63.269f
6097path.cubicTo(SkBits2Float(0x4200ac0a), SkBits2Float(0x427cfce9), SkBits2Float(0x42010f5e), SkBits2Float(0x427cd0e1), SkBits2Float(0x4201a9fe), SkBits2Float(0x427ca4d8)); // 32.168f, 63.247f, 32.265f, 63.204f, 32.416f, 63.161f
6098path.cubicTo(SkBits2Float(0x4201c085), SkBits2Float(0x427c9994), SkBits2Float(0x4201f7d1), SkBits2Float(0x427c78d0), SkBits2Float(0x42020315), SkBits2Float(0x427c78d0)); // 32.438f, 63.15f, 32.492f, 63.118f, 32.503f, 63.118f
6099path.cubicTo(SkBits2Float(0x420223da), SkBits2Float(0x427c6249), SkBits2Float(0x42022f1d), SkBits2Float(0x427c78d0), SkBits2Float(0x42023a61), SkBits2Float(0x427c78d0)); // 32.535f, 63.096f, 32.546f, 63.118f, 32.557f, 63.118f
6100path.cubicTo(SkBits2Float(0x42025b26), SkBits2Float(0x427c6249), SkBits2Float(0x42028834), SkBits2Float(0x427c4184), SkBits2Float(0x4202a8f9), SkBits2Float(0x427c4184)); // 32.589f, 63.096f, 32.633f, 63.064f, 32.665f, 63.064f
6101path.cubicTo(SkBits2Float(0x4203e97c), SkBits2Float(0x427bc7a9), SkBits2Float(0x42061db5), SkBits2Float(0x427ba6e4), SkBits2Float(0x4207b649), SkBits2Float(0x427bfef5)); // 32.978f, 62.945f, 33.529f, 62.913f, 33.928f, 62.999f
6102path.cubicTo(SkBits2Float(0x42089ebc), SkBits2Float(0x427c20c0), SkBits2Float(0x420970a7), SkBits2Float(0x427c78d0), SkBits2Float(0x420a21ce), SkBits2Float(0x427cc59d)); // 34.155f, 63.032f, 34.36f, 63.118f, 34.533f, 63.193f
6103path.cubicTo(SkBits2Float(0x420a6fa1), SkBits2Float(0x427cdc24), SkBits2Float(0x420ab12a), SkBits2Float(0x427ce768), SkBits2Float(0x420af3ba), SkBits2Float(0x427d1370)); // 34.609f, 63.215f, 34.673f, 63.226f, 34.738f, 63.269f
6104path.cubicTo(SkBits2Float(0x420b0a41), SkBits2Float(0x427d1370), SkBits2Float(0x420af3ba), SkBits2Float(0x427d353b), SkBits2Float(0x420b1585), SkBits2Float(0x427d407e)); // 34.76f, 63.269f, 34.738f, 63.302f, 34.771f, 63.313f
6105path.cubicTo(SkBits2Float(0x420b0a41), SkBits2Float(0x427d6143), SkBits2Float(0x420b0a41), SkBits2Float(0x427d8207), SkBits2Float(0x420af3ba), SkBits2Float(0x427dae0f)); // 34.76f, 63.345f, 34.76f, 63.377f, 34.738f, 63.42f
6106path.cubicTo(SkBits2Float(0x420ad2f5), SkBits2Float(0x427df09e), SkBits2Float(0x420a2d12), SkBits2Float(0x427e54f8), SkBits2Float(0x420a4293), SkBits2Float(0x427ee455)); // 34.706f, 63.485f, 34.544f, 63.583f, 34.565f, 63.723f
6107path.cubicTo(SkBits2Float(0x420a591a), SkBits2Float(0x427f051a), SkBits2Float(0x420ad2f5), SkBits2Float(0x427f3122), SkBits2Float(0x420af3ba), SkBits2Float(0x427f47a9)); // 34.587f, 63.755f, 34.706f, 63.798f, 34.738f, 63.82f
6108path.cubicTo(SkBits2Float(0x420af3ba), SkBits2Float(0x427f5d2a), SkBits2Float(0x420af3ba), SkBits2Float(0x427f73b1), SkBits2Float(0x420b0a41), SkBits2Float(0x427f7ef5)); // 34.738f, 63.841f, 34.738f, 63.863f, 34.76f, 63.874f
6109path.cubicTo(SkBits2Float(0x420add33), SkBits2Float(0x427fccc8), SkBits2Float(0x420a21ce), SkBits2Float(0x42803e74), SkBits2Float(0x420a2d12), SkBits2Float(0x4280701e)); // 34.716f, 63.95f, 34.533f, 64.122f, 34.544f, 64.219f
6110path.cubicTo(SkBits2Float(0x420a3856), SkBits2Float(0x42808bc4), SkBits2Float(0x420ad2f5), SkBits2Float(0x4280a7ed), SkBits2Float(0x420ae876), SkBits2Float(0x4280b2ad)); // 34.555f, 64.273f, 34.706f, 64.328f, 34.727f, 64.349f
6111path.cubicTo(SkBits2Float(0x420af3ba), SkBits2Float(0x4280bdf1), SkBits2Float(0x420add32), SkBits2Float(0x4280c8b1), SkBits2Float(0x420af3ba), SkBits2Float(0x4280d3f5)); // 34.738f, 64.371f, 34.716f, 64.392f, 34.738f, 64.414f
6112path.cubicTo(SkBits2Float(0x420abd74), SkBits2Float(0x4280f53d), SkBits2Float(0x4209f5c6), SkBits2Float(0x4281428d), SkBits2Float(0x420a21ce), SkBits2Float(0x42816e95)); // 34.685f, 64.479f, 34.49f, 64.63f, 34.533f, 64.716f
6113path.cubicTo(SkBits2Float(0x420a4293), SkBits2Float(0x4281957e), SkBits2Float(0x420ad2f5), SkBits2Float(0x4281a664), SkBits2Float(0x420ae876), SkBits2Float(0x4281c187)); // 34.565f, 64.792f, 34.706f, 64.825f, 34.727f, 64.878f
6114path.cubicTo(SkBits2Float(0x420ae876), SkBits2Float(0x4281c729), SkBits2Float(0x420add32), SkBits2Float(0x4281d26c), SkBits2Float(0x420ae876), SkBits2Float(0x4281d26c)); // 34.727f, 64.889f, 34.716f, 64.911f, 34.727f, 64.911f
6115path.cubicTo(SkBits2Float(0x420aa6ed), SkBits2Float(0x4281fe74), SkBits2Float(0x420a591a), SkBits2Float(0x42821a1a), SkBits2Float(0x4209f5c6), SkBits2Float(0x42823b62)); // 34.663f, 64.997f, 34.587f, 65.051f, 34.49f, 65.116f
6116path.cubicTo(SkBits2Float(0x420a168b), SkBits2Float(0x42825caa), SkBits2Float(0x420a010a), SkBits2Float(0x4282624b), SkBits2Float(0x420a2d12), SkBits2Float(0x42827850)); // 34.522f, 65.181f, 34.501f, 65.192f, 34.544f, 65.235f
6117path.cubicTo(SkBits2Float(0x420a645e), SkBits2Float(0x428288b2), SkBits2Float(0x420a9baa), SkBits2Float(0x428293f6), SkBits2Float(0x420ad2f5), SkBits2Float(0x4282a458)); // 34.598f, 65.267f, 34.652f, 65.289f, 34.706f, 65.321f
6118path.cubicTo(SkBits2Float(0x420ad2f5), SkBits2Float(0x4282a458), SkBits2Float(0x420add32), SkBits2Float(0x4282d685), SkBits2Float(0x420abd74), SkBits2Float(0x4282c5a0)); // 34.706f, 65.321f, 34.716f, 65.419f, 34.685f, 65.386f
6119path.cubicTo(SkBits2Float(0x420aa6ed), SkBits2Float(0x4282cb42), SkBits2Float(0x420a9066), SkBits2Float(0x4282e146), SkBits2Float(0x420a6fa1), SkBits2Float(0x4282e6e8)); // 34.663f, 65.397f, 34.641f, 65.44f, 34.609f, 65.451f
6120path.cubicTo(SkBits2Float(0x4209df3f), SkBits2Float(0x42830830), SkBits2Float(0x4208f6cc), SkBits2Float(0x4282bae0), SkBits2Float(0x42088834), SkBits2Float(0x4282a459)); // 34.468f, 65.516f, 34.241f, 65.365f, 34.133f, 65.321f
6121path.cubicTo(SkBits2Float(0x420846ab), SkBits2Float(0x42829915), SkBits2Float(0x42080f5f), SkBits2Float(0x42829915), SkBits2Float(0x4207c18c), SkBits2Float(0x428293f7)); // 34.069f, 65.299f, 34.015f, 65.299f, 33.939f, 65.289f
6122path.cubicTo(SkBits2Float(0x42079584), SkBits2Float(0x428288b3), SkBits2Float(0x420748b7), SkBits2Float(0x42826d0e), SkBits2Float(0x42071ba9), SkBits2Float(0x42826d0e)); // 33.896f, 65.267f, 33.821f, 65.213f, 33.777f, 65.213f
6123path.cubicTo(SkBits2Float(0x4206cedc), SkBits2Float(0x4282624d), SkBits2Float(0x42068109), SkBits2Float(0x4282624d), SkBits2Float(0x42061272), SkBits2Float(0x4282624d)); // 33.702f, 65.192f, 33.626f, 65.192f, 33.518f, 65.192f
6124path.cubicTo(SkBits2Float(0x4205cfe3), SkBits2Float(0x42825cab), SkBits2Float(0x4205614b), SkBits2Float(0x42824bc6), SkBits2Float(0x42051ebc), SkBits2Float(0x42824bc6)); // 33.453f, 65.181f, 33.345f, 65.148f, 33.28f, 65.148f
6125path.cubicTo(SkBits2Float(0x42037ae5), SkBits2Float(0x428246a7), SkBits2Float(0x4201cbca), SkBits2Float(0x42829eb8), SkBits2Float(0x4200ac0c), SkBits2Float(0x4282e147)); // 32.87f, 65.138f, 32.449f, 65.31f, 32.168f, 65.44f
6126path.cubicTo(SkBits2Float(0x42008b47), SkBits2Float(0x4282e6e9), SkBits2Float(0x42005e39), SkBits2Float(0x4282fced), SkBits2Float(0x42003d74), SkBits2Float(0x4283028f)); // 32.136f, 65.451f, 32.092f, 65.494f, 32.06f, 65.505f
6127path.cubicTo(SkBits2Float(0x41fdf9e2), SkBits2Float(0x42833f7d), SkBits2Float(0x41fa4190), SkBits2Float(0x42836041), SkBits2Float(0x41f674c3), SkBits2Float(0x42834fdf)); // 31.747f, 65.624f, 31.282f, 65.688f, 30.807f, 65.656f
6128path.cubicTo(SkBits2Float(0x41f59794), SkBits2Float(0x4283451e), SkBits2Float(0x41f48d56), SkBits2Float(0x4283451e), SkBits2Float(0x41f3b027), SkBits2Float(0x428339db)); // 30.699f, 65.635f, 30.569f, 65.635f, 30.461f, 65.613f
6129path.cubicTo(SkBits2Float(0x41f32d15), SkBits2Float(0x42832e97), SkBits2Float(0x41f2666d), SkBits2Float(0x428312f2), SkBits2Float(0x41f1b440), SkBits2Float(0x42830831)); // 30.397f, 65.591f, 30.3f, 65.537f, 30.213f, 65.516f
6130path.cubicTo(SkBits2Float(0x41f1041f), SkBits2Float(0x4282fced), SkBits2Float(0x41f07f01), SkBits2Float(0x4282f74c), SkBits2Float(0x41efb859), SkBits2Float(0x4282e6e9)); // 30.127f, 65.494f, 30.062f, 65.483f, 29.965f, 65.451f
6131path.cubicTo(SkBits2Float(0x41efa1d2), SkBits2Float(0x4282e147), SkBits2Float(0x41ef6049), SkBits2Float(0x4282d687), SkBits2Float(0x41ef49c1), SkBits2Float(0x4282d687)); // 29.954f, 65.44f, 29.922f, 65.419f, 29.911f, 65.419f
6132path.cubicTo(SkBits2Float(0x41ef062b), SkBits2Float(0x4282cb43), SkBits2Float(0x41eec4a2), SkBits2Float(0x4282cb43), SkBits2Float(0x41ee560b), SkBits2Float(0x4282c5a2)); // 29.878f, 65.397f, 29.846f, 65.397f, 29.792f, 65.386f
6133path.cubicTo(SkBits2Float(0x41ee1275), SkBits2Float(0x4282c000), SkBits2Float(0x41ed8f63), SkBits2Float(0x4282a45a), SkBits2Float(0x41ed3546), SkBits2Float(0x42829eb9)); // 29.759f, 65.375f, 29.695f, 65.321f, 29.651f, 65.31f
6134path.cubicTo(SkBits2Float(0x41ebbe7d), SkBits2Float(0x42827d71), SkBits2Float(0x41ea72b7), SkBits2Float(0x42825cad), SkBits2Float(0x41e91069), SkBits2Float(0x42823b65)); // 29.468f, 65.245f, 29.306f, 65.181f, 29.133f, 65.116f
6135path.cubicTo(SkBits2Float(0x41e6fdfa), SkBits2Float(0x42820419), SkBits2Float(0x41e4a7f6), SkBits2Float(0x4281ab86), SkBits2Float(0x41e18b4a), SkBits2Float(0x4281ab86)); // 28.874f, 65.008f, 28.582f, 64.835f, 28.193f, 64.835f
6136path.cubicTo(SkBits2Float(0x41de9bac), SkBits2Float(0x4281b128), SkBits2Float(0x41dcf7d5), SkBits2Float(0x4281fe78), SkBits2Float(0x41db3d77), SkBits2Float(0x428246a9)); // 27.826f, 64.846f, 27.621f, 64.997f, 27.405f, 65.138f
6137path.cubicTo(SkBits2Float(0x41dacedf), SkBits2Float(0x4282570b), SkBits2Float(0x41da76cf), SkBits2Float(0x4282570b), SkBits2Float(0x41da0838), SkBits2Float(0x4282676e)); // 27.351f, 65.17f, 27.308f, 65.17f, 27.254f, 65.202f
6138path.cubicTo(SkBits2Float(0x41d9f1b1), SkBits2Float(0x4282676e), SkBits2Float(0x41d9f1b1), SkBits2Float(0x42827853), SkBits2Float(0x41d9db2a), SkBits2Float(0x42827d72)); // 27.243f, 65.202f, 27.243f, 65.235f, 27.232f, 65.245f
6139path.cubicTo(SkBits2Float(0x41d96c92), SkBits2Float(0x428288b6), SkBits2Float(0x41d91482), SkBits2Float(0x428288b6), SkBits2Float(0x41d8a5eb), SkBits2Float(0x42829eba)); // 27.178f, 65.267f, 27.135f, 65.267f, 27.081f, 65.31f
6140path.lineTo(SkBits2Float(0x41d88f64), SkBits2Float(0x4282a9fe)); // 27.07f, 65.332f
6141path.cubicTo(SkBits2Float(0x41d6eb8d), SkBits2Float(0x4282e14a), SkBits2Float(0x41d4ac10), SkBits2Float(0x42830291), SkBits2Float(0x41d25818), SkBits2Float(0x428312f4)); // 26.865f, 65.44f, 26.584f, 65.505f, 26.293f, 65.537f
6142path.cubicTo(SkBits2Float(0x41d0b235), SkBits2Float(0x42831896), SkBits2Float(0x41ce74c4), SkBits2Float(0x428312f4), SkBits2Float(0x41cce568), SkBits2Float(0x42830292)); // 26.087f, 65.548f, 25.807f, 65.537f, 25.612f, 65.505f
6143path.cubicTo(SkBits2Float(0x41cca3df), SkBits2Float(0x4282fcf0), SkBits2Float(0x41cc1ec0), SkBits2Float(0x4282f1ad), SkBits2Float(0x41cbf3be), SkBits2Float(0x4282f1ad)); // 25.58f, 65.494f, 25.515f, 65.472f, 25.494f, 65.472f
6144path.cubicTo(SkBits2Float(0x41ca9170), SkBits2Float(0x4282dba9), SkBits2Float(0x41c99dba), SkBits2Float(0x4282e14b), SkBits2Float(0x41c8687a), SkBits2Float(0x4282cb47)); // 25.321f, 65.429f, 25.202f, 65.44f, 25.051f, 65.397f
6145path.cubicTo(SkBits2Float(0x41c7b64d), SkBits2Float(0x4282c003), SkBits2Float(0x41c71cb3), SkBits2Float(0x4282bae5), SkBits2Float(0x41c6560b), SkBits2Float(0x4282a9ff)); // 24.964f, 65.375f, 24.889f, 65.365f, 24.792f, 65.332f
6146path.lineTo(SkBits2Float(0x41c628fd), SkBits2Float(0x42829ebb)); // 24.77f, 65.31f
6147path.cubicTo(SkBits2Float(0x41c58d57), SkBits2Float(0x428293fa), SkBits2Float(0x41c53547), SkBits2Float(0x42829919), SkBits2Float(0x41c4b028), SkBits2Float(0x428293fa)); // 24.694f, 65.289f, 24.651f, 65.299f, 24.586f, 65.289f
6148path.lineTo(SkBits2Float(0x41c46e9f), SkBits2Float(0x42828315)); // 24.554f, 65.256f
6149path.cubicTo(SkBits2Float(0x41c1d712), SkBits2Float(0x4282570d), SkBits2Float(0x41be20cc), SkBits2Float(0x428209bd), SkBits2Float(0x41bb0420), SkBits2Float(0x42820f5f)); // 24.23f, 65.17f, 23.766f, 65.019f, 23.377f, 65.03f
6150path.cubicTo(SkBits2Float(0x41b9a1d2), SkBits2Float(0x42820f5f), SkBits2Float(0x41b7e774), SkBits2Float(0x42823024), SkBits2Float(0x41b6dd37), SkBits2Float(0x428246ab)); // 23.204f, 65.03f, 22.988f, 65.094f, 22.858f, 65.138f
6151path.cubicTo(SkBits2Float(0x41b5eb8d), SkBits2Float(0x4282570d), SkBits2Float(0x41b54fe7), SkBits2Float(0x4282570d), SkBits2Float(0x41b45c31), SkBits2Float(0x42826770)); // 22.74f, 65.17f, 22.664f, 65.17f, 22.545f, 65.202f
6152path.cubicTo(SkBits2Float(0x41b3ed99), SkBits2Float(0x42826d12), SkBits2Float(0x41b35400), SkBits2Float(0x428288b8), SkBits2Float(0x41b2fbef), SkBits2Float(0x428293fb)); // 22.491f, 65.213f, 22.416f, 65.267f, 22.373f, 65.289f
6153path.cubicTo(SkBits2Float(0x41b274c4), SkBits2Float(0x4282991a), SkBits2Float(0x41b249c2), SkBits2Float(0x428293fb), SkBits2Float(0x41b1c4a3), SkBits2Float(0x42829ebc)); // 22.307f, 65.299f, 22.286f, 65.289f, 22.221f, 65.31f
6154path.cubicTo(SkBits2Float(0x41b1560b), SkBits2Float(0x4282a45e), SkBits2Float(0x41b08f64), SkBits2Float(0x4282c004), SkBits2Float(0x41aff3be), SkBits2Float(0x4282cb47)); // 22.167f, 65.321f, 22.07f, 65.375f, 21.994f, 65.397f
6155path.cubicTo(SkBits2Float(0x41aea7f7), SkBits2Float(0x4282e14b), SkBits2Float(0x41ad893f), SkBits2Float(0x4282f1ad), SkBits2Float(0x41ac3d78), SkBits2Float(0x42830835)); // 21.832f, 65.44f, 21.692f, 65.472f, 21.53f, 65.516f
6156path.cubicTo(SkBits2Float(0x41ac106a), SkBits2Float(0x428312f6), SkBits2Float(0x41aba1d2), SkBits2Float(0x42831e39), SkBits2Float(0x41ab76d0), SkBits2Float(0x428323db)); // 21.508f, 65.537f, 21.454f, 65.559f, 21.433f, 65.57f
6157path.cubicTo(SkBits2Float(0x41aac4a3), SkBits2Float(0x4283343d), SkBits2Float(0x41aa560b), SkBits2Float(0x4283343d), SkBits2Float(0x41a9ba66), SkBits2Float(0x42833f81)); // 21.346f, 65.602f, 21.292f, 65.602f, 21.216f, 65.624f
6158path.lineTo(SkBits2Float(0x41a98f64), SkBits2Float(0x42834fe3)); // 21.195f, 65.656f
6159path.cubicTo(SkBits2Float(0x41a96256), SkBits2Float(0x42834fe3), SkBits2Float(0x41a93754), SkBits2Float(0x42834522), SkBits2Float(0x41a920cc), SkBits2Float(0x42834fe3)); // 21.173f, 65.656f, 21.152f, 65.635f, 21.141f, 65.656f
6160path.cubicTo(SkBits2Float(0x41a90a45), SkBits2Float(0x42834fe3), SkBits2Float(0x41a8b234), SkBits2Float(0x42836045), SkBits2Float(0x41a89bad), SkBits2Float(0x42836b89)); // 21.13f, 65.656f, 21.087f, 65.688f, 21.076f, 65.71f
6161path.cubicTo(SkBits2Float(0x41a7d505), SkBits2Float(0x42837beb), SkBits2Float(0x41a7666e), SkBits2Float(0x4283818d), SkBits2Float(0x41a6cac8), SkBits2Float(0x42839d33)); // 20.979f, 65.742f, 20.925f, 65.753f, 20.849f, 65.807f
6162path.cubicTo(SkBits2Float(0x41a6b64d), SkBits2Float(0x4283a2d5), SkBits2Float(0x41a672b8), SkBits2Float(0x4283b3ba), SkBits2Float(0x41a65e3d), SkBits2Float(0x4283b8d9)); // 20.839f, 65.818f, 20.806f, 65.851f, 20.796f, 65.861f
6163path.cubicTo(SkBits2Float(0x41a6312f), SkBits2Float(0x4283be7b), SkBits2Float(0x41a60420), SkBits2Float(0x4283b8d9), SkBits2Float(0x41a5ed99), SkBits2Float(0x4283be7b)); // 20.774f, 65.872f, 20.752f, 65.861f, 20.741f, 65.872f
6164path.cubicTo(SkBits2Float(0x41a5810e), SkBits2Float(0x4283cedd), SkBits2Float(0x41a4e568), SkBits2Float(0x428406ac), SkBits2Float(0x41a48d57), SkBits2Float(0x42840bcb)); // 20.688f, 65.904f, 20.612f, 66.013f, 20.569f, 66.023f
6165path.lineTo(SkBits2Float(0x41a41ebf), SkBits2Float(0x42840bcb)); // 20.515f, 66.023f
6166path.cubicTo(SkBits2Float(0x41a40838), SkBits2Float(0x4283fb69), SkBits2Float(0x41a3f1b1), SkBits2Float(0x428406ac), SkBits2Float(0x41a3f1b1), SkBits2Float(0x4283fb69)); // 20.504f, 65.991f, 20.493f, 66.013f, 20.493f, 65.991f
6167path.cubicTo(SkBits2Float(0x41a38319), SkBits2Float(0x4283b8da), SkBits2Float(0x41a4b859), SkBits2Float(0x4282f750), SkBits2Float(0x41a4e567), SkBits2Float(0x4282cb48)); // 20.439f, 65.861f, 20.59f, 65.483f, 20.612f, 65.397f
6168path.cubicTo(SkBits2Float(0x41a5ed98), SkBits2Float(0x4281d273), SkBits2Float(0x41a74fe6), SkBits2Float(0x4280ea00), SkBits2Float(0x41a96255), SkBits2Float(0x42802e19)); // 20.741f, 64.911f, 20.914f, 64.457f, 21.173f, 64.09f
6169path.cubicTo(SkBits2Float(0x41aa2b09), SkBits2Float(0x427fccd6), SkBits2Float(0x41ab1ebf), SkBits2Float(0x427f6982), SkBits2Float(0x41abfbef), SkBits2Float(0x427eefa7)); // 21.271f, 63.95f, 21.39f, 63.853f, 21.498f, 63.734f
6170path.cubicTo(SkBits2Float(0x41ac7f01), SkBits2Float(0x427e9690), SkBits2Float(0x41aced99), SkBits2Float(0x427e49c4), SkBits2Float(0x41ad893f), SkBits2Float(0x427e0734)); // 21.562f, 63.647f, 21.616f, 63.572f, 21.692f, 63.507f
6171path.cubicTo(SkBits2Float(0x41aed506), SkBits2Float(0x427d8215), SkBits2Float(0x41b020cc), SkBits2Float(0x427d137e), SkBits2Float(0x41b1831a), SkBits2Float(0x427cbb6d)); // 21.854f, 63.377f, 22.016f, 63.269f, 22.189f, 63.183f
6172path.cubicTo(SkBits2Float(0x41b1f1b2), SkBits2Float(0x427c99a2), SkBits2Float(0x41b26049), SkBits2Float(0x427c6256), SkBits2Float(0x41b2cee1), SkBits2Float(0x427c4cd5)); // 22.243f, 63.15f, 22.297f, 63.096f, 22.351f, 63.075f
6173path.cubicTo(SkBits2Float(0x41b3106a), SkBits2Float(0x427c2b0a), SkBits2Float(0x41b445aa), SkBits2Float(0x427bff02), SkBits2Float(0x41b49dba), SkBits2Float(0x427bde3d)); // 22.383f, 63.042f, 22.534f, 62.999f, 22.577f, 62.967f
6174path.cubicTo(SkBits2Float(0x41b49dba), SkBits2Float(0x427bd2f9), SkBits2Float(0x41b4cac8), SkBits2Float(0x427ba6f1), SkBits2Float(0x41b4cac8), SkBits2Float(0x427ba6f1)); // 22.577f, 62.956f, 22.599f, 62.913f, 22.599f, 62.913f
6175path.cubicTo(SkBits2Float(0x41b4cac8), SkBits2Float(0x427b6462), SkBits2Float(0x41b33b6c), SkBits2Float(0x427a4fe7), SkBits2Float(0x41b2fbef), SkBits2Float(0x427a189b)); // 22.599f, 62.848f, 22.404f, 62.578f, 22.373f, 62.524f
6176path.cubicTo(SkBits2Float(0x41b2cee1), SkBits2Float(0x4279f7d6), SkBits2Float(0x41b19795), SkBits2Float(0x42796774), SkBits2Float(0x41b1560c), SkBits2Float(0x42795c31)); // 22.351f, 62.492f, 22.199f, 62.351f, 22.167f, 62.34f
6177path.cubicTo(SkBits2Float(0x41b0e774), SkBits2Float(0x42793b6c), SkBits2Float(0x41aff3be), SkBits2Float(0x42795c31), SkBits2Float(0x41af70ac), SkBits2Float(0x42795c31)); // 22.113f, 62.308f, 21.994f, 62.34f, 21.93f, 62.34f
6178path.cubicTo(SkBits2Float(0x41ae0e5e), SkBits2Float(0x42796775), SkBits2Float(0x41ac9589), SkBits2Float(0x427946b0), SkBits2Float(0x41ab76d1), SkBits2Float(0x42793b6c)); // 21.757f, 62.351f, 21.573f, 62.319f, 21.433f, 62.308f
6179path.cubicTo(SkBits2Float(0x41aa3f85), SkBits2Float(0x42793028), SkBits2Float(0x41a94ddb), SkBits2Float(0x42793b6c), SkBits2Float(0x41a82d17), SkBits2Float(0x42793028)); // 21.281f, 62.297f, 21.163f, 62.308f, 21.022f, 62.297f
6180path.cubicTo(SkBits2Float(0x41a5c298), SkBits2Float(0x42791aa7), SkBits2Float(0x41a2e775), SkBits2Float(0x4278ed99), SkBits2Float(0x41a07cf6), SkBits2Float(0x4278c190)); // 20.72f, 62.276f, 20.363f, 62.232f, 20.061f, 62.189f
6181path.cubicTo(SkBits2Float(0x419f47b7), SkBits2Float(0x4278b753), SkBits2Float(0x419e810f), SkBits2Float(0x4278b753), SkBits2Float(0x419d4bcf), SkBits2Float(0x4278a0cb)); // 19.91f, 62.179f, 19.813f, 62.179f, 19.662f, 62.157f
6182path.cubicTo(SkBits2Float(0x419c831b), SkBits2Float(0x42788a44), SkBits2Float(0x419b20cd), SkBits2Float(0x42785e3c), SkBits2Float(0x419a45aa), SkBits2Float(0x427847b4)); // 19.564f, 62.135f, 19.391f, 62.092f, 19.284f, 62.07f
6183path.cubicTo(SkBits2Float(0x41949171), SkBits2Float(0x4277e460), SkBits2Float(0x418e5819), SkBits2Float(0x42778c50), SkBits2Float(0x41896a87), SkBits2Float(0x4275dd35)); // 18.571f, 61.973f, 17.793f, 61.887f, 17.177f, 61.466f
6184path.cubicTo(SkBits2Float(0x4182efa6), SkBits2Float(0x4273a8fc), SkBits2Float(0x417fd71a), SkBits2Float(0x42703f83), SkBits2Float(0x4180dd37), SkBits2Float(0x426c5b29)); // 16.367f, 60.915f, 15.99f, 60.062f, 16.108f, 59.089f
6185path.cubicTo(SkBits2Float(0x41813547), SkBits2Float(0x426b5d35), SkBits2Float(0x41821276), SkBits2Float(0x426a8006), SkBits2Float(0x4182560c), SkBits2Float(0x426976cf)); // 16.151f, 58.841f, 16.259f, 58.625f, 16.292f, 58.366f
6186path.cubicTo(SkBits2Float(0x418228fe), SkBits2Float(0x426976cf), SkBits2Float(0x41823f85), SkBits2Float(0x42696b8b), SkBits2Float(0x418228fe), SkBits2Float(0x42694ac7)); // 16.27f, 58.366f, 16.281f, 58.355f, 16.27f, 58.323f
6187path.cubicTo(SkBits2Float(0x4181a5ec), SkBits2Float(0x42696b8c), SkBits2Float(0x41813548), SkBits2Float(0x42696b8c), SkBits2Float(0x41809bae), SkBits2Float(0x4269560b)); // 16.206f, 58.355f, 16.151f, 58.355f, 16.076f, 58.334f
6188path.cubicTo(SkBits2Float(0x4180b235), SkBits2Float(0x4269560b), SkBits2Float(0x4180439e), SkBits2Float(0x426976d0), SkBits2Float(0x4180168f), SkBits2Float(0x42696b8c)); // 16.087f, 58.334f, 16.033f, 58.366f, 16.011f, 58.355f
6189path.cubicTo(SkBits2Float(0x417eccdc), SkBits2Float(0x4269560b), SkBits2Float(0x417e9fce), SkBits2Float(0x4268d0ec), SkBits2Float(0x417f4fef), SkBits2Float(0x42688319)); // 15.925f, 58.334f, 15.914f, 58.204f, 15.957f, 58.128f
6190path.cubicTo(SkBits2Float(0x4180168f), SkBits2Float(0x4268364c), SkBits2Float(0x41849589), SkBits2Float(0x4267a5ea), SkBits2Float(0x4185b441), SkBits2Float(0x42679069)); // 16.011f, 58.053f, 16.573f, 57.912f, 16.713f, 57.891f
6191path.cubicTo(SkBits2Float(0x41891276), SkBits2Float(0x42674296), SkBits2Float(0x418c9dba), SkBits2Float(0x4266df42), SkBits2Float(0x418fd0ed), SkBits2Float(0x4266916f)); // 17.134f, 57.815f, 17.577f, 57.718f, 17.977f, 57.642f
6192path.cubicTo(SkBits2Float(0x4190ae1c), SkBits2Float(0x42668732), SkBits2Float(0x4191333b), SkBits2Float(0x42668732), SkBits2Float(0x4192106a), SkBits2Float(0x426670aa)); // 18.085f, 57.632f, 18.15f, 57.632f, 18.258f, 57.61f
6193path.cubicTo(SkBits2Float(0x4193189b), SkBits2Float(0x42665a23), SkBits2Float(0x4194a5eb), SkBits2Float(0x426622d7), SkBits2Float(0x4195dd37), SkBits2Float(0x42660d56)); // 18.387f, 57.588f, 18.581f, 57.534f, 18.733f, 57.513f
6194path.cubicTo(SkBits2Float(0x41975400), SkBits2Float(0x4265e254), SkBits2Float(0x41988b4b), SkBits2Float(0x4265c18f), SkBits2Float(0x4199d506), SkBits2Float(0x4265ac0e)); // 18.916f, 57.471f, 19.068f, 57.439f, 19.229f, 57.418f
6195path.moveTo(SkBits2Float(0x41a4e568), SkBits2Float(0x4277d0eb)); // 20.612f, 61.954f
6196path.cubicTo(SkBits2Float(0x41a4cee1), SkBits2Float(0x4277d0eb), SkBits2Float(0x41a48d58), SkBits2Float(0x4277f1b0), SkBits2Float(0x41a48d58), SkBits2Float(0x4277f1b0)); // 20.601f, 61.954f, 20.569f, 61.986f, 20.569f, 61.986f
6197path.cubicTo(SkBits2Float(0x41a3831b), SkBits2Float(0x42781275), SkBits2Float(0x41a0c08b), SkBits2Float(0x4277c5a8), SkBits2Float(0x419fe35c), SkBits2Float(0x4277af21)); // 20.439f, 62.018f, 20.094f, 61.943f, 19.986f, 61.921f
6198path.cubicTo(SkBits2Float(0x419dd0ed), SkBits2Float(0x42778319), SkBits2Float(0x419bbc73), SkBits2Float(0x42775711), SkBits2Float(0x4199c08b), SkBits2Float(0x42771481)); // 19.727f, 61.878f, 19.467f, 61.835f, 19.219f, 61.77f
6199path.cubicTo(SkBits2Float(0x4199687b), SkBits2Float(0x4277093d), SkBits2Float(0x4198f7d7), SkBits2Float(0x4276f3bc), SkBits2Float(0x4198b64e), SkBits2Float(0x4276dd35)); // 19.176f, 61.759f, 19.121f, 61.738f, 19.089f, 61.716f
6200path.cubicTo(SkBits2Float(0x419847b6), SkBits2Float(0x4276d1f1), SkBits2Float(0x4198062d), SkBits2Float(0x4276dd35), SkBits2Float(0x4197ae1d), SkBits2Float(0x4276d1f1)); // 19.035f, 61.705f, 19.003f, 61.716f, 18.96f, 61.705f
6201path.cubicTo(SkBits2Float(0x4196fbf0), SkBits2Float(0x4276c6ad), SkBits2Float(0x4196083a), SkBits2Float(0x42768f62), SkBits2Float(0x4195831b), SkBits2Float(0x427679e1)); // 18.873f, 61.694f, 18.754f, 61.64f, 18.689f, 61.619f
6202path.cubicTo(SkBits2Float(0x41951690), SkBits2Float(0x4276635a), SkBits2Float(0x41950009), SkBits2Float(0x427679e1), SkBits2Float(0x4194a5ec), SkBits2Float(0x4276635a)); // 18.636f, 61.597f, 18.625f, 61.619f, 18.581f, 61.597f
6203path.cubicTo(SkBits2Float(0x41940c52), SkBits2Float(0x42764dd9), SkBits2Float(0x41935a25), SkBits2Float(0x4276168d), SkBits2Float(0x4192c08c), SkBits2Float(0x42760006)); // 18.506f, 61.576f, 18.419f, 61.522f, 18.344f, 61.5f
6204path.cubicTo(SkBits2Float(0x4190c298), SkBits2Float(0x42759cb2), SkBits2Float(0x418f6257), SkBits2Float(0x427544a2), SkBits2Float(0x418e2b0b), SkBits2Float(0x42748837)); // 18.095f, 61.403f, 17.923f, 61.317f, 17.771f, 61.133f
6205path.cubicTo(SkBits2Float(0x418e1690), SkBits2Float(0x4274666c), SkBits2Float(0x418dd2fb), SkBits2Float(0x4274666c), SkBits2Float(0x418dbe80), SkBits2Float(0x42745c2f)); // 17.761f, 61.1f, 17.728f, 61.1f, 17.718f, 61.09f
6206path.cubicTo(SkBits2Float(0x418da7f9), SkBits2Float(0x42742f21), SkBits2Float(0x418da7f9), SkBits2Float(0x42740e5c), SkBits2Float(0x418d6670), SkBits2Float(0x4273ed97)); // 17.707f, 61.046f, 17.707f, 61.014f, 17.675f, 60.982f
6207path.cubicTo(SkBits2Float(0x418d22da), SkBits2Float(0x42739fc4), SkBits2Float(0x418ccaca), SkBits2Float(0x427373bc), SkBits2Float(0x418c9dbc), SkBits2Float(0x42731aa5)); // 17.642f, 60.906f, 17.599f, 60.863f, 17.577f, 60.776f
6208path.cubicTo(SkBits2Float(0x418bd714), SkBits2Float(0x4271b95d), SkBits2Float(0x418d22db), SkBits2Float(0x4270999f), SkBits2Float(0x418fd0ef), SkBits2Float(0x4270418e)); // 17.48f, 60.431f, 17.642f, 60.15f, 17.977f, 60.064f
6209path.cubicTo(SkBits2Float(0x41919fc8), SkBits2Float(0x426ffeff), SkBits2Float(0x4193df45), SkBits2Float(0x42701fc3), SkBits2Float(0x4195f3c0), SkBits2Float(0x4270841d)); // 18.203f, 59.999f, 18.484f, 60.031f, 18.744f, 60.129f
6210path.cubicTo(SkBits2Float(0x419847b8), SkBits2Float(0x4270e771), SkBits2Float(0x419a5a26), SkBits2Float(0x42718211), SkBits2Float(0x419bd2fb), SkBits2Float(0x42723231)); // 19.035f, 60.226f, 19.294f, 60.377f, 19.478f, 60.549f
6211path.cubicTo(SkBits2Float(0x419be982), SkBits2Float(0x42723e7b), SkBits2Float(0x419be982), SkBits2Float(0x42726a83), SkBits2Float(0x419c1484), SkBits2Float(0x42726a83)); // 19.489f, 60.561f, 19.489f, 60.604f, 19.51f, 60.604f
6212path.cubicTo(SkBits2Float(0x419c4192), SkBits2Float(0x42728004), SkBits2Float(0x419c831c), SkBits2Float(0x42728004), SkBits2Float(0x419c99a3), SkBits2Float(0x4272968b)); // 19.532f, 60.625f, 19.564f, 60.625f, 19.575f, 60.647f
6213path.cubicTo(SkBits2Float(0x419cdb2c), SkBits2Float(0x4272b750), SkBits2Float(0x419d083b), SkBits2Float(0x4272ee9b), SkBits2Float(0x419d3549), SkBits2Float(0x427325e7)); // 19.607f, 60.679f, 19.629f, 60.733f, 19.651f, 60.787f
6214path.cubicTo(SkBits2Float(0x419e28ff), SkBits2Float(0x4273cbca), SkBits2Float(0x419f062e), SkBits2Float(0x4274666a), SkBits2Float(0x419ff7d8), SkBits2Float(0x42750c4d)); // 19.77f, 60.949f, 19.878f, 61.1f, 19.996f, 61.262f
6215path.cubicTo(SkBits2Float(0x41a0c08c), SkBits2Float(0x42758628), SkBits2Float(0x41a1f5cc), SkBits2Float(0x4275df3f), SkBits2Float(0x41a2d2fb), SkBits2Float(0x42766357)); // 20.094f, 61.381f, 20.245f, 61.468f, 20.353f, 61.597f
6216path.cubicTo(SkBits2Float(0x41a31484), SkBits2Float(0x42769aa3), SkBits2Float(0x41a36c95), SkBits2Float(0x4276f3b9), SkBits2Float(0x41a3db2c), SkBits2Float(0x42771fc1)); // 20.385f, 61.651f, 20.428f, 61.738f, 20.482f, 61.781f
6217path.cubicTo(SkBits2Float(0x41a4083a), SkBits2Float(0x42774bc9), SkBits2Float(0x41a4b85b), SkBits2Float(0x42778315), SkBits2Float(0x41a4e569), SkBits2Float(0x4277af1d)); // 20.504f, 61.824f, 20.59f, 61.878f, 20.612f, 61.921f
6218path.cubicTo(SkBits2Float(0x41a4e569), SkBits2Float(0x4277ba61), SkBits2Float(0x41a4cee2), SkBits2Float(0x4277c5a4), SkBits2Float(0x41a4e569), SkBits2Float(0x4277d0e8)); // 20.612f, 61.932f, 20.601f, 61.943f, 20.612f, 61.954f
6219path.moveTo(SkBits2Float(0x41ad72b9), SkBits2Float(0x42786044)); // 21.681f, 62.094f
6220path.cubicTo(SkBits2Float(0x41ac106b), SkBits2Float(0x42788c4c), SkBits2Float(0x41a9d0ee), SkBits2Float(0x4277d0e8), SkBits2Float(0x41a8b236), SkBits2Float(0x42778e58)); // 21.508f, 62.137f, 21.227f, 61.954f, 21.087f, 61.889f
6221path.cubicTo(SkBits2Float(0x41a2fdfd), SkBits2Float(0x42761689), SkBits2Float(0x41a10215), SkBits2Float(0x42733c6c), SkBits2Float(0x419fb64f), SkBits2Float(0x42704ccf)); // 20.374f, 61.522f, 20.126f, 60.809f, 19.964f, 60.075f
6222path.cubicTo(SkBits2Float(0x419f9fc8), SkBits2Float(0x42700a40), SkBits2Float(0x419f47b7), SkBits2Float(0x426f9ba8), SkBits2Float(0x419f3130), SkBits2Float(0x426f5919)); // 19.953f, 60.01f, 19.91f, 59.902f, 19.899f, 59.837f
6223path.cubicTo(SkBits2Float(0x419f3130), SkBits2Float(0x426f0b46), SkBits2Float(0x419f47b7), SkBits2Float(0x426ec9bd), SkBits2Float(0x419f3130), SkBits2Float(0x426e70a6)); // 19.899f, 59.761f, 19.91f, 59.697f, 19.899f, 59.61f
6224path.cubicTo(SkBits2Float(0x419f1aa9), SkBits2Float(0x426de14a), SkBits2Float(0x419f062e), SkBits2Float(0x426ced94), SkBits2Float(0x419f3130), SkBits2Float(0x426c5d31)); // 19.888f, 59.47f, 19.878f, 59.232f, 19.899f, 59.091f
6225path.cubicTo(SkBits2Float(0x419f72b9), SkBits2Float(0x426befa0), SkBits2Float(0x419fe35d), SkBits2Float(0x426b8108), SkBits2Float(0x41a00e5f), SkBits2Float(0x426b3335)); // 19.931f, 58.984f, 19.986f, 58.876f, 20.007f, 58.8f
6226path.cubicTo(SkBits2Float(0x41a0666f), SkBits2Float(0x426acfe1), SkBits2Float(0x41a10215), SkBits2Float(0x4269c6aa), SkBits2Float(0x41a19dbb), SkBits2Float(0x4269bb66)); // 20.05f, 58.703f, 20.126f, 58.444f, 20.202f, 58.433f
6227path.cubicTo(SkBits2Float(0x41a220cd), SkBits2Float(0x4269bb66), SkBits2Float(0x41a2a5ec), SkBits2Float(0x4269f2b2), SkBits2Float(0x41a31484), SkBits2Float(0x426a3f7f)); // 20.266f, 58.433f, 20.331f, 58.487f, 20.385f, 58.562f
6228path.cubicTo(SkBits2Float(0x41a3c6b1), SkBits2Float(0x426aa3d9), SkBits2Float(0x41a449c3), SkBits2Float(0x426b1cae), SkBits2Float(0x41a476d2), SkBits2Float(0x426b3e79)); // 20.472f, 58.66f, 20.536f, 58.778f, 20.558f, 58.811f
6229path.cubicTo(SkBits2Float(0x41a5ac11), SkBits2Float(0x426c0521), SkBits2Float(0x41a6caca), SkBits2Float(0x426ce250), SkBits2Float(0x41a8189d), SkBits2Float(0x426da9fe)); // 20.709f, 59.005f, 20.849f, 59.221f, 21.012f, 59.416f
6230path.cubicTo(SkBits2Float(0x41aa3f86), SkBits2Float(0x426f1689), SkBits2Float(0x41ac5401), SkBits2Float(0x4270841b), SkBits2Float(0x41ae7aeb), SkBits2Float(0x4271f0a6)); // 21.281f, 59.772f, 21.541f, 60.129f, 21.81f, 60.485f
6231path.cubicTo(SkBits2Float(0x41af000a), SkBits2Float(0x427248b6), SkBits2Float(0x41afb237), SkBits2Float(0x4272a1cd), SkBits2Float(0x41b020ce), SkBits2Float(0x4272ee9a)); // 21.875f, 60.571f, 21.962f, 60.658f, 22.016f, 60.733f
6232path.cubicTo(SkBits2Float(0x41b06257), SkBits2Float(0x42731aa2), SkBits2Float(0x41b19797), SkBits2Float(0x4273f7d1), SkBits2Float(0x41b19797), SkBits2Float(0x4274199c)); // 22.048f, 60.776f, 22.199f, 60.992f, 22.199f, 61.025f
6233path.cubicTo(SkBits2Float(0x41b1c4a5), SkBits2Float(0x427424e0), SkBits2Float(0x41b1831c), SkBits2Float(0x42746669), SkBits2Float(0x41b1831c), SkBits2Float(0x42746669)); // 22.221f, 61.036f, 22.189f, 61.1f, 22.189f, 61.1f
6234path.cubicTo(SkBits2Float(0x41ac3d7a), SkBits2Float(0x42742f1d), SkBits2Float(0x41a96257), SkBits2Float(0x4271ae17), SkBits2Float(0x41a7a7f9), SkBits2Float(0x426fb12a)); // 21.53f, 61.046f, 21.173f, 60.42f, 20.957f, 59.923f
6235path.cubicTo(SkBits2Float(0x41a77cf7), SkBits2Float(0x426f9ba9), SkBits2Float(0x41a73b6e), SkBits2Float(0x426f79de), SkBits2Float(0x41a73b6e), SkBits2Float(0x426f591a)); // 20.936f, 59.902f, 20.904f, 59.869f, 20.904f, 59.837f
6236path.cubicTo(SkBits2Float(0x41a6e151), SkBits2Float(0x426eea82), SkBits2Float(0x41a68941), SkBits2Float(0x426e6564), SkBits2Float(0x41a672ba), SkBits2Float(0x426dec8f)); // 20.86f, 59.729f, 20.817f, 59.599f, 20.806f, 59.481f
6237path.cubicTo(SkBits2Float(0x41a65e3f), SkBits2Float(0x426daa00), SkBits2Float(0x41a68941), SkBits2Float(0x426d71ae), SkBits2Float(0x41a65e3f), SkBits2Float(0x426d50e9)); // 20.796f, 59.416f, 20.817f, 59.361f, 20.796f, 59.329f
6238path.cubicTo(SkBits2Float(0x41a63131), SkBits2Float(0x426d24e1), SkBits2Float(0x41a56a89), SkBits2Float(0x426cf8d9), SkBits2Float(0x41a4fbf1), SkBits2Float(0x426cf8d9)); // 20.774f, 59.286f, 20.677f, 59.243f, 20.623f, 59.243f
6239path.cubicTo(SkBits2Float(0x41a449c4), SkBits2Float(0x426ced95), SkBits2Float(0x41a36c95), SkBits2Float(0x426cf8d9), SkBits2Float(0x41a31484), SkBits2Float(0x426d24e1)); // 20.536f, 59.232f, 20.428f, 59.243f, 20.385f, 59.286f
6240path.cubicTo(SkBits2Float(0x41a20a47), SkBits2Float(0x426d71ae), SkBits2Float(0x41a1f5cc), SkBits2Float(0x426f645e), SkBits2Float(0x41a220ce), SkBits2Float(0x42701fc2)); // 20.255f, 59.361f, 20.245f, 59.848f, 20.266f, 60.031f
6241path.cubicTo(SkBits2Float(0x41a28f66), SkBits2Float(0x4272e45e), SkBits2Float(0x41a4b85b), SkBits2Float(0x4274c9be), SkBits2Float(0x41a7eb8e), SkBits2Float(0x427621ce)); // 20.32f, 60.723f, 20.59f, 61.197f, 20.99f, 61.533f
6242path.cubicTo(SkBits2Float(0x41a82d17), SkBits2Float(0x42764293), SkBits2Float(0x41a870ad), SkBits2Float(0x42764293), SkBits2Float(0x41a8b236), SkBits2Float(0x4276591a)); // 21.022f, 61.565f, 21.055f, 61.565f, 21.087f, 61.587f
6243path.cubicTo(SkBits2Float(0x41a90a46), SkBits2Float(0x427679df), SkBits2Float(0x41a93755), SkBits2Float(0x4276b12a), SkBits2Float(0x41a98f65), SkBits2Float(0x4276c6ab)); // 21.13f, 61.619f, 21.152f, 61.673f, 21.195f, 61.694f
6244path.cubicTo(SkBits2Float(0x41aadb2c), SkBits2Float(0x42774086), SkBits2Float(0x41ac958a), SkBits2Float(0x42778e59), SkBits2Float(0x41adb64e), SkBits2Float(0x427828f9)); // 21.357f, 61.813f, 21.573f, 61.889f, 21.714f, 62.04f
6245path.cubicTo(SkBits2Float(0x41adb64e), SkBits2Float(0x427828f9), SkBits2Float(0x41ad8940), SkBits2Float(0x42786045), SkBits2Float(0x41ad72b8), SkBits2Float(0x42786045)); // 21.714f, 62.04f, 21.692f, 62.094f, 21.681f, 62.094f
6246path.moveTo(SkBits2Float(0x41bd168f), SkBits2Float(0x4267be7a)); // 23.636f, 57.936f
6247path.cubicTo(SkBits2Float(0x41bd168f), SkBits2Float(0x42679caf), SkBits2Float(0x41bd2d16), SkBits2Float(0x4267666a), SkBits2Float(0x41bd168f), SkBits2Float(0x42674fe2)); // 23.636f, 57.903f, 23.647f, 57.85f, 23.636f, 57.828f
6248path.cubicTo(SkBits2Float(0x41bd168f), SkBits2Float(0x4267449e), SkBits2Float(0x41bd0008), SkBits2Float(0x42674fe2), SkBits2Float(0x41bce981), SkBits2Float(0x42672f1d)); // 23.636f, 57.817f, 23.625f, 57.828f, 23.614f, 57.796f
6249path.cubicTo(SkBits2Float(0x41bcd2fa), SkBits2Float(0x42672f1d), SkBits2Float(0x41bc9171), SkBits2Float(0x4267449e), SkBits2Float(0x41bc7ae9), SkBits2Float(0x42672f1d)); // 23.603f, 57.796f, 23.571f, 57.817f, 23.56f, 57.796f
6250path.cubicTo(SkBits2Float(0x41bb9dba), SkBits2Float(0x4267d500), SkBits2Float(0x41bbb441), SkBits2Float(0x42693648), SkBits2Float(0x41bb72b8), SkBits2Float(0x426a1377)); // 23.452f, 57.958f, 23.463f, 58.303f, 23.431f, 58.519f
6251path.cubicTo(SkBits2Float(0x41bb45aa), SkBits2Float(0x426a6c8e), SkBits2Float(0x41bb2f22), SkBits2Float(0x426acfe1), SkBits2Float(0x41bb189b), SkBits2Float(0x426b3335)); // 23.409f, 58.606f, 23.398f, 58.703f, 23.387f, 58.8f
6252path.lineTo(SkBits2Float(0x41baed99), SkBits2Float(0x426b5f3d)); // 23.366f, 58.843f
6253path.cubicTo(SkBits2Float(0x41baac10), SkBits2Float(0x426bd918), SkBits2Float(0x41bac08b), SkBits2Float(0x426c3129), SkBits2Float(0x41baac10), SkBits2Float(0x426cab04)); // 23.334f, 58.962f, 23.344f, 59.048f, 23.334f, 59.167f
6254path.cubicTo(SkBits2Float(0x41ba7f02), SkBits2Float(0x426d50e7), SkBits2Float(0x41ba3b6c), SkBits2Float(0x426e0d52), SkBits2Float(0x41ba106a), SkBits2Float(0x426ec9bc)); // 23.312f, 59.329f, 23.279f, 59.513f, 23.258f, 59.697f
6255path.cubicTo(SkBits2Float(0x41b9ccd4), SkBits2Float(0x426f645c), SkBits2Float(0x41b974c4), SkBits2Float(0x42701fc0), SkBits2Float(0x41b949c2), SkBits2Float(0x4270c5a3)); // 23.225f, 59.848f, 23.182f, 60.031f, 23.161f, 60.193f
6256path.cubicTo(SkBits2Float(0x41b9333b), SkBits2Float(0x42713f7e), SkBits2Float(0x41b98b4b), SkBits2Float(0x4271820d), SkBits2Float(0x41b9f9e3), SkBits2Float(0x4271ae16)); // 23.15f, 60.312f, 23.193f, 60.377f, 23.247f, 60.42f
6257path.cubicTo(SkBits2Float(0x41ba3b6c), SkBits2Float(0x42718d51), SkBits2Float(0x41ba7f02), SkBits2Float(0x4271b95a), SkBits2Float(0x41ba9589), SkBits2Float(0x42716b87)); // 23.279f, 60.388f, 23.312f, 60.431f, 23.323f, 60.355f
6258path.cubicTo(SkBits2Float(0x41baac10), SkBits2Float(0x4271343b), SkBits2Float(0x41ba9589), SkBits2Float(0x4270e76e), SkBits2Float(0x41ba9589), SkBits2Float(0x4270999b)); // 23.334f, 60.301f, 23.323f, 60.226f, 23.323f, 60.15f
6259path.cubicTo(SkBits2Float(0x41ba9589), SkBits2Float(0x4270418b), SkBits2Float(0x41bac08b), SkBits2Float(0x426fd1ed), SkBits2Float(0x41baed99), SkBits2Float(0x426f645c)); // 23.323f, 60.064f, 23.344f, 59.955f, 23.366f, 59.848f
6260path.cubicTo(SkBits2Float(0x41bb2f22), SkBits2Float(0x426e6562), SkBits2Float(0x41bb9dba), SkBits2Float(0x426d3b66), SkBits2Float(0x41bbf5ca), SkBits2Float(0x426c3c6c)); // 23.398f, 59.599f, 23.452f, 59.308f, 23.495f, 59.059f
6261path.cubicTo(SkBits2Float(0x41bc0e5d), SkBits2Float(0x426bb853), SkBits2Float(0x41bc0e5d), SkBits2Float(0x426b5f3d), SkBits2Float(0x41bc22d8), SkBits2Float(0x426ae562)); // 23.507f, 58.93f, 23.507f, 58.843f, 23.517f, 58.724f
6262path.cubicTo(SkBits2Float(0x41bc395f), SkBits2Float(0x426a820e), SkBits2Float(0x41bc9170), SkBits2Float(0x4269f2b2), SkBits2Float(0x41bca7f7), SkBits2Float(0x42698f5e)); // 23.528f, 58.627f, 23.571f, 58.487f, 23.582f, 58.39f
6263path.cubicTo(SkBits2Float(0x41bcd2f9), SkBits2Float(0x426920c6), SkBits2Float(0x41bca7f7), SkBits2Float(0x4268d2f4), SkBits2Float(0x41bcd2f9), SkBits2Float(0x4268645c)); // 23.603f, 58.282f, 23.582f, 58.206f, 23.603f, 58.098f
6264path.cubicTo(SkBits2Float(0x41bcd2f9), SkBits2Float(0x42684291), SkBits2Float(0x41bd168f), SkBits2Float(0x4267df3d), SkBits2Float(0x41bd168f), SkBits2Float(0x4267be79)); // 23.603f, 58.065f, 23.636f, 57.968f, 23.636f, 57.936f
6265path.moveTo(SkBits2Float(0x41bd6e9f), SkBits2Float(0x426e916b)); // 23.679f, 59.642f
6266path.cubicTo(SkBits2Float(0x41bdb028), SkBits2Float(0x426d199c), SkBits2Float(0x41bdf3be), SkBits2Float(0x426bb854), SkBits2Float(0x41be6255), SkBits2Float(0x426a343c)); // 23.711f, 59.275f, 23.744f, 58.93f, 23.798f, 58.551f
6267path.cubicTo(SkBits2Float(0x41be78dc), SkBits2Float(0x4269f2b3), SkBits2Float(0x41bed0ed), SkBits2Float(0x4269841b), SkBits2Float(0x41bed0ed), SkBits2Float(0x4269418c)); // 23.809f, 58.487f, 23.852f, 58.379f, 23.852f, 58.314f
6268path.cubicTo(SkBits2Float(0x41bee774), SkBits2Float(0x4268bc6d), SkBits2Float(0x41bee774), SkBits2Float(0x42684edc), SkBits2Float(0x41bf1276), SkBits2Float(0x4267df3e)); // 23.863f, 58.184f, 23.863f, 58.077f, 23.884f, 57.968f
6269path.cubicTo(SkBits2Float(0x41bf3f84), SkBits2Float(0x4267a7f2), SkBits2Float(0x41bf3f84), SkBits2Float(0x4267872e), SkBits2Float(0x41bf9795), SkBits2Float(0x426770a6)); // 23.906f, 57.914f, 23.906f, 57.882f, 23.949f, 57.86f
6270path.cubicTo(SkBits2Float(0x41c0ccd4), SkBits2Float(0x42675b25), SkBits2Float(0x41c6810e), SkBits2Float(0x4268d2f4), SkBits2Float(0x41c6d91e), SkBits2Float(0x426920c7)); // 24.1f, 57.839f, 24.813f, 58.206f, 24.856f, 58.282f
6271path.cubicTo(SkBits2Float(0x41c7333b), SkBits2Float(0x42696d94), SkBits2Float(0x41c7062c), SkBits2Float(0x4270e76f), SkBits2Float(0x41c6ae1c), SkBits2Float(0x42713f7f)); // 24.9f, 58.357f, 24.878f, 60.226f, 24.835f, 60.312f
6272path.cubicTo(SkBits2Float(0x41c63f84), SkBits2Float(0x4271a2d3), SkBits2Float(0x41c3a7f7), SkBits2Float(0x42716b87), SkBits2Float(0x41c2cac8), SkBits2Float(0x427176cb)); // 24.781f, 60.409f, 24.457f, 60.355f, 24.349f, 60.366f
6273path.cubicTo(SkBits2Float(0x41c2b441), SkBits2Float(0x427176cb), SkBits2Float(0x41c270ab), SkBits2Float(0x4271a2d3), SkBits2Float(0x41c245a9), SkBits2Float(0x4271a2d3)); // 24.338f, 60.366f, 24.305f, 60.409f, 24.284f, 60.409f
6274path.cubicTo(SkBits2Float(0x41c1aa03), SkBits2Float(0x4271b95a), SkBits2Float(0x41c1106a), SkBits2Float(0x4271ae17), SkBits2Float(0x41c05e3c), SkBits2Float(0x4271b95a)); // 24.208f, 60.431f, 24.133f, 60.42f, 24.046f, 60.431f
6275path.cubicTo(SkBits2Float(0x41bf1275), SkBits2Float(0x4271e562), SkBits2Float(0x41be4bcd), SkBits2Float(0x427227f2), SkBits2Float(0x41bcd2f8), SkBits2Float(0x4272322f)); // 23.884f, 60.474f, 23.787f, 60.539f, 23.603f, 60.549f
6276path.cubicTo(SkBits2Float(0x41bc395e), SkBits2Float(0x427128f8), SkBits2Float(0x41bd2d15), SkBits2Float(0x426f8f5e), SkBits2Float(0x41bd6e9e), SkBits2Float(0x426e916a)); // 23.528f, 60.29f, 23.647f, 59.89f, 23.679f, 59.642f
6277path.moveTo(SkBits2Float(0x41d21481), SkBits2Float(0x42700a3f)); // 26.26f, 60.01f
6278path.cubicTo(SkBits2Float(0x41d22b08), SkBits2Float(0x42704cce), SkBits2Float(0x41d299a0), SkBits2Float(0x4270f1ac), SkBits2Float(0x41d2418f), SkBits2Float(0x42713f7e)); // 26.271f, 60.075f, 26.325f, 60.236f, 26.282f, 60.312f
6279path.cubicTo(SkBits2Float(0x41d2418f), SkBits2Float(0x42714ac2), SkBits2Float(0x41d22b08), SkBits2Float(0x42713f7e), SkBits2Float(0x41d21481), SkBits2Float(0x42715605)); // 26.282f, 60.323f, 26.271f, 60.312f, 26.26f, 60.334f
6280path.cubicTo(SkBits2Float(0x41d1bc71), SkBits2Float(0x42715605), SkBits2Float(0x41d1916f), SkBits2Float(0x42715605), SkBits2Float(0x41d1395e), SkBits2Float(0x42714ac1)); // 26.217f, 60.334f, 26.196f, 60.334f, 26.153f, 60.323f
6281path.cubicTo(SkBits2Float(0x41d0b233), SkBits2Float(0x42708419), SkBits2Float(0x41d0c8ba), SkBits2Float(0x426f645b), SkBits2Float(0x41d09db8), SkBits2Float(0x426e5a1d)); // 26.087f, 60.129f, 26.098f, 59.848f, 26.077f, 59.588f
6282path.cubicTo(SkBits2Float(0x41d09db8), SkBits2Float(0x426e23d7), SkBits2Float(0x41d05a22), SkBits2Float(0x426d9375), SkBits2Float(0x41d070aa), SkBits2Float(0x426d50e6)); // 26.077f, 59.535f, 26.044f, 59.394f, 26.055f, 59.329f
6283path.cubicTo(SkBits2Float(0x41d09db8), SkBits2Float(0x426d3b65), SkBits2Float(0x41d0b233), SkBits2Float(0x426d50e6), SkBits2Float(0x41d0b233), SkBits2Float(0x426d2f1b)); // 26.077f, 59.308f, 26.087f, 59.329f, 26.087f, 59.296f
6284path.cubicTo(SkBits2Float(0x41d1395e), SkBits2Float(0x426d3b65), SkBits2Float(0x41d14dd9), SkBits2Float(0x426d2f1b), SkBits2Float(0x41d1916e), SkBits2Float(0x426d50e6)); // 26.153f, 59.308f, 26.163f, 59.296f, 26.196f, 59.329f
6285path.cubicTo(SkBits2Float(0x41d1a5e9), SkBits2Float(0x426d50e6), SkBits2Float(0x41d1e97e), SkBits2Float(0x426de148), SkBits2Float(0x41d1e97e), SkBits2Float(0x426dec8c)); // 26.206f, 59.329f, 26.239f, 59.47f, 26.239f, 59.481f
6286path.cubicTo(SkBits2Float(0x41d22b07), SkBits2Float(0x426e9cad), SkBits2Float(0x41d1e97e), SkBits2Float(0x426f4dd4), SkBits2Float(0x41d21480), SkBits2Float(0x42700a3e)); // 26.271f, 59.653f, 26.239f, 59.826f, 26.26f, 60.01f
6287path.moveTo(SkBits2Float(0x41ee1274), SkBits2Float(0x42564ac1)); // 29.759f, 53.573f
6288path.cubicTo(SkBits2Float(0x41ee1274), SkBits2Float(0x42566b86), SkBits2Float(0x41ee3f82), SkBits2Float(0x4256c49c), SkBits2Float(0x41ee28fb), SkBits2Float(0x4256fbe8)); // 29.759f, 53.605f, 29.781f, 53.692f, 29.77f, 53.746f
6289path.cubicTo(SkBits2Float(0x41ee28fb), SkBits2Float(0x42571cad), SkBits2Float(0x41ede772), SkBits2Float(0x425748b5), SkBits2Float(0x41ede772), SkBits2Float(0x42576a80)); // 29.77f, 53.778f, 29.738f, 53.821f, 29.738f, 53.854f
6290path.cubicTo(SkBits2Float(0x41ed8f62), SkBits2Float(0x425774bd), SkBits2Float(0x41ed20ca), SkBits2Float(0x42579688), SkBits2Float(0x41ec6e9d), SkBits2Float(0x42579688)); // 29.695f, 53.864f, 29.641f, 53.897f, 29.554f, 53.897f
6291path.cubicTo(SkBits2Float(0x41ebeb8b), SkBits2Float(0x42579688), SkBits2Float(0x41eb666c), SkBits2Float(0x425774bd), SkBits2Float(0x41eaf7d4), SkBits2Float(0x42576a80)); // 29.49f, 53.897f, 29.425f, 53.864f, 29.371f, 53.854f
6292path.cubicTo(SkBits2Float(0x41eacac6), SkBits2Float(0x425676ca), SkBits2Float(0x41eb666c), SkBits2Float(0x42556d92), SkBits2Float(0x41ebbe7c), SkBits2Float(0x42549063)); // 29.349f, 53.616f, 29.425f, 53.357f, 29.468f, 53.141f
6293path.cubicTo(SkBits2Float(0x41ebd503), SkBits2Float(0x425421cb), SkBits2Float(0x41ebd503), SkBits2Float(0x4253d3f9), SkBits2Float(0x41ec0005), SkBits2Float(0x42537be8)); // 29.479f, 53.033f, 29.479f, 52.957f, 29.5f, 52.871f
6294path.cubicTo(SkBits2Float(0x41ec2d13), SkBits2Float(0x42535a1d), SkBits2Float(0x41ec6e9d), SkBits2Float(0x42531894), SkBits2Float(0x41ecb232), SkBits2Float(0x42531894)); // 29.522f, 52.838f, 29.554f, 52.774f, 29.587f, 52.774f
6295path.cubicTo(SkBits2Float(0x41ed3544), SkBits2Float(0x4253020d), SkBits2Float(0x41edd0ea), SkBits2Float(0x42531894), SkBits2Float(0x41ede771), SkBits2Float(0x4253449c)); // 29.651f, 52.752f, 29.727f, 52.774f, 29.738f, 52.817f
6296path.cubicTo(SkBits2Float(0x41ee1273), SkBits2Float(0x42534fe0), SkBits2Float(0x41ede771), SkBits2Float(0x42536561), SkBits2Float(0x41ede771), SkBits2Float(0x42537be8)); // 29.759f, 52.828f, 29.738f, 52.849f, 29.738f, 52.871f
6297path.cubicTo(SkBits2Float(0x41ee3f81), SkBits2Float(0x42544290), SkBits2Float(0x41ede771), SkBits2Float(0x42554ccd), SkBits2Float(0x41ee1273), SkBits2Float(0x42564ac1)); // 29.781f, 53.065f, 29.738f, 53.325f, 29.759f, 53.573f
6298path.moveTo(SkBits2Float(0x41f51273), SkBits2Float(0x4258cbc7)); // 30.634f, 54.199f
6299path.cubicTo(SkBits2Float(0x41f4e771), SkBits2Float(0x4259199a), SkBits2Float(0x41f3b025), SkBits2Float(0x4259bf7d), SkBits2Float(0x41f35815), SkBits2Float(0x4259eb85)); // 30.613f, 54.275f, 30.461f, 54.437f, 30.418f, 54.48f
6300path.cubicTo(SkBits2Float(0x41f2395d), SkBits2Float(0x425aa6e9), SkBits2Float(0x41f2395d), SkBits2Float(0x425a449c), SkBits2Float(0x41f222d6), SkBits2Float(0x42596666)); // 30.278f, 54.663f, 30.278f, 54.567f, 30.267f, 54.35f
6301path.cubicTo(SkBits2Float(0x41f222d6), SkBits2Float(0x425945a1), SkBits2Float(0x41f1f5c8), SkBits2Float(0x4258e24d), SkBits2Float(0x41f222d6), SkBits2Float(0x4258ab02)); // 30.267f, 54.318f, 30.245f, 54.221f, 30.267f, 54.167f
6302path.cubicTo(SkBits2Float(0x41f2395d), SkBits2Float(0x42589fbe), SkBits2Float(0x41f2e97e), SkBits2Float(0x42588a3d), SkBits2Float(0x41f30005), SkBits2Float(0x425873b6)); // 30.278f, 54.156f, 30.364f, 54.135f, 30.375f, 54.113f
6303path.cubicTo(SkBits2Float(0x41f3b026), SkBits2Float(0x42586872), SkBits2Float(0x41f48d55), SkBits2Float(0x42588937), SkBits2Float(0x41f51274), SkBits2Float(0x4258947b)); // 30.461f, 54.102f, 30.569f, 54.134f, 30.634f, 54.145f
6304path.cubicTo(SkBits2Float(0x41f4fdf9), SkBits2Float(0x42589fbf), SkBits2Float(0x41f51274), SkBits2Float(0x4258b646), SkBits2Float(0x41f51274), SkBits2Float(0x4258cbc7)); // 30.624f, 54.156f, 30.634f, 54.178f, 30.634f, 54.199f
6305path.moveTo(SkBits2Float(0x41f20e5b), SkBits2Float(0x425727f0)); // 30.257f, 53.789f
6306path.cubicTo(SkBits2Float(0x41f1cac5), SkBits2Float(0x4256da1d), SkBits2Float(0x41f222d6), SkBits2Float(0x42561375), SkBits2Float(0x41f222d6), SkBits2Float(0x4255d0e6)); // 30.224f, 53.713f, 30.267f, 53.519f, 30.267f, 53.454f
6307path.cubicTo(SkBits2Float(0x41f222d6), SkBits2Float(0x42553646), SkBits2Float(0x41f1b43e), SkBits2Float(0x4254374c), SkBits2Float(0x41f20e5b), SkBits2Float(0x42539169)); // 30.267f, 53.303f, 30.213f, 53.054f, 30.257f, 52.892f
6308path.cubicTo(SkBits2Float(0x41f222d6), SkBits2Float(0x42536561), SkBits2Float(0x41f2916d), SkBits2Float(0x4253449c), SkBits2Float(0x41f2be7c), SkBits2Float(0x4253449c)); // 30.267f, 52.849f, 30.321f, 52.817f, 30.343f, 52.817f
6309path.cubicTo(SkBits2Float(0x41f3b026), SkBits2Float(0x42532e15), SkBits2Float(0x41f845a7), SkBits2Float(0x42539cac), SkBits2Float(0x41f88730), SkBits2Float(0x4253d3f8)); // 30.461f, 52.795f, 31.034f, 52.903f, 31.066f, 52.957f
6310path.cubicTo(SkBits2Float(0x41f8cac6), SkBits2Float(0x42540000), SkBits2Float(0x41f8cac6), SkBits2Float(0x42544290), SkBits2Float(0x41f8e14d), SkBits2Float(0x4254851f)); // 31.099f, 53, 31.099f, 53.065f, 31.11f, 53.13f
6311path.cubicTo(SkBits2Float(0x41f8f5c8), SkBits2Float(0x4254d1ec), SkBits2Float(0x41f97ae7), SkBits2Float(0x425578d5), SkBits2Float(0x41f9666c), SkBits2Float(0x4255e76d)); // 31.12f, 53.205f, 31.185f, 53.368f, 31.175f, 53.476f
6312path.cubicTo(SkBits2Float(0x41f94dd9), SkBits2Float(0x42561375), SkBits2Float(0x41f88731), SkBits2Float(0x4256a2d1), SkBits2Float(0x41f85c2f), SkBits2Float(0x4256c49c)); // 31.163f, 53.519f, 31.066f, 53.659f, 31.045f, 53.692f
6313path.cubicTo(SkBits2Float(0x41f845a8), SkBits2Float(0x4256da1d), SkBits2Float(0x41f7d710), SkBits2Float(0x4256f0a4), SkBits2Float(0x41f7d710), SkBits2Float(0x4256fbe8)); // 31.034f, 53.713f, 30.98f, 53.735f, 30.98f, 53.746f
6314path.lineTo(SkBits2Float(0x41f7d710), SkBits2Float(0x42571cad)); // 30.98f, 53.778f
6315path.cubicTo(SkBits2Float(0x41f79587), SkBits2Float(0x4257322e), SkBits2Float(0x41f73b6a), SkBits2Float(0x425748b5), SkBits2Float(0x41f6f9e1), SkBits2Float(0x42575f3c)); // 30.948f, 53.799f, 30.904f, 53.821f, 30.872f, 53.843f
6316path.cubicTo(SkBits2Float(0x41f6062b), SkBits2Float(0x425774bd), SkBits2Float(0x41f2395e), SkBits2Float(0x425774bd), SkBits2Float(0x41f20e5c), SkBits2Float(0x425727f0)); // 30.753f, 53.864f, 30.278f, 53.864f, 30.257f, 53.789f
6317path.moveTo(SkBits2Float(0x42048f5f), SkBits2Float(0x426b072b)); // 33.14f, 58.757f
6318path.cubicTo(SkBits2Float(0x42046d94), SkBits2Float(0x426acfdf), SkBits2Float(0x42048f5f), SkBits2Float(0x426ab958), SkBits2Float(0x420478d8), SkBits2Float(0x426a77cf)); // 33.107f, 58.703f, 33.14f, 58.681f, 33.118f, 58.617f
6319path.cubicTo(SkBits2Float(0x42045813), SkBits2Float(0x4269d0e6), SkBits2Float(0x42042c0b), SkBits2Float(0x42693646), SkBits2Float(0x42041584), SkBits2Float(0x4268851f)); // 33.086f, 58.454f, 33.043f, 58.303f, 33.021f, 58.13f
6320path.cubicTo(SkBits2Float(0x4203e97c), SkBits2Float(0x4267c9bb), SkBits2Float(0x42039caf), SkBits2Float(0x42670d50), SkBits2Float(0x4203a6ec), SkBits2Float(0x426624dd)); // 32.978f, 57.947f, 32.903f, 57.763f, 32.913f, 57.536f
6321path.cubicTo(SkBits2Float(0x4203a6ec), SkBits2Float(0x426624dd), SkBits2Float(0x4203de38), SkBits2Float(0x4265f8d5), SkBits2Float(0x4203e97b), SkBits2Float(0x4265f8d5)); // 32.913f, 57.536f, 32.967f, 57.493f, 32.978f, 57.493f
6322path.cubicTo(SkBits2Float(0x42042c0a), SkBits2Float(0x4265ee98), SkBits2Float(0x4204c6aa), SkBits2Float(0x4266199a), SkBits2Float(0x4204e875), SkBits2Float(0x42663b64)); // 33.043f, 57.483f, 33.194f, 57.525f, 33.227f, 57.558f
6323path.cubicTo(SkBits2Float(0x42051ebb), SkBits2Float(0x42668937), SkBits2Float(0x42051ebb), SkBits2Float(0x42671893), SkBits2Float(0x42054085), SkBits2Float(0x426770a3)); // 33.28f, 57.634f, 33.28f, 57.774f, 33.313f, 57.86f
6324path.cubicTo(SkBits2Float(0x42058314), SkBits2Float(0x4268a6e9), SkBits2Float(0x4206072d), SkBits2Float(0x4269d0e5), SkBits2Float(0x42061271), SkBits2Float(0x426b3e76)); // 33.378f, 58.163f, 33.507f, 58.454f, 33.518f, 58.811f
6325path.cubicTo(SkBits2Float(0x4205e669), SkBits2Float(0x426b3e76), SkBits2Float(0x4205e669), SkBits2Float(0x426b49ba), SkBits2Float(0x4205b95a), SkBits2Float(0x426b5f3b)); // 33.475f, 58.811f, 33.475f, 58.822f, 33.431f, 58.843f
6326path.cubicTo(SkBits2Float(0x42056c8d), SkBits2Float(0x426b5f3b), SkBits2Float(0x4204e875), SkBits2Float(0x426b75c2), SkBits2Float(0x4204b023), SkBits2Float(0x426b49ba)); // 33.356f, 58.843f, 33.227f, 58.865f, 33.172f, 58.822f
6327path.lineTo(SkBits2Float(0x4204b023), SkBits2Float(0x426b3333)); // 33.172f, 58.8f
6328path.cubicTo(SkBits2Float(0x4204b023), SkBits2Float(0x426b27ef), SkBits2Float(0x42048f5e), SkBits2Float(0x426b072b), SkBits2Float(0x42048f5e), SkBits2Float(0x426b072b)); // 33.172f, 58.789f, 33.14f, 58.757f, 33.14f, 58.757f
6329path.moveTo(SkBits2Float(0x42035918), SkBits2Float(0x426b6a7f)); // 32.837f, 58.854f
6330path.cubicTo(SkBits2Float(0x42032d10), SkBits2Float(0x426b6a7f), SkBits2Float(0x42030108), SkBits2Float(0x426b75c3), SkBits2Float(0x4202d4ff), SkBits2Float(0x426b75c3)); // 32.794f, 58.854f, 32.751f, 58.865f, 32.708f, 58.865f
6331path.cubicTo(SkBits2Float(0x42026667), SkBits2Float(0x426b75c3), SkBits2Float(0x42020d51), SkBits2Float(0x426b5f3c), SkBits2Float(0x4201ec8c), SkBits2Float(0x426b27f0)); // 32.6f, 58.865f, 32.513f, 58.843f, 32.481f, 58.789f
6332path.cubicTo(SkBits2Float(0x4201cbc7), SkBits2Float(0x426ae561), SkBits2Float(0x4201cbc7), SkBits2Float(0x426a6c8c), SkBits2Float(0x4201b540), SkBits2Float(0x426a0832)); // 32.449f, 58.724f, 32.449f, 58.606f, 32.427f, 58.508f
6333path.cubicTo(SkBits2Float(0x42018938), SkBits2Float(0x426920c5), SkBits2Float(0x42016873), SkBits2Float(0x42683853), SkBits2Float(0x42013021), SkBits2Float(0x42672f1b)); // 32.384f, 58.282f, 32.352f, 58.055f, 32.297f, 57.796f
6334path.cubicTo(SkBits2Float(0x42013021), SkBits2Float(0x4267020d), SkBits2Float(0x4200f9db), SkBits2Float(0x42669375), SkBits2Float(0x4200f9db), SkBits2Float(0x426651ec)); // 32.297f, 57.752f, 32.244f, 57.644f, 32.244f, 57.58f
6335path.cubicTo(SkBits2Float(0x42010418), SkBits2Float(0x4266199a), SkBits2Float(0x420151eb), SkBits2Float(0x4265ee98), SkBits2Float(0x42018937), SkBits2Float(0x4265ee98)); // 32.254f, 57.525f, 32.33f, 57.483f, 32.384f, 57.483f
6336path.cubicTo(SkBits2Float(0x4201e147), SkBits2Float(0x4265e24e), SkBits2Float(0x42022f1a), SkBits2Float(0x4265ee98), SkBits2Float(0x42023a5e), SkBits2Float(0x4266199a)); // 32.47f, 57.471f, 32.546f, 57.483f, 32.557f, 57.525f
6337path.cubicTo(SkBits2Float(0x420271aa), SkBits2Float(0x42665c29), SkBits2Float(0x42027be7), SkBits2Float(0x42670d50), SkBits2Float(0x42029db2), SkBits2Float(0x426770a4)); // 32.611f, 57.59f, 32.621f, 57.763f, 32.654f, 57.86f
6338path.cubicTo(SkBits2Float(0x42029db2), SkBits2Float(0x4267be77), SkBits2Float(0x4202d4fe), SkBits2Float(0x4268178d), SkBits2Float(0x4202e041), SkBits2Float(0x42684ed9)); // 32.654f, 57.936f, 32.708f, 58.023f, 32.719f, 58.077f
6339path.cubicTo(SkBits2Float(0x4202ea7e), SkBits2Float(0x4268bc6a), SkBits2Float(0x4202ea7e), SkBits2Float(0x4268fefa), SkBits2Float(0x42030106), SkBits2Float(0x42695810)); // 32.729f, 58.184f, 32.729f, 58.249f, 32.751f, 58.336f
6340path.cubicTo(SkBits2Float(0x420322d1), SkBits2Float(0x4269fced), SkBits2Float(0x4203645a), SkBits2Float(0x426a820c), SkBits2Float(0x4203645a), SkBits2Float(0x426b49ba)); // 32.784f, 58.497f, 32.848f, 58.627f, 32.848f, 58.822f
6341path.cubicTo(SkBits2Float(0x42034395), SkBits2Float(0x426b49ba), SkBits2Float(0x42035916), SkBits2Float(0x426b49ba), SkBits2Float(0x42035916), SkBits2Float(0x426b6a7f)); // 32.816f, 58.822f, 32.837f, 58.822f, 32.837f, 58.854f
6342path.moveTo(SkBits2Float(0x42009580), SkBits2Float(0x426b6a7f)); // 32.146f, 58.854f
6343path.lineTo(SkBits2Float(0x42008b43), SkBits2Float(0x426b8106)); // 32.136f, 58.876f
6344path.cubicTo(SkBits2Float(0x42007fff), SkBits2Float(0x426b8106), SkBits2Float(0x42005e35), SkBits2Float(0x426b75c2), SkBits2Float(0x420048b4), SkBits2Float(0x426b8106)); // 32.125f, 58.876f, 32.092f, 58.865f, 32.071f, 58.876f
6345path.cubicTo(SkBits2Float(0x41fdcccc), SkBits2Float(0x426bad0e), SkBits2Float(0x41f94dd2), SkBits2Float(0x426b8c4a), SkBits2Float(0x41f6cccc), SkBits2Float(0x426b8c4a)); // 31.725f, 58.919f, 31.163f, 58.887f, 30.85f, 58.887f
6346path.cubicTo(SkBits2Float(0x41f65e34), SkBits2Float(0x426b8106), SkBits2Float(0x41f39ba5), SkBits2Float(0x426b8106), SkBits2Float(0x41f35810), SkBits2Float(0x426b49bb)); // 30.796f, 58.876f, 30.451f, 58.876f, 30.418f, 58.822f
6347path.cubicTo(SkBits2Float(0x41f35810), SkBits2Float(0x426b3334), SkBits2Float(0x41f2e978), SkBits2Float(0x4267926f), SkBits2Float(0x41f31687), SkBits2Float(0x426723d8)); // 30.418f, 58.8f, 30.364f, 57.893f, 30.386f, 57.785f
6348path.lineTo(SkBits2Float(0x41f36e97), SkBits2Float(0x4266ec8c)); // 30.429f, 57.731f
6349path.cubicTo(SkBits2Float(0x41f3f3b6), SkBits2Float(0x4266b540), SkBits2Float(0x41f4d0e5), SkBits2Float(0x4266b540), SkBits2Float(0x41f58106), SkBits2Float(0x42669eb9)); // 30.494f, 57.677f, 30.602f, 57.677f, 30.688f, 57.655f
6350path.cubicTo(SkBits2Float(0x41f7ed91), SkBits2Float(0x42663b65), SkBits2Float(0x41fac6a8), SkBits2Float(0x4265ee98), SkBits2Float(0x41fdb646), SkBits2Float(0x4265d811)); // 30.991f, 57.558f, 31.347f, 57.483f, 31.714f, 57.461f
6351path.cubicTo(SkBits2Float(0x41fe51ec), SkBits2Float(0x4265c18a), SkBits2Float(0x41ff2f1b), SkBits2Float(0x4265d811), SkBits2Float(0x41ff872b), SkBits2Float(0x4265f8d6)); // 31.79f, 57.439f, 31.898f, 57.461f, 31.941f, 57.493f
6352path.cubicTo(SkBits2Float(0x41ffb439), SkBits2Float(0x4266199b), SkBits2Float(0x41ffb439), SkBits2Float(0x42669eb9), SkBits2Float(0x41ffdf3b), SkBits2Float(0x4266d605)); // 31.963f, 57.525f, 31.963f, 57.655f, 31.984f, 57.709f
6353path.cubicTo(SkBits2Float(0x41fff5c2), SkBits2Float(0x42670d51), SkBits2Float(0x42001cac), SkBits2Float(0x42675b24), SkBits2Float(0x42001cac), SkBits2Float(0x4267926f)); // 31.995f, 57.763f, 32.028f, 57.839f, 32.028f, 57.893f
6354path.cubicTo(SkBits2Float(0x42003d71), SkBits2Float(0x42684290), SkBits2Float(0x420048b4), SkBits2Float(0x4268c7ae), SkBits2Float(0x42005e35), SkBits2Float(0x42696d92)); // 32.06f, 58.065f, 32.071f, 58.195f, 32.092f, 58.357f
6355path.cubicTo(SkBits2Float(0x42008000), SkBits2Float(0x4269d0e6), SkBits2Float(0x4200ac08), SkBits2Float(0x426a5605), SkBits2Float(0x4200b74c), SkBits2Float(0x426acfe0)); // 32.125f, 58.454f, 32.168f, 58.584f, 32.179f, 58.703f
6356path.cubicTo(SkBits2Float(0x4200c189), SkBits2Float(0x426b072c), SkBits2Float(0x4200b74c), SkBits2Float(0x426b49bb), SkBits2Float(0x42009581), SkBits2Float(0x426b6a80)); // 32.189f, 58.757f, 32.179f, 58.822f, 32.146f, 58.854f
6357path.moveTo(SkBits2Float(0x41eeae14), SkBits2Float(0x426bef9f)); // 29.835f, 58.984f
6358path.cubicTo(SkBits2Float(0x41ee8312), SkBits2Float(0x426c26eb), SkBits2Float(0x41ed353f), SkBits2Float(0x426c52f3), SkBits2Float(0x41ecc8b4), SkBits2Float(0x426c73b8)); // 29.814f, 59.038f, 29.651f, 59.081f, 29.598f, 59.113f
6359path.cubicTo(SkBits2Float(0x41eb7ae1), SkBits2Float(0x426cd70c), SkBits2Float(0x41ea3127), SkBits2Float(0x426d9376), SkBits2Float(0x41e96872), SkBits2Float(0x426e2e16)); // 29.435f, 59.21f, 29.274f, 59.394f, 29.176f, 59.545f
6360path.cubicTo(SkBits2Float(0x41e88b43), SkBits2Float(0x426ed3f9), SkBits2Float(0x41e7c49b), SkBits2Float(0x426fdd31), SkBits2Float(0x41e6a5e3), SkBits2Float(0x4270570c)); // 29.068f, 59.707f, 28.971f, 59.966f, 28.831f, 60.085f
6361path.cubicTo(SkBits2Float(0x41e678d5), SkBits2Float(0x427078d7), SkBits2Float(0x41e6624d), SkBits2Float(0x42706d93), SkBits2Float(0x41e620c4), SkBits2Float(0x427078d7)); // 28.809f, 60.118f, 28.798f, 60.107f, 28.766f, 60.118f
6362path.cubicTo(SkBits2Float(0x41e60a3d), SkBits2Float(0x4270841b), SkBits2Float(0x41e5f3b6), SkBits2Float(0x4270999c), SkBits2Float(0x41e5f3b6), SkBits2Float(0x4270999c)); // 28.755f, 60.129f, 28.744f, 60.15f, 28.744f, 60.15f
6363path.cubicTo(SkBits2Float(0x41e52d0e), SkBits2Float(0x4270d0e8), SkBits2Float(0x41e49374), SkBits2Float(0x4270e76f), SkBits2Float(0x41e39fbe), SkBits2Float(0x4270fcf0)); // 28.647f, 60.204f, 28.572f, 60.226f, 28.453f, 60.247f
6364path.cubicTo(SkBits2Float(0x41e2c28f), SkBits2Float(0x42711377), SkBits2Float(0x41e1a1ca), SkBits2Float(0x42714ac3), SkBits2Float(0x41e03f7c), SkBits2Float(0x4271343c)); // 28.345f, 60.269f, 28.204f, 60.323f, 28.031f, 60.301f
6365path.cubicTo(SkBits2Float(0x41de2d0d), SkBits2Float(0x42711377), SkBits2Float(0x41e0c49b), SkBits2Float(0x426e9caf), SkBits2Float(0x41e149b9), SkBits2Float(0x426e23da)); // 27.772f, 60.269f, 28.096f, 59.653f, 28.161f, 59.535f
6366path.cubicTo(SkBits2Float(0x41e23d6f), SkBits2Float(0x426d2f1e), SkBits2Float(0x41e38936), SkBits2Float(0x426c52f5), SkBits2Float(0x41e4eb84), SkBits2Float(0x426b8109)); // 28.28f, 59.296f, 28.442f, 59.081f, 28.615f, 58.876f
6367path.cubicTo(SkBits2Float(0x41e55a1c), SkBits2Float(0x426b49bd), SkBits2Float(0x41e5dd2e), SkBits2Float(0x426b1caf), SkBits2Float(0x41e6624d), SkBits2Float(0x426ae563)); // 28.669f, 58.822f, 28.733f, 58.778f, 28.798f, 58.724f
6368path.cubicTo(SkBits2Float(0x41e78312), SkBits2Float(0x426a77d2), SkBits2Float(0x41e88b43), SkBits2Float(0x4269fcf0), SkBits2Float(0x41e99580), SkBits2Float(0x42698f5f)); // 28.939f, 58.617f, 29.068f, 58.497f, 29.198f, 58.39f
6369path.cubicTo(SkBits2Float(0x41ea3126), SkBits2Float(0x42695813), SkBits2Float(0x41edd0e4), SkBits2Float(0x4267a7f2), SkBits2Float(0x41eeae13), SkBits2Float(0x42684292)); // 29.274f, 58.336f, 29.727f, 57.914f, 29.835f, 58.065f
6370path.cubicTo(SkBits2Float(0x41eeae13), SkBits2Float(0x42684292), SkBits2Float(0x41eec49a), SkBits2Float(0x42684edc), SkBits2Float(0x41eec49a), SkBits2Float(0x42685919)); // 29.835f, 58.065f, 29.846f, 58.077f, 29.846f, 58.087f
6371path.cubicTo(SkBits2Float(0x41ef0623), SkBits2Float(0x4268a6ec), SkBits2Float(0x41eedb21), SkBits2Float(0x426bb854), SkBits2Float(0x41eeae13), SkBits2Float(0x426befa0)); // 29.878f, 58.163f, 29.857f, 58.93f, 29.835f, 58.984f
6372path.moveTo(SkBits2Float(0x41eaf7cd), SkBits2Float(0x4258947d)); // 29.371f, 54.145f
6373path.cubicTo(SkBits2Float(0x41ebd4fc), SkBits2Float(0x425873b8), SkBits2Float(0x41ed353e), SkBits2Float(0x42589fc1), SkBits2Float(0x41edba5c), SkBits2Float(0x4258ab04)); // 29.479f, 54.113f, 29.651f, 54.156f, 29.716f, 54.167f
6374path.cubicTo(SkBits2Float(0x41ede76a), SkBits2Float(0x4259c9bc), SkBits2Float(0x41ee3f7b), SkBits2Float(0x425b6e9a), SkBits2Float(0x41ee126c), SkBits2Float(0x425c8314)); // 29.738f, 54.447f, 29.781f, 54.858f, 29.759f, 55.128f
6375path.cubicTo(SkBits2Float(0x41ede76a), SkBits2Float(0x425d343b), SkBits2Float(0x41ee5602), SkBits2Float(0x425dda1e), SkBits2Float(0x41edd0e3), SkBits2Float(0x425e74be)); // 29.738f, 55.301f, 29.792f, 55.463f, 29.727f, 55.614f
6376path.cubicTo(SkBits2Float(0x41ed624b), SkBits2Float(0x425f1aa1), SkBits2Float(0x41ec6e95), SkBits2Float(0x425f947c), SkBits2Float(0x41ebd4fc), SkBits2Float(0x426023d9)); // 29.673f, 55.776f, 29.554f, 55.895f, 29.479f, 56.035f
6377path.cubicTo(SkBits2Float(0x41eb22cf), SkBits2Float(0x4260c9bc), SkBits2Float(0x41ea5c27), SkBits2Float(0x4261645c), SkBits2Float(0x41e9957f), SkBits2Float(0x42621583)); // 29.392f, 56.197f, 29.295f, 56.348f, 29.198f, 56.521f
6378path.cubicTo(SkBits2Float(0x41e8e55e), SkBits2Float(0x4262c6aa), SkBits2Float(0x41e849b8), SkBits2Float(0x42638314), SkBits2Float(0x41e78310), SkBits2Float(0x426427f2)); // 29.112f, 56.694f, 29.036f, 56.878f, 28.939f, 57.039f
6379path.cubicTo(SkBits2Float(0x41e72b00), SkBits2Float(0x42646b88), SkBits2Float(0x41e6e76a), SkBits2Float(0x4264b854), SkBits2Float(0x41e68f5a), SkBits2Float(0x4264efa0)); // 28.896f, 57.105f, 28.863f, 57.18f, 28.82f, 57.234f
6380path.cubicTo(SkBits2Float(0x41e6624c), SkBits2Float(0x42651ba8), SkBits2Float(0x41e60a3b), SkBits2Float(0x4265322f), SkBits2Float(0x41e5dd2d), SkBits2Float(0x426552f4)); // 28.798f, 57.277f, 28.755f, 57.299f, 28.733f, 57.331f
6381path.cubicTo(SkBits2Float(0x41e570a2), SkBits2Float(0x4264ad11), SkBits2Float(0x41e620c3), SkBits2Float(0x4263c49e), SkBits2Float(0x41e6624c), SkBits2Float(0x426329fe)); // 28.68f, 57.169f, 28.766f, 56.942f, 28.798f, 56.791f
6382path.cubicTo(SkBits2Float(0x41e6a5e2), SkBits2Float(0x4262418b), SkBits2Float(0x41e6e76b), SkBits2Float(0x42617ae3), SkBits2Float(0x41e72b00), SkBits2Float(0x42609271)); // 28.831f, 56.564f, 28.863f, 56.37f, 28.896f, 56.143f
6383path.cubicTo(SkBits2Float(0x41e75602), SkBits2Float(0x42604fe2), SkBits2Float(0x41e7978b), SkBits2Float(0x425fe250), SkBits2Float(0x41e7c49a), SkBits2Float(0x425f9fc1)); // 28.917f, 56.078f, 28.949f, 55.971f, 28.971f, 55.906f
6384path.cubicTo(SkBits2Float(0x41e7db21), SkBits2Float(0x425f25e6), SkBits2Float(0x41e7db21), SkBits2Float(0x425ec18c), SkBits2Float(0x41e80623), SkBits2Float(0x425e53fa)); // 28.982f, 55.787f, 28.982f, 55.689f, 29.003f, 55.582f
6385path.lineTo(SkBits2Float(0x41e849b9), SkBits2Float(0x425e26ec)); // 29.036f, 55.538f
6386path.cubicTo(SkBits2Float(0x41e874bb), SkBits2Float(0x425da2d3), SkBits2Float(0x41e8b851), SkBits2Float(0x425d28f8), SkBits2Float(0x41e8e55f), SkBits2Float(0x425caf1d)); // 29.057f, 55.409f, 29.09f, 55.29f, 29.112f, 55.171f
6387path.cubicTo(SkBits2Float(0x41e93b63), SkBits2Float(0x425b8f5f), SkBits2Float(0x41e97ef9), SkBits2Float(0x425a7ae4), SkBits2Float(0x41ea0417), SkBits2Float(0x42596669)); // 29.154f, 54.89f, 29.187f, 54.62f, 29.252f, 54.35f
6388path.cubicTo(SkBits2Float(0x41ea3125), SkBits2Float(0x4259199c), SkBits2Float(0x41ea5c27), SkBits2Float(0x4258ab05), SkBits2Float(0x41eaf7cd), SkBits2Float(0x4258947d)); // 29.274f, 54.275f, 29.295f, 54.167f, 29.371f, 54.145f
6389path.moveTo(SkBits2Float(0x41e96871), SkBits2Float(0x4256a2d3)); // 29.176f, 53.659f
6390path.cubicTo(SkBits2Float(0x41e953f6), SkBits2Float(0x4256e562), SkBits2Float(0x41e96871), SkBits2Float(0x425727f2), SkBits2Float(0x41e93b63), SkBits2Float(0x42575f3d)); // 29.166f, 53.724f, 29.176f, 53.789f, 29.154f, 53.843f
6391path.cubicTo(SkBits2Float(0x41e8fbe6), SkBits2Float(0x42578002), SkBits2Float(0x41e88b42), SkBits2Float(0x42578002), SkBits2Float(0x41e81cab), SkBits2Float(0x42578002)); // 29.123f, 53.875f, 29.068f, 53.875f, 29.014f, 53.875f
6392path.cubicTo(SkBits2Float(0x41e7db22), SkBits2Float(0x42578002), SkBits2Float(0x41e78311), SkBits2Float(0x42576a81), SkBits2Float(0x41e75603), SkBits2Float(0x42575f3d)); // 28.982f, 53.875f, 28.939f, 53.854f, 28.917f, 53.843f
6393path.cubicTo(SkBits2Float(0x41e72b01), SkBits2Float(0x4257322f), SkBits2Float(0x41e72b01), SkBits2Float(0x4257322f), SkBits2Float(0x41e72b01), SkBits2Float(0x4256fbe9)); // 28.896f, 53.799f, 28.896f, 53.799f, 28.896f, 53.746f
6394path.cubicTo(SkBits2Float(0x41e72b01), SkBits2Float(0x4256b95a), SkBits2Float(0x41e78311), SkBits2Float(0x42564ac2), SkBits2Float(0x41e7978c), SkBits2Float(0x42561376)); // 28.896f, 53.681f, 28.939f, 53.573f, 28.949f, 53.519f
6395path.cubicTo(SkBits2Float(0x41e7db22), SkBits2Float(0x4255570c), SkBits2Float(0x41e80624), SkBits2Float(0x4254b128), SkBits2Float(0x41e86040), SkBits2Float(0x42540b45)); // 28.982f, 53.335f, 29.003f, 53.173f, 29.047f, 53.011f
6396path.cubicTo(SkBits2Float(0x41e874bb), SkBits2Float(0x4253cac2), SkBits2Float(0x41e86040), SkBits2Float(0x4253916a), SkBits2Float(0x41e8b850), SkBits2Float(0x42536562)); // 29.057f, 52.948f, 29.047f, 52.892f, 29.09f, 52.849f
6397path.cubicTo(SkBits2Float(0x41e8ced7), SkBits2Float(0x42534fe1), SkBits2Float(0x41e953f6), SkBits2Float(0x42532e16), SkBits2Float(0x41e97ef8), SkBits2Float(0x42532e16)); // 29.101f, 52.828f, 29.166f, 52.795f, 29.187f, 52.795f
6398path.cubicTo(SkBits2Float(0x41ea0417), SkBits2Float(0x425323d9), SkBits2Float(0x41ea3125), SkBits2Float(0x42534fe1), SkBits2Float(0x41ea72ae), SkBits2Float(0x42535a1e)); // 29.252f, 52.785f, 29.274f, 52.828f, 29.306f, 52.838f
6399path.cubicTo(SkBits2Float(0x41ea72ae), SkBits2Float(0x42548520), SkBits2Float(0x41e9d708), SkBits2Float(0x4255a4df), SkBits2Float(0x41e96871), SkBits2Float(0x4256a2d2)); // 29.306f, 53.13f, 29.23f, 53.411f, 29.176f, 53.659f
6400path.moveTo(SkBits2Float(0x41e874bb), SkBits2Float(0x4258b647)); // 29.057f, 54.178f
6401path.cubicTo(SkBits2Float(0x41e86040), SkBits2Float(0x42595c2a), SkBits2Float(0x41e849b9), SkBits2Float(0x4259bf7e), SkBits2Float(0x41e80623), SkBits2Float(0x425a4eda)); // 29.047f, 54.34f, 29.036f, 54.437f, 29.003f, 54.577f
6402path.cubicTo(SkBits2Float(0x41e7db21), SkBits2Float(0x425ad3f9), SkBits2Float(0x41e76c89), SkBits2Float(0x425b8520), SkBits2Float(0x41e72b00), SkBits2Float(0x425c147c)); // 28.982f, 54.707f, 28.928f, 54.88f, 28.896f, 55.02f
6403path.cubicTo(SkBits2Float(0x41e71479), SkBits2Float(0x425c570b), SkBits2Float(0x41e72b00), SkBits2Float(0x425c77d0), SkBits2Float(0x41e71479), SkBits2Float(0x425cba5f)); // 28.885f, 55.085f, 28.896f, 55.117f, 28.885f, 55.182f
6404path.cubicTo(SkBits2Float(0x41e68f5a), SkBits2Float(0x425dfae2), SkBits2Float(0x41e5dd2d), SkBits2Float(0x425f676d), SkBits2Float(0x41e570a2), SkBits2Float(0x4260a8f7)); // 28.82f, 55.495f, 28.733f, 55.851f, 28.68f, 56.165f
6405path.cubicTo(SkBits2Float(0x41e52d0c), SkBits2Float(0x42610c4b), SkBits2Float(0x41e55a1b), SkBits2Float(0x42614eda), SkBits2Float(0x41e52d0c), SkBits2Float(0x42619ba7)); // 28.647f, 56.262f, 28.669f, 56.327f, 28.647f, 56.402f
6406path.cubicTo(SkBits2Float(0x41e51685), SkBits2Float(0x4261f4be), SkBits2Float(0x41e4be74), SkBits2Float(0x42624cce), SkBits2Float(0x41e4a7ed), SkBits2Float(0x42628f5d)); // 28.636f, 56.489f, 28.593f, 56.575f, 28.582f, 56.64f
6407path.cubicTo(SkBits2Float(0x41e46664), SkBits2Float(0x42634bc7), SkBits2Float(0x41e43b62), SkBits2Float(0x4263e667), SkBits2Float(0x41e3f7cc), SkBits2Float(0x4264a1cc)); // 28.55f, 56.824f, 28.529f, 56.975f, 28.496f, 57.158f
6408path.cubicTo(SkBits2Float(0x41e39fbc), SkBits2Float(0x42657efb), SkBits2Float(0x41e31a9d), SkBits2Float(0x42669376), SkBits2Float(0x41e2ac05), SkBits2Float(0x426770a5)); // 28.453f, 57.374f, 28.388f, 57.644f, 28.334f, 57.86f
6409path.cubicTo(SkBits2Float(0x41e27ef7), SkBits2Float(0x426821cc), SkBits2Float(0x41e253f5), SkBits2Float(0x4268bc6c), SkBits2Float(0x41e2105f), SkBits2Float(0x42695812)); // 28.312f, 58.033f, 28.291f, 58.184f, 28.258f, 58.336f
6410path.cubicTo(SkBits2Float(0x41e1ced6), SkBits2Float(0x4269f2b2), SkBits2Float(0x41e1082e), SkBits2Float(0x426aa3d9), SkBits2Float(0x41e09996), SkBits2Float(0x426b3335)); // 28.226f, 58.487f, 28.129f, 58.66f, 28.075f, 58.8f
6411path.lineTo(SkBits2Float(0x41e05600), SkBits2Float(0x426b3e79)); // 28.042f, 58.811f
6412path.cubicTo(SkBits2Float(0x41dfe768), SkBits2Float(0x426bb854), SkBits2Float(0x41dfba5a), SkBits2Float(0x426c3129), SkBits2Float(0x41df4dcf), SkBits2Float(0x426ccccf)); // 27.988f, 58.93f, 27.966f, 59.048f, 27.913f, 59.2f
6413path.cubicTo(SkBits2Float(0x41def5bf), SkBits2Float(0x426d50e8), SkBits2Float(0x41de5a19), SkBits2Float(0x426de14a), SkBits2Float(0x41ddeb81), SkBits2Float(0x426e70a6)); // 27.87f, 59.329f, 27.794f, 59.47f, 27.74f, 59.61f
6414path.cubicTo(SkBits2Float(0x41dd3b60), SkBits2Float(0x426f79dd), SkBits2Float(0x41dd4fdb), SkBits2Float(0x426e1896), SkBits2Float(0x41dd6662), SkBits2Float(0x426db43c)); // 27.654f, 59.869f, 27.664f, 59.524f, 27.675f, 59.426f
6415path.cubicTo(SkBits2Float(0x41de9ba1), SkBits2Float(0x426aa3da), SkBits2Float(0x41e01476), SkBits2Float(0x42679271), SkBits2Float(0x41e1332f), SkBits2Float(0x42648109)); // 27.826f, 58.66f, 28.01f, 57.893f, 28.15f, 57.126f
6416path.cubicTo(SkBits2Float(0x41e149b6), SkBits2Float(0x42645f3e), SkBits2Float(0x41e1a1c7), SkBits2Float(0x4264072e), SkBits2Float(0x41e1a1c7), SkBits2Float(0x4263f1ad)); // 28.161f, 57.093f, 28.204f, 57.007f, 28.204f, 56.986f
6417path.cubicTo(SkBits2Float(0x41e253f4), SkBits2Float(0x42626e9b), SkBits2Float(0x41e2c28c), SkBits2Float(0x42610109), SkBits2Float(0x41e3459e), SkBits2Float(0x425f72b3)); // 28.291f, 56.608f, 28.345f, 56.251f, 28.409f, 55.862f
6418path.cubicTo(SkBits2Float(0x41e372ac), SkBits2Float(0x425f51ee), SkBits2Float(0x41e3b642), SkBits2Float(0x425ef9de), SkBits2Float(0x41e3b642), SkBits2Float(0x425ed813)); // 28.431f, 55.83f, 28.464f, 55.744f, 28.464f, 55.711f
6419path.cubicTo(SkBits2Float(0x41e46663), SkBits2Float(0x425d76cb), SkBits2Float(0x41e4be73), SkBits2Float(0x425c3542), SkBits2Float(0x41e570a0), SkBits2Float(0x425ad3fa)); // 28.55f, 55.366f, 28.593f, 55.052f, 28.68f, 54.707f
6420path.cubicTo(SkBits2Float(0x41e570a0), SkBits2Float(0x425a916b), SkBits2Float(0x41e5dd2b), SkBits2Float(0x425a22d3), SkBits2Float(0x41e5f3b2), SkBits2Float(0x4259e044)); // 28.68f, 54.642f, 28.733f, 54.534f, 28.744f, 54.469f
6421path.cubicTo(SkBits2Float(0x41e620c0), SkBits2Float(0x42595c2b), SkBits2Float(0x41e60a39), SkBits2Float(0x4258ab05), SkBits2Float(0x41e72afe), SkBits2Float(0x4258947d)); // 28.766f, 54.34f, 28.755f, 54.167f, 28.896f, 54.145f
6422path.cubicTo(SkBits2Float(0x41e79789), SkBits2Float(0x4258947d), SkBits2Float(0x41e80621), SkBits2Float(0x4258ab04), SkBits2Float(0x41e874b8), SkBits2Float(0x4258b648)); // 28.949f, 54.145f, 29.003f, 54.167f, 29.057f, 54.178f
6423path.moveTo(SkBits2Float(0x41e5b229), SkBits2Float(0x4256a2d3)); // 28.712f, 53.659f
6424path.cubicTo(SkBits2Float(0x41e5851b), SkBits2Float(0x4256e562), SkBits2Float(0x41e59ba2), SkBits2Float(0x425727f2), SkBits2Float(0x41e570a0), SkBits2Float(0x42575f3d)); // 28.69f, 53.724f, 28.701f, 53.789f, 28.68f, 53.843f
6425path.cubicTo(SkBits2Float(0x41e52d0a), SkBits2Float(0x42578002), SkBits2Float(0x41e4a7ec), SkBits2Float(0x42579689), SkBits2Float(0x41e43b61), SkBits2Float(0x42578002)); // 28.647f, 53.875f, 28.582f, 53.897f, 28.529f, 53.875f
6426path.cubicTo(SkBits2Float(0x41e3f7cb), SkBits2Float(0x42578002), SkBits2Float(0x41e39fbb), SkBits2Float(0x425748b6), SkBits2Float(0x41e3459e), SkBits2Float(0x42573e79)); // 28.496f, 53.875f, 28.453f, 53.821f, 28.409f, 53.811f
6427path.cubicTo(SkBits2Float(0x41e39fbb), SkBits2Float(0x42566044), SkBits2Float(0x41e40e52), SkBits2Float(0x42558e58), SkBits2Float(0x41e47add), SkBits2Float(0x4254c7b0)); // 28.453f, 53.594f, 28.507f, 53.389f, 28.56f, 53.195f
6428path.cubicTo(SkBits2Float(0x41e49370), SkBits2Float(0x425479dd), SkBits2Float(0x41e49370), SkBits2Float(0x42541689), SkBits2Float(0x41e4eb81), SkBits2Float(0x4253df3d)); // 28.572f, 53.119f, 28.572f, 53.022f, 28.615f, 52.968f
6429path.cubicTo(SkBits2Float(0x41e4fffc), SkBits2Float(0x4253c9bc), SkBits2Float(0x41e5b229), SkBits2Float(0x4253916a), SkBits2Float(0x41e60a39), SkBits2Float(0x4253916a)); // 28.625f, 52.947f, 28.712f, 52.892f, 28.755f, 52.892f
6430path.cubicTo(SkBits2Float(0x41e68f58), SkBits2Float(0x4253872d), SkBits2Float(0x41e68f58), SkBits2Float(0x4253a7f1), SkBits2Float(0x41e6e768), SkBits2Float(0x4253be78)); // 28.82f, 52.882f, 28.82f, 52.914f, 28.863f, 52.936f
6431path.cubicTo(SkBits2Float(0x41e68f58), SkBits2Float(0x4254c7af), SkBits2Float(0x41e60a39), SkBits2Float(0x4255af1c), SkBits2Float(0x41e5b229), SkBits2Float(0x4256a2d2)); // 28.82f, 53.195f, 28.755f, 53.421f, 28.712f, 53.659f
6432path.moveTo(SkBits2Float(0x41e372ac), SkBits2Float(0x42589fc0)); // 28.431f, 54.156f
6433path.cubicTo(SkBits2Float(0x41e55a19), SkBits2Float(0x42586874), SkBits2Float(0x41e40e52), SkBits2Float(0x425a178f), SkBits2Float(0x41e3cabc), SkBits2Float(0x425a7ae3)); // 28.669f, 54.102f, 28.507f, 54.523f, 28.474f, 54.62f
6434path.cubicTo(SkBits2Float(0x41e1fbe3), SkBits2Float(0x425f3b66), SkBits2Float(0x41dfd0e1), SkBits2Float(0x4263f1ac), SkBits2Float(0x41ddeb81), SkBits2Float(0x4268c7b0)); // 28.248f, 55.808f, 27.977f, 56.986f, 27.74f, 58.195f
6435path.cubicTo(SkBits2Float(0x41ddd4fa), SkBits2Float(0x42690a3f), SkBits2Float(0x41dd7ce9), SkBits2Float(0x42696d93), SkBits2Float(0x41dd6662), SkBits2Float(0x4269999c)); // 27.729f, 58.26f, 27.686f, 58.357f, 27.675f, 58.4f
6436path.cubicTo(SkBits2Float(0x41dd3b60), SkBits2Float(0x426a29fe), SkBits2Float(0x41dd3b60), SkBits2Float(0x426a8d52), SkBits2Float(0x41dcf7ca), SkBits2Float(0x426b1cae)); // 27.654f, 58.541f, 27.654f, 58.638f, 27.621f, 58.778f
6437path.cubicTo(SkBits2Float(0x41dcb641), SkBits2Float(0x426bf9dd), SkBits2Float(0x41dc0414), SkBits2Float(0x426cf8d7), SkBits2Float(0x41db957c), SkBits2Float(0x426dec8d)); // 27.589f, 58.994f, 27.502f, 59.243f, 27.448f, 59.481f
6438path.cubicTo(SkBits2Float(0x41db53f3), SkBits2Float(0x426e916a), SkBits2Float(0x41db3d6c), SkBits2Float(0x426eea81), SkBits2Float(0x41daa3d2), SkBits2Float(0x426f5918)); // 27.416f, 59.642f, 27.405f, 59.729f, 27.33f, 59.837f
6439path.cubicTo(SkBits2Float(0x41da76c4), SkBits2Float(0x426f4dd4), SkBits2Float(0x41da49b5), SkBits2Float(0x426f4291), SkBits2Float(0x41da082c), SkBits2Float(0x426f21cc)); // 27.308f, 59.826f, 27.286f, 59.815f, 27.254f, 59.783f
6440path.cubicTo(SkBits2Float(0x41d9db1e), SkBits2Float(0x426f0b45), SkBits2Float(0x41d9f1a5), SkBits2Float(0x426f0b45), SkBits2Float(0x41d9c6a3), SkBits2Float(0x426eea80)); // 27.232f, 59.761f, 27.243f, 59.761f, 27.222f, 59.729f
6441path.lineTo(SkBits2Float(0x41d99995), SkBits2Float(0x426edf3c)); // 27.2f, 59.718f
6442path.cubicTo(SkBits2Float(0x41d91476), SkBits2Float(0x426ea7f0), SkBits2Float(0x41d8e768), SkBits2Float(0x426e6561), SkBits2Float(0x41d8a5df), SkBits2Float(0x426e020d)); // 27.135f, 59.664f, 27.113f, 59.599f, 27.081f, 59.502f
6443path.cubicTo(SkBits2Float(0x41d8a5df), SkBits2Float(0x426e020d), SkBits2Float(0x41d86456), SkBits2Float(0x426dd605), SkBits2Float(0x41d8a5df), SkBits2Float(0x426dd605)); // 27.081f, 59.502f, 27.049f, 59.459f, 27.081f, 59.459f
6444path.cubicTo(SkBits2Float(0x41d8e768), SkBits2Float(0x426d5c2a), SkBits2Float(0x41d8fdef), SkBits2Float(0x426cf8d6), SkBits2Float(0x41d92afe), SkBits2Float(0x426c7efb)); // 27.113f, 59.34f, 27.124f, 59.243f, 27.146f, 59.124f
6445path.cubicTo(SkBits2Float(0x41d9830e), SkBits2Float(0x426bb853), SkBits2Float(0x41da1eb4), SkBits2Float(0x426ae561), SkBits2Float(0x41da8d4c), SkBits2Float(0x426a29fd)); // 27.189f, 58.93f, 27.265f, 58.724f, 27.319f, 58.541f
6446path.cubicTo(SkBits2Float(0x41dccabd), SkBits2Float(0x4265d811), SkBits2Float(0x41e02afe), SkBits2Float(0x42617ae2), SkBits2Float(0x41e1332f), SkBits2Float(0x425cfcef)); // 27.599f, 57.461f, 28.021f, 56.37f, 28.15f, 55.247f
6447path.cubicTo(SkBits2Float(0x41e149b6), SkBits2Float(0x425c4085), SkBits2Float(0x41e1a1c7), SkBits2Float(0x425b8f5e), SkBits2Float(0x41e1fbe3), SkBits2Float(0x425adf3d)); // 28.161f, 55.063f, 28.204f, 54.89f, 28.248f, 54.718f
6448path.cubicTo(SkBits2Float(0x41e226e5), SkBits2Float(0x425a4edb), SkBits2Float(0x41e226e5), SkBits2Float(0x42598833), SkBits2Float(0x41e2ac04), SkBits2Float(0x4258f7d0)); // 28.269f, 54.577f, 28.269f, 54.383f, 28.334f, 54.242f
6449path.cubicTo(SkBits2Float(0x41e2c28b), SkBits2Float(0x4258ec8c), SkBits2Float(0x41e372ac), SkBits2Float(0x42589fc0), SkBits2Float(0x41e372ac), SkBits2Float(0x42589fc0)); // 28.345f, 54.231f, 28.431f, 54.156f, 28.431f, 54.156f
6450path.moveTo(SkBits2Float(0x41d9830e), SkBits2Float(0x427128f7)); // 27.189f, 60.29f
6451path.cubicTo(SkBits2Float(0x41d95600), SkBits2Float(0x42714ac2), SkBits2Float(0x41d92afe), SkBits2Float(0x427176ca), SkBits2Float(0x41d8e768), SkBits2Float(0x427176ca)); // 27.167f, 60.323f, 27.146f, 60.366f, 27.113f, 60.366f
6452path.cubicTo(SkBits2Float(0x41d86456), SkBits2Float(0x42718d51), SkBits2Float(0x41d67ce9), SkBits2Float(0x4271820e), SkBits2Float(0x41d60e51), SkBits2Float(0x42716b86)); // 27.049f, 60.388f, 26.811f, 60.377f, 26.757f, 60.355f
6453path.cubicTo(SkBits2Float(0x41d5f7ca), SkBits2Float(0x42716b86), SkBits2Float(0x41d5ccc8), SkBits2Float(0x42714ac1), SkBits2Float(0x41d5b641), SkBits2Float(0x42713f7e)); // 26.746f, 60.355f, 26.725f, 60.323f, 26.714f, 60.312f
6454path.cubicTo(SkBits2Float(0x41d5b641), SkBits2Float(0x42708e57), SkBits2Float(0x41d5f7ca), SkBits2Float(0x426ffefb), SkBits2Float(0x41d69370), SkBits2Float(0x426f8f5d)); // 26.714f, 60.139f, 26.746f, 59.999f, 26.822f, 59.89f
6455path.cubicTo(SkBits2Float(0x41d6eb80), SkBits2Float(0x426f9ba7), SkBits2Float(0x41d7188f), SkBits2Float(0x426f8f5d), SkBits2Float(0x41d7709f), SkBits2Float(0x426f9ba7)); // 26.865f, 59.902f, 26.887f, 59.89f, 26.93f, 59.902f
6456path.cubicTo(SkBits2Float(0x41d7b228), SkBits2Float(0x426fb128), SkBits2Float(0x41d99995), SkBits2Float(0x42706d93), SkBits2Float(0x41d9c6a3), SkBits2Float(0x42708e57)); // 26.962f, 59.923f, 27.2f, 60.107f, 27.222f, 60.139f
6457path.cubicTo(SkBits2Float(0x41d9db1e), SkBits2Float(0x4270d0e6), SkBits2Float(0x41d99995), SkBits2Float(0x42710832), SkBits2Float(0x41d9830d), SkBits2Float(0x427128f7)); // 27.232f, 60.204f, 27.2f, 60.258f, 27.189f, 60.29f
6458path.moveTo(SkBits2Float(0x41e1603c), SkBits2Float(0x4255f1ab)); // 28.172f, 53.486f
6459path.cubicTo(SkBits2Float(0x41e149b5), SkBits2Float(0x42563f7e), SkBits2Float(0x41e1603c), SkBits2Float(0x425676ca), SkBits2Float(0x41e1332e), SkBits2Float(0x4256c49d)); // 28.161f, 53.562f, 28.172f, 53.616f, 28.15f, 53.692f
6460path.cubicTo(SkBits2Float(0x41e11eb3), SkBits2Float(0x4256f0a5), SkBits2Float(0x41e0db1e), SkBits2Float(0x425727f1), SkBits2Float(0x41e0b01c), SkBits2Float(0x425748b6)); // 28.14f, 53.735f, 28.107f, 53.789f, 28.086f, 53.821f
6461path.lineTo(SkBits2Float(0x41e055ff), SkBits2Float(0x425748b6)); // 28.042f, 53.821f
6462path.cubicTo(SkBits2Float(0x41e055ff), SkBits2Float(0x425748b6), SkBits2Float(0x41df4dce), SkBits2Float(0x4256e562), SkBits2Float(0x41df3747), SkBits2Float(0x4256da1e)); // 28.042f, 53.821f, 27.913f, 53.724f, 27.902f, 53.713f
6463path.cubicTo(SkBits2Float(0x41deb228), SkBits2Float(0x4256820e), SkBits2Float(0x41de4391), SkBits2Float(0x42561376), SkBits2Float(0x41ddbe72), SkBits2Float(0x4255ba60)); // 27.837f, 53.627f, 27.783f, 53.519f, 27.718f, 53.432f
6464path.lineTo(SkBits2Float(0x41dd7ce9), SkBits2Float(0x4255af1c)); // 27.686f, 53.421f
6465path.cubicTo(SkBits2Float(0x41dd7ce9), SkBits2Float(0x4255a4df), SkBits2Float(0x41dda7eb), SkBits2Float(0x425578d6), SkBits2Float(0x41dd7ce9), SkBits2Float(0x42556d93)); // 27.686f, 53.411f, 27.707f, 53.368f, 27.686f, 53.357f
6466path.cubicTo(SkBits2Float(0x41de9ba1), SkBits2Float(0x4255147c), SkBits2Float(0x41df8f58), SkBits2Float(0x4254c7b0), SkBits2Float(0x41e0b01c), SkBits2Float(0x42549064)); // 27.826f, 53.27f, 27.945f, 53.195f, 28.086f, 53.141f
6467path.cubicTo(SkBits2Float(0x41e0c497), SkBits2Float(0x42548520), SkBits2Float(0x41e11eb4), SkBits2Float(0x4254645c), SkBits2Float(0x41e1332e), SkBits2Float(0x4254645c)); // 28.096f, 53.13f, 28.14f, 53.098f, 28.15f, 53.098f
6468path.cubicTo(SkBits2Float(0x41e18b3e), SkBits2Float(0x42545918), SkBits2Float(0x41e1ced4), SkBits2Float(0x425479dd), SkBits2Float(0x41e1fbe2), SkBits2Float(0x425479dd)); // 28.193f, 53.087f, 28.226f, 53.119f, 28.248f, 53.119f
6469path.cubicTo(SkBits2Float(0x41e1fbe2), SkBits2Float(0x4255147d), SkBits2Float(0x41e1a1c5), SkBits2Float(0x4255841a), SkBits2Float(0x41e1603c), SkBits2Float(0x4255f1ac)); // 28.248f, 53.27f, 28.204f, 53.379f, 28.172f, 53.486f
6470path.moveTo(SkBits2Float(0x41df6248), SkBits2Float(0x425b4ccf)); // 27.923f, 54.825f
6471path.cubicTo(SkBits2Float(0x41dfe767), SkBits2Float(0x425b9aa2), SkBits2Float(0x41df4dcd), SkBits2Float(0x425c6c8d), SkBits2Float(0x41df20bf), SkBits2Float(0x425cd0e8)); // 27.988f, 54.901f, 27.913f, 55.106f, 27.891f, 55.204f
6472path.cubicTo(SkBits2Float(0x41ddeb80), SkBits2Float(0x425f893a), SkBits2Float(0x41dc8932), SkBits2Float(0x4262374e), SkBits2Float(0x41db105d), SkBits2Float(0x4264e45d)); // 27.74f, 55.884f, 27.567f, 56.554f, 27.383f, 57.223f
6473path.cubicTo(SkBits2Float(0x41daced4), SkBits2Float(0x42657efd), SkBits2Float(0x41d78726), SkBits2Float(0x426c52f5), SkBits2Float(0x41d6c07e), SkBits2Float(0x426c3c6d)); // 27.351f, 57.374f, 26.941f, 59.081f, 26.844f, 59.059f
6474path.cubicTo(SkBits2Float(0x41d58932), SkBits2Float(0x426c3129), SkBits2Float(0x41d50620), SkBits2Float(0x426b1caf), SkBits2Float(0x41d48101), SkBits2Float(0x426aa3da)); // 26.692f, 59.048f, 26.628f, 58.778f, 26.563f, 58.66f
6475path.cubicTo(SkBits2Float(0x41d3d0e0), SkBits2Float(0x426a0834), SkBits2Float(0x41d34bc2), SkBits2Float(0x42696d94), SkBits2Float(0x41d2db1e), SkBits2Float(0x4268bc6d)); // 26.477f, 58.508f, 26.412f, 58.357f, 26.357f, 58.184f
6476path.cubicTo(SkBits2Float(0x41d21476), SkBits2Float(0x42674fe2), SkBits2Float(0x41d19164), SkBits2Float(0x4265c18c), SkBits2Float(0x41d19164), SkBits2Float(0x426449bd)); // 26.26f, 57.828f, 26.196f, 57.439f, 26.196f, 57.072f
6477path.cubicTo(SkBits2Float(0x41d1a5df), SkBits2Float(0x4261bd73), SkBits2Float(0x41d3d0e1), SkBits2Float(0x425f51ee), SkBits2Float(0x41d79dae), SkBits2Float(0x425d820f)); // 26.206f, 56.435f, 26.477f, 55.83f, 26.952f, 55.377f
6478path.cubicTo(SkBits2Float(0x41d8a5df), SkBits2Float(0x425cfcf0), SkBits2Float(0x41d9db1f), SkBits2Float(0x425c8e59), SkBits2Float(0x41db105e), SkBits2Float(0x425c3542)); // 27.081f, 55.247f, 27.232f, 55.139f, 27.383f, 55.052f
6479path.cubicTo(SkBits2Float(0x41dbed8d), SkBits2Float(0x425bf4bf), SkBits2Float(0x41ddbe72), SkBits2Float(0x425b21cd), SkBits2Float(0x41dec8b0), SkBits2Float(0x425b21cd)); // 27.491f, 54.989f, 27.718f, 54.783f, 27.848f, 54.783f
6480path.cubicTo(SkBits2Float(0x41df20c0), SkBits2Float(0x425b374e), SkBits2Float(0x41df4dcf), SkBits2Float(0x425b4292), SkBits2Float(0x41df624a), SkBits2Float(0x425b4ccf)); // 27.891f, 54.804f, 27.913f, 54.815f, 27.923f, 54.825f
6481path.moveTo(SkBits2Float(0x41d453f4), SkBits2Float(0x426fbc6d)); // 26.541f, 59.934f
6482path.cubicTo(SkBits2Float(0x41d48102), SkBits2Float(0x426f8521), SkBits2Float(0x41d51a9c), SkBits2Float(0x426ea7f2), SkBits2Float(0x41d4957d), SkBits2Float(0x426e872e)); // 26.563f, 59.88f, 26.638f, 59.664f, 26.573f, 59.632f
6483path.cubicTo(SkBits2Float(0x41d453f4), SkBits2Float(0x426e70a7), SkBits2Float(0x41d428f2), SkBits2Float(0x426e872e), SkBits2Float(0x41d3fbe3), SkBits2Float(0x426e70a7)); // 26.541f, 59.61f, 26.52f, 59.632f, 26.498f, 59.61f
6484path.cubicTo(SkBits2Float(0x41d3d0e1), SkBits2Float(0x426e916c), SkBits2Float(0x41d3b84d), SkBits2Float(0x426e872e), SkBits2Float(0x41d3a3d3), SkBits2Float(0x426e916c)); // 26.477f, 59.642f, 26.465f, 59.632f, 26.455f, 59.642f
6485path.cubicTo(SkBits2Float(0x41d3603d), SkBits2Float(0x426f010a), SkBits2Float(0x41d3d0e1), SkBits2Float(0x426f9ba9), SkBits2Float(0x41d4126b), SkBits2Float(0x426fdd33)); // 26.422f, 59.751f, 26.477f, 59.902f, 26.509f, 59.966f
6486path.lineTo(SkBits2Float(0x41d43d6d), SkBits2Float(0x426fdd33)); // 26.53f, 59.966f
6487path.cubicTo(SkBits2Float(0x41d43d6d), SkBits2Float(0x426fd1ef), SkBits2Float(0x41d43d6d), SkBits2Float(0x426fbc6e), SkBits2Float(0x41d453f4), SkBits2Float(0x426fbc6e)); // 26.53f, 59.955f, 26.53f, 59.934f, 26.541f, 59.934f
6488path.moveTo(SkBits2Float(0x42071ba4), SkBits2Float(0x42670210)); // 33.777f, 57.752f
6489path.cubicTo(SkBits2Float(0x42075e33), SkBits2Float(0x42670d54), SkBits2Float(0x4207957f), SkBits2Float(0x42671897), SkBits2Float(0x4207cccb), SkBits2Float(0x42672f1e)); // 33.842f, 57.763f, 33.896f, 57.774f, 33.95f, 57.796f
6490path.cubicTo(SkBits2Float(0x4208a9fa), SkBits2Float(0x4267872e), SkBits2Float(0x42097be6), SkBits2Float(0x42681791), SkBits2Float(0x420a3850), SkBits2Float(0x42688522)); // 34.166f, 57.882f, 34.371f, 58.023f, 34.555f, 58.13f
6491path.cubicTo(SkBits2Float(0x420b0a3c), SkBits2Float(0x4268fefd), SkBits2Float(0x420d1167), SkBits2Float(0x4269e770), SkBits2Float(0x420d27ee), SkBits2Float(0x426ae564)); // 34.76f, 58.249f, 35.267f, 58.476f, 35.289f, 58.724f
6492path.cubicTo(SkBits2Float(0x420d0729), SkBits2Float(0x426af0a8), SkBits2Float(0x420cdb21), SkBits2Float(0x426afbeb), SkBits2Float(0x420cb956), SkBits2Float(0x426b072f)); // 35.257f, 58.735f, 35.214f, 58.746f, 35.181f, 58.757f
6493path.cubicTo(SkBits2Float(0x420b9998), SkBits2Float(0x426b27f4), SkBits2Float(0x420a6f9c), SkBits2Float(0x426b27f4), SkBits2Float(0x42095b21), SkBits2Float(0x426b3337)); // 34.9f, 58.789f, 34.609f, 58.789f, 34.339f, 58.8f
6494path.cubicTo(SkBits2Float(0x42090d4e), SkBits2Float(0x426b3337), SkBits2Float(0x4207b644), SkBits2Float(0x426b49be), SkBits2Float(0x420773b4), SkBits2Float(0x426b3337)); // 34.263f, 58.8f, 33.928f, 58.822f, 33.863f, 58.8f
6495path.cubicTo(SkBits2Float(0x4207322b), SkBits2Float(0x426b072f), SkBits2Float(0x4206ef9b), SkBits2Float(0x4269999d), SkBits2Float(0x4206ced7), SkBits2Float(0x426920c8)); // 33.799f, 58.757f, 33.734f, 58.4f, 33.702f, 58.282f
6496path.cubicTo(SkBits2Float(0x42069685), SkBits2Float(0x4268645e), SkBits2Float(0x4205c49a), SkBits2Float(0x4266b543), SkBits2Float(0x42071ba4), SkBits2Float(0x42670210)); // 33.647f, 58.098f, 33.442f, 57.677f, 33.777f, 57.752f
6497path.moveTo(SkBits2Float(0x41f026e6), SkBits2Float(0x423f0c4e)); // 30.019f, 47.762f
6498path.cubicTo(SkBits2Float(0x41effbe4), SkBits2Float(0x42400004), SkBits2Float(0x41f0105f), SkBits2Float(0x4240e877), SkBits2Float(0x41f03b61), SkBits2Float(0x4241d0ea)); // 29.998f, 48, 30.008f, 48.227f, 30.029f, 48.454f
6499path.lineTo(SkBits2Float(0x41f03b61), SkBits2Float(0x424228fa)); // 30.029f, 48.54f
6500path.cubicTo(SkBits2Float(0x41f051e8), SkBits2Float(0x42423f81), SkBits2Float(0x41f0c080), SkBits2Float(0x424276cd), SkBits2Float(0x41f11890), SkBits2Float(0x424276cd)); // 30.04f, 48.562f, 30.094f, 48.616f, 30.137f, 48.616f
6501path.cubicTo(SkBits2Float(0x41f11890), SkBits2Float(0x424276cd), SkBits2Float(0x41f18934), SkBits2Float(0x42426b89), SkBits2Float(0x41f12f17), SkBits2Float(0x42426b89)); // 30.137f, 48.616f, 30.192f, 48.605f, 30.148f, 48.605f
6502path.cubicTo(SkBits2Float(0x41f1459e), SkBits2Float(0x42426045), SkBits2Float(0x41f18934), SkBits2Float(0x42426b89), SkBits2Float(0x41f18934), SkBits2Float(0x42426b89)); // 30.159f, 48.594f, 30.192f, 48.605f, 30.192f, 48.605f
6503path.cubicTo(SkBits2Float(0x41f19daf), SkBits2Float(0x424249be), SkBits2Float(0x41f19daf), SkBits2Float(0x42423f81), SkBits2Float(0x41f1b436), SkBits2Float(0x42423f81)); // 30.202f, 48.572f, 30.202f, 48.562f, 30.213f, 48.562f
6504path.cubicTo(SkBits2Float(0x41f18934), SkBits2Float(0x42414087), SkBits2Float(0x41f11890), SkBits2Float(0x424079df), SkBits2Float(0x41f0ac05), SkBits2Float(0x423f9cb0)); // 30.192f, 48.313f, 30.137f, 48.119f, 30.084f, 47.903f
6505path.cubicTo(SkBits2Float(0x41f0957e), SkBits2Float(0x423f7ae5), SkBits2Float(0x41f0c080), SkBits2Float(0x423f5a21), SkBits2Float(0x41f0957e), SkBits2Float(0x423f395c)); // 30.073f, 47.87f, 30.094f, 47.838f, 30.073f, 47.806f
6506path.lineTo(SkBits2Float(0x41f026e6), SkBits2Float(0x423f0c4e)); // 30.019f, 47.762f
6507path.moveTo(SkBits2Float(0x41ed4dcf), SkBits2Float(0x423fd3fc)); // 29.663f, 47.957f
6508path.cubicTo(SkBits2Float(0x41ecc8b0), SkBits2Float(0x42408523), SkBits2Float(0x41ec580c), SkBits2Float(0x42414bcb), SkBits2Float(0x41ec580c), SkBits2Float(0x42423f81)); // 29.598f, 48.13f, 29.543f, 48.324f, 29.543f, 48.562f
6509path.cubicTo(SkBits2Float(0x41ec6e93), SkBits2Float(0x42423f81), SkBits2Float(0x41ec9ba2), SkBits2Float(0x42426046), SkBits2Float(0x41ecb229), SkBits2Float(0x42426b89)); // 29.554f, 48.562f, 29.576f, 48.594f, 29.587f, 48.605f
6510path.cubicTo(SkBits2Float(0x41ecc8b0), SkBits2Float(0x42426b89), SkBits2Float(0x41ecdd2b), SkBits2Float(0x42426045), SkBits2Float(0x41ecf3b2), SkBits2Float(0x42426b89)); // 29.598f, 48.605f, 29.608f, 48.594f, 29.619f, 48.605f
6511path.cubicTo(SkBits2Float(0x41ecf3b2), SkBits2Float(0x42426b89), SkBits2Float(0x41eda5df), SkBits2Float(0x42426045), SkBits2Float(0x41edba5a), SkBits2Float(0x42423f81)); // 29.619f, 48.605f, 29.706f, 48.594f, 29.716f, 48.562f
6512path.cubicTo(SkBits2Float(0x41ee126a), SkBits2Float(0x4241e66a), SkBits2Float(0x41edd0e1), SkBits2Float(0x42403750), SkBits2Float(0x41eda5df), SkBits2Float(0x423fdf3f)); // 29.759f, 48.475f, 29.727f, 48.054f, 29.706f, 47.968f
6513path.lineTo(SkBits2Float(0x41ed4dcf), SkBits2Float(0x423fd3fb)); // 29.663f, 47.957f
6514path.moveTo(SkBits2Float(0x41d05a19), SkBits2Float(0x4258ab05)); // 26.044f, 54.167f
6515path.cubicTo(SkBits2Float(0x41d05a19), SkBits2Float(0x42589fc1), SkBits2Float(0x41d070a0), SkBits2Float(0x42588a40), SkBits2Float(0x41d05a19), SkBits2Float(0x42586876)); // 26.044f, 54.156f, 26.055f, 54.135f, 26.044f, 54.102f
6516path.cubicTo(SkBits2Float(0x41d05a19), SkBits2Float(0x42583c6e), SkBits2Float(0x41d02f17), SkBits2Float(0x4257ee9b), SkBits2Float(0x41d00209), SkBits2Float(0x4257c293)); // 26.044f, 54.059f, 26.023f, 53.983f, 26.001f, 53.94f
6517path.cubicTo(SkBits2Float(0x41cfeb82), SkBits2Float(0x42571cb0), SkBits2Float(0x41d00209), SkBits2Float(0x42568210), SkBits2Float(0x41cfeb82), SkBits2Float(0x4255c5a5)); // 25.99f, 53.778f, 26.001f, 53.627f, 25.99f, 53.443f
6518path.cubicTo(SkBits2Float(0x41cfeb82), SkBits2Float(0x4255a4e0), SkBits2Float(0x41cfc080), SkBits2Float(0x42552b05), SkBits2Float(0x41cfd4fb), SkBits2Float(0x4254dd32)); // 25.99f, 53.411f, 25.969f, 53.292f, 25.979f, 53.216f
6519path.cubicTo(SkBits2Float(0x41cfeb82), SkBits2Float(0x4254b12a), SkBits2Float(0x41d05a1a), SkBits2Float(0x4254b12a), SkBits2Float(0x41d0df38), SkBits2Float(0x4254c7b1)); // 25.99f, 53.173f, 26.044f, 53.173f, 26.109f, 53.195f
6520path.cubicTo(SkBits2Float(0x41d24186), SkBits2Float(0x42552b05), SkBits2Float(0x41d4ac05), SkBits2Float(0x42563f80), SkBits2Float(0x41d50621), SkBits2Float(0x42566044)); // 26.282f, 53.292f, 26.584f, 53.562f, 26.628f, 53.594f
6521path.cubicTo(SkBits2Float(0x41d60e52), SkBits2Float(0x4256da1f), SkBits2Float(0x41d70208), SkBits2Float(0x425748b7), SkBits2Float(0x41d80a3a), SkBits2Float(0x4257c292)); // 26.757f, 53.713f, 26.876f, 53.821f, 27.005f, 53.94f
6522path.cubicTo(SkBits2Float(0x41d8a5e0), SkBits2Float(0x4257f9de), SkBits2Float(0x41da1eb5), SkBits2Float(0x4258947e), SkBits2Float(0x41d8a5e0), SkBits2Float(0x4258ab05)); // 27.081f, 53.994f, 27.265f, 54.145f, 27.081f, 54.167f
6523path.cubicTo(SkBits2Float(0x41d7df38), SkBits2Float(0x4258cbca), SkBits2Float(0x41d72d0b), SkBits2Float(0x4258b649), SkBits2Float(0x41d66663), SkBits2Float(0x4258b649)); // 26.984f, 54.199f, 26.897f, 54.178f, 26.8f, 54.178f
6524path.cubicTo(SkBits2Float(0x41d547ab), SkBits2Float(0x4258cbca), SkBits2Float(0x41d1bc67), SkBits2Float(0x42592f1e), SkBits2Float(0x41d0b22a), SkBits2Float(0x4258e251)); // 26.66f, 54.199f, 26.217f, 54.296f, 26.087f, 54.221f
6525path.lineTo(SkBits2Float(0x41d0b22a), SkBits2Float(0x4258d70d)); // 26.087f, 54.21f
6526path.cubicTo(SkBits2Float(0x41d09daf), SkBits2Float(0x4258d70d), SkBits2Float(0x41d070a1), SkBits2Float(0x4258b648), SkBits2Float(0x41d05a1a), SkBits2Float(0x4258ab05)); // 26.077f, 54.21f, 26.055f, 54.178f, 26.044f, 54.167f
6527path.moveTo(SkBits2Float(0x41ce8b41), SkBits2Float(0x42588a40)); // 25.818f, 54.135f
6528path.cubicTo(SkBits2Float(0x41ceb643), SkBits2Float(0x4258ab05), SkBits2Float(0x41ce74ba), SkBits2Float(0x4258ab05), SkBits2Float(0x41ceccca), SkBits2Float(0x4258ab05)); // 25.839f, 54.167f, 25.807f, 54.167f, 25.85f, 54.167f
6529path.cubicTo(SkBits2Float(0x41cef7cc), SkBits2Float(0x4258ab05), SkBits2Float(0x41cf0e53), SkBits2Float(0x4258b336), SkBits2Float(0x41cf0e53), SkBits2Float(0x42589db5)); // 25.871f, 54.167f, 25.882f, 54.175f, 25.882f, 54.154f
6530path.cubicTo(SkBits2Float(0x41cf0e53), SkBits2Float(0x4258395b), SkBits2Float(0x41cf0a3a), SkBits2Float(0x42579790), SkBits2Float(0x41cedd2c), SkBits2Float(0x4257343c)); // 25.882f, 54.056f, 25.88f, 53.898f, 25.858f, 53.801f
6531path.cubicTo(SkBits2Float(0x41cec8b1), SkBits2Float(0x42564086), SkBits2Float(0x41ceccca), SkBits2Float(0x4254f3b9), SkBits2Float(0x41ce5e32), SkBits2Float(0x425421cd)); // 25.848f, 53.563f, 25.85f, 53.238f, 25.796f, 53.033f
6532path.lineTo(SkBits2Float(0x41cdef9a), SkBits2Float(0x425421cd)); // 25.742f, 53.033f
6533path.cubicTo(SkBits2Float(0x41cdd913), SkBits2Float(0x4254dd31), SkBits2Float(0x41ce126b), SkBits2Float(0x425626ec), SkBits2Float(0x41ce28f2), SkBits2Float(0x4256e250)); // 25.731f, 53.216f, 25.759f, 53.538f, 25.77f, 53.721f
6534path.cubicTo(SkBits2Float(0x41ce3f79), SkBits2Float(0x42579377), SkBits2Float(0x41ce47aa), SkBits2Float(0x42580f5e), SkBits2Float(0x41ce8b40), SkBits2Float(0x42588a40)); // 25.781f, 53.894f, 25.785f, 54.015f, 25.818f, 54.135f
6535path.moveTo(SkBits2Float(0x41c58d4c), SkBits2Float(0x425271ad)); // 24.694f, 52.611f
6536path.cubicTo(SkBits2Float(0x41c58d4c), SkBits2Float(0x42525c2c), SkBits2Float(0x41c5ba5a), SkBits2Float(0x42523024), SkBits2Float(0x41c5fbe4), SkBits2Float(0x425224e0)); // 24.694f, 52.59f, 24.716f, 52.547f, 24.748f, 52.536f
6537path.lineTo(SkBits2Float(0x41c6126b), SkBits2Float(0x4252199c)); // 24.759f, 52.525f
6538path.cubicTo(SkBits2Float(0x41c6978a), SkBits2Float(0x42520f5f), SkBits2Float(0x41c774b9), SkBits2Float(0x42523023), SkBits2Float(0x41c79fbb), SkBits2Float(0x42525c2b)); // 24.824f, 52.515f, 24.932f, 52.547f, 24.953f, 52.59f
6539path.cubicTo(SkBits2Float(0x41c7f9d8), SkBits2Float(0x4252a9fe), SkBits2Float(0x41c79fbb), SkBits2Float(0x4258e250), SkBits2Float(0x41c78b40), SkBits2Float(0x4259199c)); // 24.997f, 52.666f, 24.953f, 54.221f, 24.943f, 54.275f
6540path.lineTo(SkBits2Float(0x41c78b40), SkBits2Float(0x42592f1d)); // 24.943f, 54.296f
6541path.cubicTo(SkBits2Float(0x41c747aa), SkBits2Float(0x42595c2b), SkBits2Float(0x41c68103), SkBits2Float(0x42596669), SkBits2Float(0x41c5fbe4), SkBits2Float(0x42596669)); // 24.91f, 54.34f, 24.813f, 54.35f, 24.748f, 54.35f
6542path.cubicTo(SkBits2Float(0x41c5353c), SkBits2Float(0x425971ad), SkBits2Float(0x41c41684), SkBits2Float(0x425971ad), SkBits2Float(0x41c3e975), SkBits2Float(0x42592f1d)); // 24.651f, 54.361f, 24.511f, 54.361f, 24.489f, 54.296f
6543path.cubicTo(SkBits2Float(0x41c3a7ec), SkBits2Float(0x4258cbc9), SkBits2Float(0x41c42afe), SkBits2Float(0x4257d919), SkBits2Float(0x41c44185), SkBits2Float(0x42578002)); // 24.457f, 54.199f, 24.521f, 53.962f, 24.532f, 53.875f
6544path.cubicTo(SkBits2Float(0x41c46e93), SkBits2Float(0x42563f7f), SkBits2Float(0x41c4c6a4), SkBits2Float(0x42550a3f), SkBits2Float(0x41c5353b), SkBits2Float(0x4253df3d)); // 24.554f, 53.562f, 24.597f, 53.26f, 24.651f, 52.968f
6545path.cubicTo(SkBits2Float(0x41c54bc2), SkBits2Float(0x42537be9), SkBits2Float(0x41c56249), SkBits2Float(0x42530d51), SkBits2Float(0x41c58d4b), SkBits2Float(0x4252cac2)); // 24.662f, 52.871f, 24.673f, 52.763f, 24.694f, 52.698f
6546path.cubicTo(SkBits2Float(0x41c58d4b), SkBits2Float(0x4252a9fd), SkBits2Float(0x41c56249), SkBits2Float(0x42528833), SkBits2Float(0x41c58d4b), SkBits2Float(0x425271ab)); // 24.694f, 52.666f, 24.673f, 52.633f, 24.694f, 52.611f
6547path.moveTo(SkBits2Float(0x41c36662), SkBits2Float(0x42534fe0)); // 24.425f, 52.828f
6548path.cubicTo(SkBits2Float(0x41c33954), SkBits2Float(0x4253c9bb), SkBits2Float(0x41c34dcf), SkBits2Float(0x42541688), SkBits2Float(0x41c322cc), SkBits2Float(0x42549063)); // 24.403f, 52.947f, 24.413f, 53.022f, 24.392f, 53.141f
6549path.cubicTo(SkBits2Float(0x41c2f5be), SkBits2Float(0x4254fefb), SkBits2Float(0x41c2b434), SkBits2Float(0x42558e57), SkBits2Float(0x41c29dad), SkBits2Float(0x42560832)); // 24.37f, 53.249f, 24.338f, 53.389f, 24.327f, 53.508f
6550path.cubicTo(SkBits2Float(0x41c2709f), SkBits2Float(0x4256e561), SkBits2Float(0x41c2459d), SkBits2Float(0x4257ad0f), SkBits2Float(0x41c1ed8c), SkBits2Float(0x42586874)); // 24.305f, 53.724f, 24.284f, 53.919f, 24.241f, 54.102f
6551path.cubicTo(SkBits2Float(0x41c1d705), SkBits2Float(0x4258cbc8), SkBits2Float(0x41c20207), SkBits2Float(0x42590e57), SkBits2Float(0x41c1c07e), SkBits2Float(0x425950e7)); // 24.23f, 54.199f, 24.251f, 54.264f, 24.219f, 54.329f
6552path.cubicTo(SkBits2Float(0x41c1c07e), SkBits2Float(0x42596668), SkBits2Float(0x41c1686e), SkBits2Float(0x42599270), SkBits2Float(0x41c13b5f), SkBits2Float(0x42599270)); // 24.219f, 54.35f, 24.176f, 54.393f, 24.154f, 54.393f
6553path.cubicTo(SkBits2Float(0x41c0ccc7), SkBits2Float(0x4259a8f7), SkBits2Float(0x41c074b7), SkBits2Float(0x42599270), SkBits2Float(0x41c00620), SkBits2Float(0x425971ab)); // 24.1f, 54.415f, 24.057f, 54.393f, 24.003f, 54.361f
6554path.cubicTo(SkBits2Float(0x41c00620), SkBits2Float(0x425825e4), SkBits2Float(0x41c08b3f), SkBits2Float(0x4256da1e), SkBits2Float(0x41c0f9d6), SkBits2Float(0x42558e57)); // 24.003f, 54.037f, 24.068f, 53.713f, 24.122f, 53.389f
6555path.cubicTo(SkBits2Float(0x41c151e6), SkBits2Float(0x425479dc), SkBits2Float(0x41c151e6), SkBits2Float(0x42534fe0), SkBits2Float(0x41c1ed8c), SkBits2Float(0x425245a3)); // 24.165f, 53.119f, 24.165f, 52.828f, 24.241f, 52.568f
6556path.cubicTo(SkBits2Float(0x41c22f15), SkBits2Float(0x42520f5d), SkBits2Float(0x41c22f15), SkBits2Float(0x4251d70b), SkBits2Float(0x41c25c24), SkBits2Float(0x4251ccce)); // 24.273f, 52.515f, 24.273f, 52.46f, 24.295f, 52.45f
6557path.cubicTo(SkBits2Float(0x41c2e143), SkBits2Float(0x4251b647), SkBits2Float(0x41c34dce), SkBits2Float(0x4251e24f), SkBits2Float(0x41c3a7eb), SkBits2Float(0x4251e24f)); // 24.36f, 52.428f, 24.413f, 52.471f, 24.457f, 52.471f
6558path.cubicTo(SkBits2Float(0x41c3be72), SkBits2Float(0x42525c2a), SkBits2Float(0x41c37add), SkBits2Float(0x4252e149), SkBits2Float(0x41c36662), SkBits2Float(0x42534fe0)); // 24.468f, 52.59f, 24.435f, 52.72f, 24.425f, 52.828f
6559path.moveTo(SkBits2Float(0x41b3105e), SkBits2Float(0x426e020d)); // 22.383f, 59.502f
6560path.cubicTo(SkBits2Float(0x41b2ced5), SkBits2Float(0x426dcac1), SkBits2Float(0x41b28b3f), SkBits2Float(0x426d9375), SkBits2Float(0x41b21ca8), SkBits2Float(0x426d676d)); // 22.351f, 59.448f, 22.318f, 59.394f, 22.264f, 59.351f
6561path.lineTo(SkBits2Float(0x41b1f1a6), SkBits2Float(0x426d676d)); // 22.243f, 59.351f
6562path.lineTo(SkBits2Float(0x41b1f1a6), SkBits2Float(0x426d50e6)); // 22.243f, 59.329f
6563path.cubicTo(SkBits2Float(0x41b1f1a6), SkBits2Float(0x426d2f1b), SkBits2Float(0x41b1830e), SkBits2Float(0x426d199a), SkBits2Float(0x41b15600), SkBits2Float(0x426d0f5d)); // 22.243f, 59.296f, 22.189f, 59.275f, 22.167f, 59.265f
6564path.cubicTo(SkBits2Float(0x41b0e768), SkBits2Float(0x426cccce), SkBits2Float(0x41af1683), SkBits2Float(0x426bd917), SkBits2Float(0x41aefffc), SkBits2Float(0x426b8107)); // 22.113f, 59.2f, 21.886f, 58.962f, 21.875f, 58.876f
6565path.cubicTo(SkBits2Float(0x41aeeb81), SkBits2Float(0x426b3334), SkBits2Float(0x41af5a19), SkBits2Float(0x426acfe0), SkBits2Float(0x41af70a0), SkBits2Float(0x426a8d51)); // 21.865f, 58.8f, 21.919f, 58.703f, 21.93f, 58.638f
6566path.cubicTo(SkBits2Float(0x41b04dcf), SkBits2Float(0x42693647), SkBits2Float(0x41b1db1f), SkBits2Float(0x4268645b), SkBits2Float(0x41b43123), SkBits2Float(0x4267c9bc)); // 22.038f, 58.303f, 22.232f, 58.098f, 22.524f, 57.947f
6567path.cubicTo(SkBits2Float(0x41b472ac), SkBits2Float(0x4267a7f1), SkBits2Float(0x41b4f7cb), SkBits2Float(0x426770a5), SkBits2Float(0x41b56662), SkBits2Float(0x42676668)); // 22.556f, 57.914f, 22.621f, 57.86f, 22.675f, 57.85f
6568path.cubicTo(SkBits2Float(0x41b5a7eb), SkBits2Float(0x42675b24), SkBits2Float(0x41b5d4fa), SkBits2Float(0x42676668), SkBits2Float(0x41b62d0a), SkBits2Float(0x42675b24)); // 22.707f, 57.839f, 22.729f, 57.85f, 22.772f, 57.839f
6569path.cubicTo(SkBits2Float(0x41b69ba2), SkBits2Float(0x42674fe0), SkBits2Float(0x41b78f58), SkBits2Float(0x42671895), SkBits2Float(0x41b828f1), SkBits2Float(0x42671895)); // 22.826f, 57.828f, 22.945f, 57.774f, 23.02f, 57.774f
6570path.cubicTo(SkBits2Float(0x41b8ae10), SkBits2Float(0x42671895), SkBits2Float(0x41b8c497), SkBits2Float(0x42672f1c), SkBits2Float(0x41b91ca7), SkBits2Float(0x4267449d)); // 23.085f, 57.774f, 23.096f, 57.796f, 23.139f, 57.817f
6571path.lineTo(SkBits2Float(0x41b91ca7), SkBits2Float(0x42675b24)); // 23.139f, 57.839f
6572path.cubicTo(SkBits2Float(0x41b91ca7), SkBits2Float(0x42674fe0), SkBits2Float(0x41b9332e), SkBits2Float(0x426770a5), SkBits2Float(0x41b9332e), SkBits2Float(0x4267872c)); // 23.139f, 57.828f, 23.15f, 57.86f, 23.15f, 57.882f
6573path.cubicTo(SkBits2Float(0x41b91ca7), SkBits2Float(0x4267df3c), SkBits2Float(0x41b90620), SkBits2Float(0x42685918), SkBits2Float(0x41b8db1e), SkBits2Float(0x4268bc6b)); // 23.139f, 57.968f, 23.128f, 58.087f, 23.107f, 58.184f
6574path.cubicTo(SkBits2Float(0x41b855ff), SkBits2Float(0x426a29fc), SkBits2Float(0x41b7d0e1), SkBits2Float(0x426bc290), SkBits2Float(0x41b76249), SkBits2Float(0x426d2f1b)); // 23.042f, 58.541f, 22.977f, 58.94f, 22.923f, 59.296f
6575path.cubicTo(SkBits2Float(0x41b720c0), SkBits2Float(0x426e0d50), SkBits2Float(0x41b720c0), SkBits2Float(0x426ed3f8), SkBits2Float(0x41b69ba1), SkBits2Float(0x426f79dc)); // 22.891f, 59.513f, 22.891f, 59.707f, 22.826f, 59.869f
6576path.cubicTo(SkBits2Float(0x41b64391), SkBits2Float(0x426f645b), SkBits2Float(0x41b62d09), SkBits2Float(0x426f79dc), SkBits2Float(0x41b5eb80), SkBits2Float(0x426f645b)); // 22.783f, 59.848f, 22.772f, 59.869f, 22.74f, 59.848f
6577path.cubicTo(SkBits2Float(0x41b5a7ea), SkBits2Float(0x426f5917), SkBits2Float(0x41b57adc), SkBits2Float(0x426f374d), SkBits2Float(0x41b53953), SkBits2Float(0x426f1688)); // 22.707f, 59.837f, 22.685f, 59.804f, 22.653f, 59.772f
6578path.lineTo(SkBits2Float(0x41b53953), SkBits2Float(0x426f0107)); // 22.653f, 59.751f
6579path.cubicTo(SkBits2Float(0x41b472ab), SkBits2Float(0x426ea7f0), SkBits2Float(0x41b3ac03), SkBits2Float(0x426e5a1e), SkBits2Float(0x41b3105d), SkBits2Float(0x426e020d)); // 22.556f, 59.664f, 22.459f, 59.588f, 22.383f, 59.502f
6580 testSimplify(reporter, path, filename);
6581}
6582
6583static void joel_5(skiatest::Reporter* reporter, const char* filename) {
6584 SkPath path;
6585 path.setFillType((SkPathFillType) 0);
6586path.moveTo(SkBits2Float(0x43c5145a), SkBits2Float(0x43dc82f2)); // 394.159f, 441.023f
6587path.lineTo(SkBits2Float(0x43c5145a), SkBits2Float(0x43dc82f2)); // 394.159f, 441.023f
6588path.close();
6589path.moveTo(SkBits2Float(0x43af4e56), SkBits2Float(0x43dbc604)); // 350.612f, 439.547f
6590path.lineTo(SkBits2Float(0x43af4e56), SkBits2Float(0x43dbc604)); // 350.612f, 439.547f
6591path.close();
6592path.moveTo(SkBits2Float(0x43af4e56), SkBits2Float(0x43dbc604)); // 350.612f, 439.547f
6593path.cubicTo(SkBits2Float(0x43b64a5e), SkBits2Float(0x43dc9604), SkBits2Float(0x43be0958), SkBits2Float(0x43dbb604), SkBits2Float(0x43c5145a), SkBits2Float(0x43dc8312)); // 364.581f, 441.172f, 380.073f, 439.422f, 394.159f, 441.024f
6594path.cubicTo(SkBits2Float(0x43be0958), SkBits2Float(0x43dbb604), SkBits2Float(0x43b64a5e), SkBits2Float(0x43dc9604), SkBits2Float(0x43af4e56), SkBits2Float(0x43dbc604)); // 380.073f, 439.422f, 364.581f, 441.172f, 350.612f, 439.547f
6595path.close();
6596path.moveTo(SkBits2Float(0x43a9126f), SkBits2Float(0x43e11604)); // 338.144f, 450.172f
6597path.lineTo(SkBits2Float(0x43a9126f), SkBits2Float(0x43e11604)); // 338.144f, 450.172f
6598path.close();
6599path.moveTo(SkBits2Float(0x43a9126f), SkBits2Float(0x43e11604)); // 338.144f, 450.172f
6600path.cubicTo(SkBits2Float(0x43ab3c6b), SkBits2Float(0x43debc08), SkBits2Float(0x43ad1b65), SkBits2Float(0x43de18f6), SkBits2Float(0x43af4e77), SkBits2Float(0x43dbc604)); // 342.472f, 445.469f, 346.214f, 444.195f, 350.613f, 439.547f
6601path.cubicTo(SkBits2Float(0x43ad1b65), SkBits2Float(0x43de18f6), SkBits2Float(0x43ab3c6b), SkBits2Float(0x43debc08), SkBits2Float(0x43a9126f), SkBits2Float(0x43e11604)); // 346.214f, 444.195f, 342.472f, 445.469f, 338.144f, 450.172f
6602path.close();
6603path.moveTo(SkBits2Float(0x43aa9d50), SkBits2Float(0x43e173f8)); // 341.229f, 450.906f
6604path.lineTo(SkBits2Float(0x43aa9d50), SkBits2Float(0x43e173f8)); // 341.229f, 450.906f
6605path.close();
6606path.moveTo(SkBits2Float(0x43aa9d50), SkBits2Float(0x43e173f8)); // 341.229f, 450.906f
6607path.cubicTo(SkBits2Float(0x43aa0852), SkBits2Float(0x43e183f8), SkBits2Float(0x43a9be56), SkBits2Float(0x43e0d2f2), SkBits2Float(0x43a9124e), SkBits2Float(0x43e11604)); // 340.065f, 451.031f, 339.487f, 449.648f, 338.143f, 450.172f
6608path.cubicTo(SkBits2Float(0x43a9be56), SkBits2Float(0x43e0d2f2), SkBits2Float(0x43aa0852), SkBits2Float(0x43e183f8), SkBits2Float(0x43aa9d50), SkBits2Float(0x43e173f8)); // 339.487f, 449.648f, 340.065f, 451.031f, 341.229f, 450.906f
6609path.close();
6610path.moveTo(SkBits2Float(0x43b13667), SkBits2Float(0x43dce106)); // 354.425f, 441.758f
6611path.lineTo(SkBits2Float(0x43b13667), SkBits2Float(0x43dce106)); // 354.425f, 441.758f
6612path.close();
6613path.moveTo(SkBits2Float(0x43b13667), SkBits2Float(0x43dce106)); // 354.425f, 441.758f
6614path.cubicTo(SkBits2Float(0x43aead71), SkBits2Float(0x43dd9d0e), SkBits2Float(0x43acd375), SkBits2Float(0x43dff20c), SkBits2Float(0x43aa9d71), SkBits2Float(0x43e173f8)); // 349.355f, 443.227f, 345.652f, 447.891f, 341.23f, 450.906f
6615path.cubicTo(SkBits2Float(0x43acd354), SkBits2Float(0x43dff20c), SkBits2Float(0x43aead50), SkBits2Float(0x43dd9d0f), SkBits2Float(0x43b13667), SkBits2Float(0x43dce106)); // 345.651f, 447.891f, 349.354f, 443.227f, 354.425f, 441.758f
6616path.close();
6617path.moveTo(SkBits2Float(0x43ac8561), SkBits2Float(0x43e30106)); // 345.042f, 454.008f
6618path.lineTo(SkBits2Float(0x43ac8561), SkBits2Float(0x43e30106)); // 345.042f, 454.008f
6619path.close();
6620path.moveTo(SkBits2Float(0x43ac8561), SkBits2Float(0x43e30106)); // 345.042f, 454.008f
6621path.cubicTo(SkBits2Float(0x43adc76d), SkBits2Float(0x43e0f4fe), SkBits2Float(0x43b21a5f), SkBits2Float(0x43df7efa), SkBits2Float(0x43b13667), SkBits2Float(0x43dce106)); // 347.558f, 449.914f, 356.206f, 446.992f, 354.425f, 441.758f
6622path.cubicTo(SkBits2Float(0x43b21a5f), SkBits2Float(0x43df7efa), SkBits2Float(0x43adc76d), SkBits2Float(0x43e0f4fe), SkBits2Float(0x43ac8561), SkBits2Float(0x43e30106)); // 356.206f, 446.992f, 347.558f, 449.914f, 345.042f, 454.008f
6623path.close();
6624path.moveTo(SkBits2Float(0x43b33169), SkBits2Float(0x43dc82f2)); // 358.386f, 441.023f
6625path.lineTo(SkBits2Float(0x43b33169), SkBits2Float(0x43dc82f2)); // 358.386f, 441.023f
6626path.close();
6627path.moveTo(SkBits2Float(0x43b33169), SkBits2Float(0x43dc82f2)); // 358.386f, 441.023f
6628path.cubicTo(SkBits2Float(0x43b16169), SkBits2Float(0x43ded7f0), SkBits2Float(0x43aef375), SkBits2Float(0x43e13be8), SkBits2Float(0x43ac8561), SkBits2Float(0x43e300e6)); // 354.761f, 445.687f, 349.902f, 450.468f, 345.042f, 454.007f
6629path.cubicTo(SkBits2Float(0x43aef355), SkBits2Float(0x43e13c09), SkBits2Float(0x43b16169), SkBits2Float(0x43ded811), SkBits2Float(0x43b33169), SkBits2Float(0x43dc82f2)); // 349.901f, 450.469f, 354.761f, 445.688f, 358.386f, 441.023f
6630path.close();
6631path.moveTo(SkBits2Float(0x43b4bb65), SkBits2Float(0x43dd4000)); // 361.464f, 442.5f
6632path.lineTo(SkBits2Float(0x43b4bb65), SkBits2Float(0x43dd4000)); // 361.464f, 442.5f
6633path.close();
6634path.moveTo(SkBits2Float(0x43b4bb65), SkBits2Float(0x43dd4000)); // 361.464f, 442.5f
6635path.cubicTo(SkBits2Float(0x43b44959), SkBits2Float(0x43dcddf4), SkBits2Float(0x43b3e76d), SkBits2Float(0x43dc48f6), SkBits2Float(0x43b33169), SkBits2Float(0x43dc82f2)); // 360.573f, 441.734f, 359.808f, 440.57f, 358.386f, 441.023f
6636path.cubicTo(SkBits2Float(0x43b3e76d), SkBits2Float(0x43dc48f6), SkBits2Float(0x43b44959), SkBits2Float(0x43dcddf4), SkBits2Float(0x43b4bb65), SkBits2Float(0x43dd4000)); // 359.808f, 440.57f, 360.573f, 441.734f, 361.464f, 442.5f
6637path.close();
6638path.moveTo(SkBits2Float(0x43ae7f5d), SkBits2Float(0x43e5a70a)); // 348.995f, 459.305f
6639path.lineTo(SkBits2Float(0x43ae7f5d), SkBits2Float(0x43e5a70a)); // 348.995f, 459.305f
6640path.close();
6641path.moveTo(SkBits2Float(0x43ae7f5d), SkBits2Float(0x43e5a70a)); // 348.995f, 459.305f
6642path.cubicTo(SkBits2Float(0x43af945b), SkBits2Float(0x43e21d0e), SkBits2Float(0x43b3a74d), SkBits2Float(0x43e0ce14), SkBits2Float(0x43b4bb65), SkBits2Float(0x43dd4000)); // 351.159f, 452.227f, 359.307f, 449.61f, 361.464f, 442.5f
6643path.cubicTo(SkBits2Float(0x43b3a76d), SkBits2Float(0x43e0cdf4), SkBits2Float(0x43af945b), SkBits2Float(0x43e21d0e), SkBits2Float(0x43ae7f5d), SkBits2Float(0x43e5a70a)); // 359.308f, 449.609f, 351.159f, 452.227f, 348.995f, 459.305f
6644path.close();
6645path.moveTo(SkBits2Float(0x43b58a5f), SkBits2Float(0x43dce106)); // 363.081f, 441.758f
6646path.lineTo(SkBits2Float(0x43b58a5f), SkBits2Float(0x43dce106)); // 363.081f, 441.758f
6647path.close();
6648path.moveTo(SkBits2Float(0x43b58a5f), SkBits2Float(0x43dce106)); // 363.081f, 441.758f
6649path.cubicTo(SkBits2Float(0x43b2c063), SkBits2Float(0x43dfa604), SkBits2Float(0x43b1d561), SkBits2Float(0x43e374fe), SkBits2Float(0x43ae7f5d), SkBits2Float(0x43e5a70a)); // 357.503f, 447.297f, 355.667f, 454.914f, 348.995f, 459.305f
6650path.cubicTo(SkBits2Float(0x43b1d561), SkBits2Float(0x43e374fe), SkBits2Float(0x43b2c063), SkBits2Float(0x43dfa604), SkBits2Float(0x43b58a5f), SkBits2Float(0x43dce106)); // 355.667f, 454.914f, 357.503f, 447.297f, 363.081f, 441.758f
6651path.close();
6652path.moveTo(SkBits2Float(0x43b6b561), SkBits2Float(0x43dd4000)); // 365.417f, 442.5f
6653path.lineTo(SkBits2Float(0x43b6b561), SkBits2Float(0x43dd4000)); // 365.417f, 442.5f
6654path.close();
6655path.moveTo(SkBits2Float(0x43b6b561), SkBits2Float(0x43dd4000)); // 365.417f, 442.5f
6656path.lineTo(SkBits2Float(0x43b58a5f), SkBits2Float(0x43dce106)); // 363.081f, 441.758f
6657path.lineTo(SkBits2Float(0x43b6b561), SkBits2Float(0x43dd4000)); // 365.417f, 442.5f
6658path.close();
6659path.moveTo(SkBits2Float(0x43b07a5f), SkBits2Float(0x43e7220c)); // 352.956f, 462.266f
6660path.lineTo(SkBits2Float(0x43b07a5f), SkBits2Float(0x43e7220c)); // 352.956f, 462.266f
6661path.close();
6662path.moveTo(SkBits2Float(0x43b07a5f), SkBits2Float(0x43e7220c)); // 352.956f, 462.266f
6663path.cubicTo(SkBits2Float(0x43b29f5d), SkBits2Float(0x43e3e810), SkBits2Float(0x43b59667), SkBits2Float(0x43e0f916), SkBits2Float(0x43b6b561), SkBits2Float(0x43dd4000)); // 357.245f, 455.813f, 363.175f, 449.946f, 365.417f, 442.5f
6664path.cubicTo(SkBits2Float(0x43b59667), SkBits2Float(0x43e0f8f6), SkBits2Float(0x43b29f5d), SkBits2Float(0x43e3e7f0), SkBits2Float(0x43b07a5f), SkBits2Float(0x43e7220c)); // 363.175f, 449.945f, 357.245f, 455.812f, 352.956f, 462.266f
6665path.close();
6666path.moveTo(SkBits2Float(0x43b0d853), SkBits2Float(0x43e84efa)); // 353.69f, 464.617f
6667path.lineTo(SkBits2Float(0x43b0d853), SkBits2Float(0x43e84efa)); // 353.69f, 464.617f
6668path.close();
6669path.moveTo(SkBits2Float(0x43b0d853), SkBits2Float(0x43e84efa)); // 353.69f, 464.617f
6670path.cubicTo(SkBits2Float(0x43b03a5f), SkBits2Float(0x43e934fe), SkBits2Float(0x43b1345b), SkBits2Float(0x43e7870a), SkBits2Float(0x43b07a5f), SkBits2Float(0x43e721ec)); // 352.456f, 466.414f, 354.409f, 463.055f, 352.956f, 462.265f
6671path.cubicTo(SkBits2Float(0x43b1345b), SkBits2Float(0x43e7870b), SkBits2Float(0x43b03a5f), SkBits2Float(0x43e934fe), SkBits2Float(0x43b0d853), SkBits2Float(0x43e84efa)); // 354.409f, 463.055f, 352.456f, 466.414f, 353.69f, 464.617f
6672path.close();
6673path.moveTo(SkBits2Float(0x43b84063), SkBits2Float(0x43ddb106)); // 368.503f, 443.383f
6674path.lineTo(SkBits2Float(0x43b84063), SkBits2Float(0x43ddb106)); // 368.503f, 443.383f
6675path.close();
6676path.moveTo(SkBits2Float(0x43b84063), SkBits2Float(0x43ddb106)); // 368.503f, 443.383f
6677path.cubicTo(SkBits2Float(0x43b42667), SkBits2Float(0x43e039fc), SkBits2Float(0x43b39d71), SkBits2Float(0x43e4e000), SkBits2Float(0x43b0d873), SkBits2Float(0x43e84efa)); // 360.3f, 448.453f, 359.23f, 457.75f, 353.691f, 464.617f
6678path.cubicTo(SkBits2Float(0x43b39d50), SkBits2Float(0x43e4e000), SkBits2Float(0x43b42667), SkBits2Float(0x43e039fc), SkBits2Float(0x43b84063), SkBits2Float(0x43ddb106)); // 359.229f, 457.75f, 360.3f, 448.453f, 368.503f, 443.383f
6679path.close();
6680path.moveTo(SkBits2Float(0x43b89d51), SkBits2Float(0x43de0efa)); // 369.229f, 444.117f
6681path.lineTo(SkBits2Float(0x43b89d51), SkBits2Float(0x43de0efa)); // 369.229f, 444.117f
6682path.close();
6683path.moveTo(SkBits2Float(0x43b89d51), SkBits2Float(0x43de0efa)); // 369.229f, 444.117f
6684path.lineTo(SkBits2Float(0x43b84043), SkBits2Float(0x43ddb106)); // 368.502f, 443.383f
6685path.lineTo(SkBits2Float(0x43b89d51), SkBits2Float(0x43de0efa)); // 369.229f, 444.117f
6686path.close();
6687path.moveTo(SkBits2Float(0x43b26270), SkBits2Float(0x43e90c08)); // 356.769f, 466.094f
6688path.lineTo(SkBits2Float(0x43b26270), SkBits2Float(0x43e90c08)); // 356.769f, 466.094f
6689path.close();
6690path.moveTo(SkBits2Float(0x43b26270), SkBits2Float(0x43e90c08)); // 356.769f, 466.094f
6691path.cubicTo(SkBits2Float(0x43b48d72), SkBits2Float(0x43e569fc), SkBits2Float(0x43b7897a), SkBits2Float(0x43e21d0e), SkBits2Float(0x43b89d72), SkBits2Float(0x43de0efa)); // 361.105f, 458.828f, 367.074f, 452.227f, 369.23f, 444.117f
6692path.cubicTo(SkBits2Float(0x43b78959), SkBits2Float(0x43e21d0e), SkBits2Float(0x43b48d51), SkBits2Float(0x43e569fc), SkBits2Float(0x43b26270), SkBits2Float(0x43e90c08)); // 367.073f, 452.227f, 361.104f, 458.828f, 356.769f, 466.094f
6693path.close();
6694path.moveTo(SkBits2Float(0x43b3316a), SkBits2Float(0x43e90c08)); // 358.386f, 466.094f
6695path.lineTo(SkBits2Float(0x43b3316a), SkBits2Float(0x43e90c08)); // 358.386f, 466.094f
6696path.close();
6697path.moveTo(SkBits2Float(0x43b3316a), SkBits2Float(0x43e90c08)); // 358.386f, 466.094f
6698path.lineTo(SkBits2Float(0x43b26270), SkBits2Float(0x43e90c08)); // 356.769f, 466.094f
6699path.lineTo(SkBits2Float(0x43b3316a), SkBits2Float(0x43e90c08)); // 358.386f, 466.094f
6700path.close();
6701path.moveTo(SkBits2Float(0x43ba2853), SkBits2Float(0x43ddb106)); // 372.315f, 443.383f
6702path.lineTo(SkBits2Float(0x43ba2853), SkBits2Float(0x43ddb106)); // 372.315f, 443.383f
6703path.close();
6704path.moveTo(SkBits2Float(0x43ba2853), SkBits2Float(0x43ddb106)); // 372.315f, 443.383f
6705path.cubicTo(SkBits2Float(0x43b7d74d), SkBits2Float(0x43e17604), SkBits2Float(0x43b5824f), SkBits2Float(0x43e59604), SkBits2Float(0x43b33149), SkBits2Float(0x43e90c08)); // 367.682f, 450.922f, 363.018f, 459.172f, 358.385f, 466.094f
6706path.cubicTo(SkBits2Float(0x43b58270), SkBits2Float(0x43e59604), SkBits2Float(0x43b7d76e), SkBits2Float(0x43e17604), SkBits2Float(0x43ba2853), SkBits2Float(0x43ddb106)); // 363.019f, 459.172f, 367.683f, 450.922f, 372.315f, 443.383f
6707path.close();
6708path.moveTo(SkBits2Float(0x43bb5355), SkBits2Float(0x43de0efa)); // 374.651f, 444.117f
6709path.lineTo(SkBits2Float(0x43bb5355), SkBits2Float(0x43de0efa)); // 374.651f, 444.117f
6710path.close();
6711path.moveTo(SkBits2Float(0x43bb5355), SkBits2Float(0x43de0efa)); // 374.651f, 444.117f
6712path.cubicTo(SkBits2Float(0x43bb1853), SkBits2Float(0x43dd92f2), SkBits2Float(0x43ba9e57), SkBits2Float(0x43ddab02), SkBits2Float(0x43ba2853), SkBits2Float(0x43ddb106)); // 374.19f, 443.148f, 373.237f, 443.336f, 372.315f, 443.383f
6713path.cubicTo(SkBits2Float(0x43ba9e57), SkBits2Float(0x43ddab02), SkBits2Float(0x43bb1853), SkBits2Float(0x43dd92f2), SkBits2Float(0x43bb5355), SkBits2Float(0x43de0efa)); // 373.237f, 443.336f, 374.19f, 443.148f, 374.651f, 444.117f
6714path.close();
6715path.moveTo(SkBits2Float(0x43b58a5f), SkBits2Float(0x43e90c08)); // 363.081f, 466.094f
6716path.lineTo(SkBits2Float(0x43b58a5f), SkBits2Float(0x43e90c08)); // 363.081f, 466.094f
6717path.close();
6718path.moveTo(SkBits2Float(0x43b58a5f), SkBits2Float(0x43e90c08)); // 363.081f, 466.094f
6719path.cubicTo(SkBits2Float(0x43b76c6b), SkBits2Float(0x43e55d0e), SkBits2Float(0x43ba4a5f), SkBits2Float(0x43e21312), SkBits2Float(0x43bb5355), SkBits2Float(0x43de0efa)); // 366.847f, 458.727f, 372.581f, 452.149f, 374.651f, 444.117f
6720path.cubicTo(SkBits2Float(0x43ba4a5f), SkBits2Float(0x43e212f2), SkBits2Float(0x43b76c6c), SkBits2Float(0x43e55d0e), SkBits2Float(0x43b58a5f), SkBits2Float(0x43e90c08)); // 372.581f, 452.148f, 366.847f, 458.727f, 363.081f, 466.094f
6721path.close();
6722path.moveTo(SkBits2Float(0x43b6b561), SkBits2Float(0x43e90c08)); // 365.417f, 466.094f
6723path.lineTo(SkBits2Float(0x43b6b561), SkBits2Float(0x43e90c08)); // 365.417f, 466.094f
6724path.close();
6725path.moveTo(SkBits2Float(0x43b6b561), SkBits2Float(0x43e90c08)); // 365.417f, 466.094f
6726path.lineTo(SkBits2Float(0x43b58a5f), SkBits2Float(0x43e90c08)); // 363.081f, 466.094f
6727path.lineTo(SkBits2Float(0x43b6b561), SkBits2Float(0x43e90c08)); // 365.417f, 466.094f
6728path.close();
6729path.moveTo(SkBits2Float(0x43bc8063), SkBits2Float(0x43e058f6)); // 377.003f, 448.695f
6730path.lineTo(SkBits2Float(0x43bc8063), SkBits2Float(0x43e058f6)); // 377.003f, 448.695f
6731path.close();
6732path.moveTo(SkBits2Float(0x43bc8063), SkBits2Float(0x43e058f6)); // 377.003f, 448.695f
6733path.cubicTo(SkBits2Float(0x43b9de57), SkBits2Float(0x43e29df4), SkBits2Float(0x43b84355), SkBits2Float(0x43e5fefa), SkBits2Float(0x43b6b561), SkBits2Float(0x43e90be8)); // 371.737f, 453.234f, 368.526f, 459.992f, 365.417f, 466.093f
6734path.cubicTo(SkBits2Float(0x43b84355), SkBits2Float(0x43e5fefa), SkBits2Float(0x43b9de57), SkBits2Float(0x43e29df4), SkBits2Float(0x43bc8063), SkBits2Float(0x43e058f6)); // 368.526f, 459.992f, 371.737f, 453.234f, 377.003f, 448.695f
6735path.close();
6736path.moveTo(SkBits2Float(0x43b89d51), SkBits2Float(0x43e969fc)); // 369.229f, 466.828f
6737path.lineTo(SkBits2Float(0x43b89d51), SkBits2Float(0x43e969fc)); // 369.229f, 466.828f
6738path.close();
6739path.moveTo(SkBits2Float(0x43b89d51), SkBits2Float(0x43e969fc)); // 369.229f, 466.828f
6740path.cubicTo(SkBits2Float(0x43b98149), SkBits2Float(0x43e637f0), SkBits2Float(0x43bd3355), SkBits2Float(0x43e3adf4), SkBits2Float(0x43bc8043), SkBits2Float(0x43e058f6)); // 371.01f, 460.437f, 378.401f, 455.359f, 377.002f, 448.695f
6741path.cubicTo(SkBits2Float(0x43bd3355), SkBits2Float(0x43e3adf4), SkBits2Float(0x43b9816a), SkBits2Float(0x43e638f6), SkBits2Float(0x43b89d51), SkBits2Float(0x43e969fc)); // 378.401f, 455.359f, 371.011f, 460.445f, 369.229f, 466.828f
6742path.close();
6743path.moveTo(SkBits2Float(0x43ba8668), SkBits2Float(0x43e9c7f0)); // 373.05f, 467.562f
6744path.lineTo(SkBits2Float(0x43ba8668), SkBits2Float(0x43e9c7f0)); // 373.05f, 467.562f
6745path.close();
6746path.moveTo(SkBits2Float(0x43ba8668), SkBits2Float(0x43e9c7f0)); // 373.05f, 467.562f
6747path.cubicTo(SkBits2Float(0x43ba1376), SkBits2Float(0x43e90000), SkBits2Float(0x43b94270), SkBits2Float(0x43e8f1ec), SkBits2Float(0x43b89d72), SkBits2Float(0x43e969fc)); // 372.152f, 466, 370.519f, 465.89f, 369.23f, 466.828f
6748path.cubicTo(SkBits2Float(0x43b94270), SkBits2Float(0x43e8f20c), SkBits2Float(0x43ba1355), SkBits2Float(0x43e90000), SkBits2Float(0x43ba8668), SkBits2Float(0x43e9c7f0)); // 370.519f, 465.891f, 372.151f, 466, 373.05f, 467.562f
6749path.close();
6750path.moveTo(SkBits2Float(0x43c0c064), SkBits2Float(0x43dc82f2)); // 385.503f, 441.023f
6751path.lineTo(SkBits2Float(0x43c0c064), SkBits2Float(0x43dc82f2)); // 385.503f, 441.023f
6752path.close();
6753path.moveTo(SkBits2Float(0x43c0c064), SkBits2Float(0x43dc82f2)); // 385.503f, 441.023f
6754path.cubicTo(SkBits2Float(0x43be095a), SkBits2Float(0x43e0acee), SkBits2Float(0x43bd8a60), SkBits2Float(0x43e5c0e6), SkBits2Float(0x43ba8668), SkBits2Float(0x43e9c7f0)); // 380.073f, 449.351f, 379.081f, 459.507f, 373.05f, 467.562f
6755path.cubicTo(SkBits2Float(0x43bd8a60), SkBits2Float(0x43e5c107), SkBits2Float(0x43be095a), SkBits2Float(0x43e0ad0f), SkBits2Float(0x43c0c064), SkBits2Float(0x43dc82f2)); // 379.081f, 459.508f, 380.073f, 449.352f, 385.503f, 441.023f
6756path.close();
6757path.moveTo(SkBits2Float(0x43c00562), SkBits2Float(0x43e23000)); // 384.042f, 452.375f
6758path.lineTo(SkBits2Float(0x43c00562), SkBits2Float(0x43e23000)); // 384.042f, 452.375f
6759path.close();
6760path.moveTo(SkBits2Float(0x43c00562), SkBits2Float(0x43e23000)); // 384.042f, 452.375f
6761path.cubicTo(SkBits2Float(0x43bfaf5e), SkBits2Float(0x43e013f8), SkBits2Float(0x43c40668), SkBits2Float(0x43ddc2f2), SkBits2Float(0x43c0c064), SkBits2Float(0x43dc82f2)); // 383.37f, 448.156f, 392.05f, 443.523f, 385.503f, 441.023f
6762path.cubicTo(SkBits2Float(0x43c40668), SkBits2Float(0x43ddc2f2), SkBits2Float(0x43bfaf5e), SkBits2Float(0x43e013f8), SkBits2Float(0x43c00562), SkBits2Float(0x43e23000)); // 392.05f, 443.523f, 383.37f, 448.156f, 384.042f, 452.375f
6763path.close();
6764path.moveTo(SkBits2Float(0x43bed854), SkBits2Float(0x43e5370a)); // 381.69f, 458.43f
6765path.lineTo(SkBits2Float(0x43bed854), SkBits2Float(0x43e5370a)); // 381.69f, 458.43f
6766path.close();
6767path.moveTo(SkBits2Float(0x43bed854), SkBits2Float(0x43e5370a)); // 381.69f, 458.43f
6768path.cubicTo(SkBits2Float(0x43c06562), SkBits2Float(0x43e4b4fe), SkBits2Float(0x43bf095a), SkBits2Float(0x43e2fd0e), SkBits2Float(0x43c00562), SkBits2Float(0x43e23000)); // 384.792f, 457.414f, 382.073f, 453.977f, 384.042f, 452.375f
6769path.cubicTo(SkBits2Float(0x43bf095a), SkBits2Float(0x43e2fdf4), SkBits2Float(0x43c06562), SkBits2Float(0x43e4b4fe), SkBits2Float(0x43bed854), SkBits2Float(0x43e5370a)); // 382.073f, 453.984f, 384.792f, 457.414f, 381.69f, 458.43f
6770path.close();
6771path.moveTo(SkBits2Float(0x43bf3668), SkBits2Float(0x43e5a70a)); // 382.425f, 459.305f
6772path.lineTo(SkBits2Float(0x43bf3668), SkBits2Float(0x43e5a70a)); // 382.425f, 459.305f
6773path.close();
6774path.moveTo(SkBits2Float(0x43bf3668), SkBits2Float(0x43e5a70a)); // 382.425f, 459.305f
6775path.lineTo(SkBits2Float(0x43bed874), SkBits2Float(0x43e5370a)); // 381.691f, 458.43f
6776path.lineTo(SkBits2Float(0x43bf3668), SkBits2Float(0x43e5a70a)); // 382.425f, 459.305f
6777path.close();
6778path.moveTo(SkBits2Float(0x43bcde58), SkBits2Float(0x43e9c7ef)); // 377.737f, 467.562f
6779path.lineTo(SkBits2Float(0x43bcde58), SkBits2Float(0x43e9c7ef)); // 377.737f, 467.562f
6780path.close();
6781path.moveTo(SkBits2Float(0x43bcde58), SkBits2Float(0x43e9c7ef)); // 377.737f, 467.562f
6782path.cubicTo(SkBits2Float(0x43bdfb66), SkBits2Float(0x43e888f5), SkBits2Float(0x43bd6854), SkBits2Float(0x43e69ced), SkBits2Float(0x43bf3668), SkBits2Float(0x43e5a6e9)); // 379.964f, 465.07f, 378.815f, 461.226f, 382.425f, 459.304f
6783path.cubicTo(SkBits2Float(0x43bd6854), SkBits2Float(0x43e69d0e), SkBits2Float(0x43bdfb66), SkBits2Float(0x43e888f5), SkBits2Float(0x43bcde58), SkBits2Float(0x43e9c7ef)); // 378.815f, 461.227f, 379.964f, 465.07f, 377.737f, 467.562f
6784path.close();
6785path.moveTo(SkBits2Float(0x43bf3668), SkBits2Float(0x43ea9810)); // 382.425f, 469.188f
6786path.lineTo(SkBits2Float(0x43bf3668), SkBits2Float(0x43ea9810)); // 382.425f, 469.188f
6787path.close();
6788path.moveTo(SkBits2Float(0x43bf3668), SkBits2Float(0x43ea9810)); // 382.425f, 469.188f
6789path.cubicTo(SkBits2Float(0x43bebf5e), SkBits2Float(0x43e99e14), SkBits2Float(0x43bdc562), SkBits2Float(0x43e9d70a), SkBits2Float(0x43bcde58), SkBits2Float(0x43e9c810)); // 381.495f, 467.235f, 379.542f, 467.68f, 377.737f, 467.563f
6790path.cubicTo(SkBits2Float(0x43bdc562), SkBits2Float(0x43e9d70a), SkBits2Float(0x43bebf5e), SkBits2Float(0x43e99df3), SkBits2Float(0x43bf3668), SkBits2Float(0x43ea9810)); // 379.542f, 467.68f, 381.495f, 467.234f, 382.425f, 469.188f
6791path.close();
6792path.moveTo(SkBits2Float(0x43c0c064), SkBits2Float(0x43e78000)); // 385.503f, 463
6793path.lineTo(SkBits2Float(0x43c0c064), SkBits2Float(0x43e78000)); // 385.503f, 463
6794path.close();
6795path.moveTo(SkBits2Float(0x43c0c064), SkBits2Float(0x43e78000)); // 385.503f, 463
6796path.cubicTo(SkBits2Float(0x43bfaf5e), SkBits2Float(0x43e7f9fc), SkBits2Float(0x43bfbe58), SkBits2Float(0x43e98b02), SkBits2Float(0x43bf3668), SkBits2Float(0x43ea9810)); // 383.37f, 463.953f, 383.487f, 467.086f, 382.425f, 469.188f
6797path.cubicTo(SkBits2Float(0x43bfbe58), SkBits2Float(0x43e98b02), SkBits2Float(0x43bfaf5e), SkBits2Float(0x43e7f9fc), SkBits2Float(0x43c0c064), SkBits2Float(0x43e78000)); // 383.487f, 467.086f, 383.37f, 463.953f, 385.503f, 463
6798path.close();
6799path.moveTo(SkBits2Float(0x43c1316a), SkBits2Float(0x43e35efa)); // 386.386f, 454.742f
6800path.lineTo(SkBits2Float(0x43c1316a), SkBits2Float(0x43e35efa)); // 386.386f, 454.742f
6801path.close();
6802path.moveTo(SkBits2Float(0x43c1316a), SkBits2Float(0x43e35efa)); // 386.386f, 454.742f
6803path.cubicTo(SkBits2Float(0x43c35270), SkBits2Float(0x43e586ea), SkBits2Float(0x43beb064), SkBits2Float(0x43e561ec), SkBits2Float(0x43c0c064), SkBits2Float(0x43e78000)); // 390.644f, 459.054f, 381.378f, 458.765f, 385.503f, 463
6804path.cubicTo(SkBits2Float(0x43beb064), SkBits2Float(0x43e5620c), SkBits2Float(0x43c35270), SkBits2Float(0x43e5870a), SkBits2Float(0x43c1316a), SkBits2Float(0x43e35efa)); // 381.378f, 458.766f, 390.644f, 459.055f, 386.386f, 454.742f
6805path.close();
6806path.moveTo(SkBits2Float(0x43c3e76e), SkBits2Float(0x43df2b02)); // 391.808f, 446.336f
6807path.lineTo(SkBits2Float(0x43c3e76e), SkBits2Float(0x43df2b02)); // 391.808f, 446.336f
6808path.close();
6809path.moveTo(SkBits2Float(0x43c3e76e), SkBits2Float(0x43df2b02)); // 391.808f, 446.336f
6810path.cubicTo(SkBits2Float(0x43c2ba60), SkBits2Float(0x43e07810), SkBits2Float(0x43c32a60), SkBits2Float(0x43e31106), SkBits2Float(0x43c1316a), SkBits2Float(0x43e35efa)); // 389.456f, 448.938f, 390.331f, 454.133f, 386.386f, 454.742f
6811path.cubicTo(SkBits2Float(0x43c32a60), SkBits2Float(0x43e31106), SkBits2Float(0x43c2ba60), SkBits2Float(0x43e07811), SkBits2Float(0x43c3e76e), SkBits2Float(0x43df2b02)); // 390.331f, 454.133f, 389.456f, 448.938f, 391.808f, 446.336f
6812path.close();
6813path.moveTo(SkBits2Float(0x43c3e76e), SkBits2Float(0x43dd4000)); // 391.808f, 442.5f
6814path.lineTo(SkBits2Float(0x43c3e76e), SkBits2Float(0x43dd4000)); // 391.808f, 442.5f
6815path.close();
6816path.moveTo(SkBits2Float(0x43c3e76e), SkBits2Float(0x43dd4000)); // 391.808f, 442.5f
6817path.cubicTo(SkBits2Float(0x43c2a668), SkBits2Float(0x43ddbefa), SkBits2Float(0x43c35f7e), SkBits2Float(0x43def4fe), SkBits2Float(0x43c3e76e), SkBits2Float(0x43df2b02)); // 389.3f, 443.492f, 390.746f, 445.914f, 391.808f, 446.336f
6818path.cubicTo(SkBits2Float(0x43c35f5e), SkBits2Float(0x43def4fe), SkBits2Float(0x43c2a668), SkBits2Float(0x43ddbefa), SkBits2Float(0x43c3e76e), SkBits2Float(0x43dd4000)); // 390.745f, 445.914f, 389.3f, 443.492f, 391.808f, 442.5f
6819path.close();
6820path.moveTo(SkBits2Float(0x43c44562), SkBits2Float(0x43ddb106)); // 392.542f, 443.383f
6821path.lineTo(SkBits2Float(0x43c44562), SkBits2Float(0x43ddb106)); // 392.542f, 443.383f
6822path.close();
6823path.moveTo(SkBits2Float(0x43c44562), SkBits2Float(0x43ddb106)); // 392.542f, 443.383f
6824path.lineTo(SkBits2Float(0x43c3e76e), SkBits2Float(0x43dd4000)); // 391.808f, 442.5f
6825path.lineTo(SkBits2Float(0x43c44562), SkBits2Float(0x43ddb106)); // 392.542f, 443.383f
6826path.close();
6827path.moveTo(SkBits2Float(0x43c5145c), SkBits2Float(0x43dc82f2)); // 394.159f, 441.023f
6828path.lineTo(SkBits2Float(0x43c44562), SkBits2Float(0x43ddb0e6)); // 392.542f, 443.382f
6829path.lineTo(SkBits2Float(0x43c5145c), SkBits2Float(0x43dc82f2)); // 394.159f, 441.023f
6830path.close();
6831 testSimplify(reporter, path, filename);
6832}
6833
6834static void joel_6(skiatest::Reporter* reporter, const char* filename) {
6835 SkPath path;
6836path.moveTo(SkBits2Float(0x43c38c6a), SkBits2Float(0x43a739fc)); // 391.097f, 334.453f
6837path.lineTo(SkBits2Float(0x43c36168), SkBits2Float(0x43a74efa)); // 390.761f, 334.617f
6838path.lineTo(SkBits2Float(0x43c33666), SkBits2Float(0x43a6f7f0)); // 390.425f, 333.937f
6839path.lineTo(SkBits2Float(0x43c36168), SkBits2Float(0x43a6e1ec)); // 390.761f, 333.765f
6840path.lineTo(SkBits2Float(0x43c38c6a), SkBits2Float(0x43a739fc)); // 391.097f, 334.453f
6841path.close();
6842path.moveTo(SkBits2Float(0x43c39062), SkBits2Float(0x43a73810)); // 391.128f, 334.438f
6843path.lineTo(SkBits2Float(0x43c3676c), SkBits2Float(0x43a75106)); // 390.808f, 334.633f
6844path.lineTo(SkBits2Float(0x43c33374), SkBits2Float(0x43a6fefa)); // 390.402f, 333.992f
6845path.lineTo(SkBits2Float(0x43c35d70), SkBits2Float(0x43a6e3f8)); // 390.73f, 333.781f
6846path.lineTo(SkBits2Float(0x43c39062), SkBits2Float(0x43a73811)); // 391.128f, 334.438f
6847path.lineTo(SkBits2Float(0x43c39062), SkBits2Float(0x43a73810)); // 391.128f, 334.438f
6848path.close();
6849path.moveTo(SkBits2Float(0x43e38958), SkBits2Float(0x43971c08)); // 455.073f, 302.219f
6850path.lineTo(SkBits2Float(0x43e3824e), SkBits2Float(0x43973000)); // 455.018f, 302.375f
6851path.lineTo(SkBits2Float(0x43e36f5c), SkBits2Float(0x439739fc)); // 454.87f, 302.453f
6852path.lineTo(SkBits2Float(0x43e35a5e), SkBits2Float(0x43970df4)); // 454.706f, 302.109f
6853path.lineTo(SkBits2Float(0x43e38958), SkBits2Float(0x43971c08)); // 455.073f, 302.219f
6854path.close();
6855path.moveTo(SkBits2Float(0x43e36f5c), SkBits2Float(0x439739fc)); // 454.87f, 302.453f
6856path.lineTo(SkBits2Float(0x43c38c6a), SkBits2Float(0x43a739fc)); // 391.097f, 334.453f
6857path.lineTo(SkBits2Float(0x43c36168), SkBits2Float(0x43a6e1ec)); // 390.761f, 333.765f
6858path.lineTo(SkBits2Float(0x43e3445a), SkBits2Float(0x4396e1ec)); // 454.534f, 301.765f
6859path.lineTo(SkBits2Float(0x43e36f5c), SkBits2Float(0x439739fc)); // 454.87f, 302.453f
6860path.close();
6861path.moveTo(SkBits2Float(0x43e41f5c), SkBits2Float(0x43946efa)); // 456.245f, 296.867f
6862path.lineTo(SkBits2Float(0x43e4545a), SkBits2Float(0x439479fc)); // 456.659f, 296.953f
6863path.lineTo(SkBits2Float(0x43e44354), SkBits2Float(0x4394acee)); // 456.526f, 297.351f
6864path.lineTo(SkBits2Float(0x43e41646), SkBits2Float(0x43949efa)); // 456.174f, 297.242f
6865path.lineTo(SkBits2Float(0x43e41f5d), SkBits2Float(0x43946efa)); // 456.245f, 296.867f
6866path.lineTo(SkBits2Float(0x43e41f5c), SkBits2Float(0x43946efa)); // 456.245f, 296.867f
6867path.close();
6868path.moveTo(SkBits2Float(0x43e44354), SkBits2Float(0x4394ad0e)); // 456.526f, 297.352f
6869path.lineTo(SkBits2Float(0x43e38958), SkBits2Float(0x43971c08)); // 455.073f, 302.219f
6870path.lineTo(SkBits2Float(0x43e32b64), SkBits2Float(0x43970000)); // 454.339f, 302
6871path.lineTo(SkBits2Float(0x43e3e76c), SkBits2Float(0x43949106)); // 455.808f, 297.133f
6872path.lineTo(SkBits2Float(0x43e44353), SkBits2Float(0x4394ad0e)); // 456.526f, 297.352f
6873path.lineTo(SkBits2Float(0x43e44354), SkBits2Float(0x4394ad0e)); // 456.526f, 297.352f
6874path.close();
6875path.moveTo(SkBits2Float(0x43e17d50), SkBits2Float(0x4393f20c)); // 450.979f, 295.891f
6876path.lineTo(SkBits2Float(0x43e18e56), SkBits2Float(0x4393e810)); // 451.112f, 295.813f
6877path.lineTo(SkBits2Float(0x43e1a148), SkBits2Float(0x4393eb02)); // 451.26f, 295.836f
6878path.lineTo(SkBits2Float(0x43e19852), SkBits2Float(0x43941b02)); // 451.19f, 296.211f
6879path.lineTo(SkBits2Float(0x43e17d50), SkBits2Float(0x4393f20c)); // 450.979f, 295.891f
6880path.close();
6881path.moveTo(SkBits2Float(0x43e1a169), SkBits2Float(0x4393eb02)); // 451.261f, 295.836f
6882path.lineTo(SkBits2Float(0x43e41f5d), SkBits2Float(0x43946efa)); // 456.245f, 296.867f
6883path.lineTo(SkBits2Float(0x43e40b65), SkBits2Float(0x4394cefa)); // 456.089f, 297.617f
6884path.lineTo(SkBits2Float(0x43e18d71), SkBits2Float(0x43944b02)); // 451.105f, 296.586f
6885path.lineTo(SkBits2Float(0x43e1a169), SkBits2Float(0x4393eb02)); // 451.261f, 295.836f
6886path.close();
6887path.moveTo(SkBits2Float(0x43c35d50), SkBits2Float(0x43a6e3f8)); // 390.729f, 333.781f
6888path.lineTo(SkBits2Float(0x43e17d50), SkBits2Float(0x4393f1ec)); // 450.979f, 295.89f
6889path.lineTo(SkBits2Float(0x43e1b148), SkBits2Float(0x439443f8)); // 451.385f, 296.531f
6890path.lineTo(SkBits2Float(0x43c39042), SkBits2Float(0x43a737f0)); // 391.127f, 334.437f
6891path.lineTo(SkBits2Float(0x43c35d50), SkBits2Float(0x43a6e3f8)); // 390.729f, 333.781f
6892path.close();
6893testSimplify(reporter, path, filename);
6894}
6895
6896static void joel_7(skiatest::Reporter* reporter, const char* filename) {
6897 SkPath path;
6898path.moveTo(SkBits2Float(0x4321220c), SkBits2Float(0x43eac70a)); // 161.133f, 469.555f
6899path.lineTo(SkBits2Float(0x4321220c), SkBits2Float(0x43eac70a)); // 161.133f, 469.555f
6900path.lineTo(SkBits2Float(0x431f8e14), SkBits2Float(0x43eb3b02)); // 159.555f, 470.461f
6901path.lineTo(SkBits2Float(0x4321220c), SkBits2Float(0x43eac70a)); // 161.133f, 469.555f
6902path.close();
6903path.moveTo(SkBits2Float(0x431e33f8), SkBits2Float(0x43f03b02)); // 158.203f, 480.461f
6904path.lineTo(SkBits2Float(0x431e33f8), SkBits2Float(0x43f03b02)); // 158.203f, 480.461f
6905path.lineTo(SkBits2Float(0x431e33f8), SkBits2Float(0x43f03b02)); // 158.203f, 480.461f
6906path.lineTo(SkBits2Float(0x431d4c08), SkBits2Float(0x43ef720c)); // 157.297f, 478.891f
6907path.lineTo(SkBits2Float(0x431e33f8), SkBits2Float(0x43f03b02)); // 158.203f, 480.461f
6908path.close();
6909path.moveTo(SkBits2Float(0x431c6419), SkBits2Float(0x43eea7f0)); // 156.391f, 477.312f
6910path.cubicTo(SkBits2Float(0x431d6e15), SkBits2Float(0x43ee5ae2), SkBits2Float(0x431e2000), SkBits2Float(0x43ede000), SkBits2Float(0x431e69fc), SkBits2Float(0x43ed55e4)); // 157.43f, 476.71f, 158.125f, 475.75f, 158.414f, 474.671f
6911path.cubicTo(SkBits2Float(0x431eb3f8), SkBits2Float(0x43eccbc8), SkBits2Float(0x431e93f8), SkBits2Float(0x43ec35e4), SkBits2Float(0x431df9db), SkBits2Float(0x43ebafe0)); // 158.703f, 473.592f, 158.578f, 472.421f, 157.976f, 471.374f
6912path.lineTo(SkBits2Float(0x432121cb), SkBits2Float(0x43eac6ea)); // 161.132f, 469.554f
6913path.cubicTo(SkBits2Float(0x432355c3), SkBits2Float(0x43ecb0e6), SkBits2Float(0x432207ae), SkBits2Float(0x43ef1fe0), SkBits2Float(0x431e33b7), SkBits2Float(0x43f03ae2)); // 163.335f, 473.382f, 162.03f, 478.249f, 158.202f, 480.46f
6914path.lineTo(SkBits2Float(0x431c6419), SkBits2Float(0x43eea7f0)); // 156.391f, 477.312f
6915path.close();
6916path.moveTo(SkBits2Float(0x43134c08), SkBits2Float(0x43eec4fe)); // 147.297f, 477.539f
6917path.lineTo(SkBits2Float(0x43134c08), SkBits2Float(0x43eec4fe)); // 147.297f, 477.539f
6918path.lineTo(SkBits2Float(0x43134c08), SkBits2Float(0x43eec4fe)); // 147.297f, 477.539f
6919path.lineTo(SkBits2Float(0x4314e20c), SkBits2Float(0x43ee5106)); // 148.883f, 476.633f
6920path.lineTo(SkBits2Float(0x43134c08), SkBits2Float(0x43eec4fe)); // 147.297f, 477.539f
6921path.close();
6922path.moveTo(SkBits2Float(0x431673f8), SkBits2Float(0x43eddc08)); // 150.453f, 475.719f
6923path.cubicTo(SkBits2Float(0x43170e15), SkBits2Float(0x43ee620c), SkBits2Float(0x43180000), SkBits2Float(0x43eebb02), SkBits2Float(0x43191604), SkBits2Float(0x43eee000)); // 151.055f, 476.766f, 152, 477.461f, 153.086f, 477.75f
6924path.cubicTo(SkBits2Float(0x431a2c08), SkBits2Float(0x43ef04fe), SkBits2Float(0x431b5810), SkBits2Float(0x43eef4fe), SkBits2Float(0x431c6418), SkBits2Float(0x43eea7f0)); // 154.172f, 478.039f, 155.344f, 477.914f, 156.391f, 477.312f
6925path.lineTo(SkBits2Float(0x431e33f7), SkBits2Float(0x43f03ae2)); // 158.203f, 480.46f
6926path.cubicTo(SkBits2Float(0x431a620b), SkBits2Float(0x43f154de), SkBits2Float(0x4315820c), SkBits2Float(0x43f0add4), SkBits2Float(0x43134c07), SkBits2Float(0x43eec4de)); // 154.383f, 482.663f, 149.508f, 481.358f, 147.297f, 477.538f
6927path.lineTo(SkBits2Float(0x431673f8), SkBits2Float(0x43eddc08)); // 150.453f, 475.719f
6928path.close();
6929path.moveTo(SkBits2Float(0x43163a1d), SkBits2Float(0x43e95106)); // 150.227f, 466.633f
6930path.lineTo(SkBits2Float(0x43163a1d), SkBits2Float(0x43e95106)); // 150.227f, 466.633f
6931path.lineTo(SkBits2Float(0x4317220d), SkBits2Float(0x43ea19fc)); // 151.133f, 468.203f
6932path.lineTo(SkBits2Float(0x43163a1d), SkBits2Float(0x43e95106)); // 150.227f, 466.633f
6933path.close();
6934path.moveTo(SkBits2Float(0x43180c08), SkBits2Float(0x43eae3f8)); // 152.047f, 469.781f
6935path.cubicTo(SkBits2Float(0x43170000), SkBits2Float(0x43eb31ec), SkBits2Float(0x43164e14), SkBits2Float(0x43ebabe8), SkBits2Float(0x43160418), SkBits2Float(0x43ec3604)); // 151, 470.39f, 150.305f, 471.343f, 150.016f, 472.422f
6936path.cubicTo(SkBits2Float(0x4315ba1c), SkBits2Float(0x43ecc106), SkBits2Float(0x4315d810), SkBits2Float(0x43ed570a), SkBits2Float(0x43167439), SkBits2Float(0x43eddc08)); // 149.727f, 473.508f, 149.844f, 474.68f, 150.454f, 475.719f
6937path.lineTo(SkBits2Float(0x43134c49), SkBits2Float(0x43eec4fe)); // 147.298f, 477.539f
6938path.cubicTo(SkBits2Float(0x43111851), SkBits2Float(0x43ecdb02), SkBits2Float(0x43126830), SkBits2Float(0x43ea6c08), SkBits2Float(0x43163a5d), SkBits2Float(0x43e95106)); // 145.095f, 473.711f, 146.407f, 468.844f, 150.228f, 466.633f
6939path.lineTo(SkBits2Float(0x43180c08), SkBits2Float(0x43eae3f8)); // 152.047f, 469.781f
6940path.close();
6941path.moveTo(SkBits2Float(0x431dfa1d), SkBits2Float(0x43ebb000)); // 157.977f, 471.375f
6942path.cubicTo(SkBits2Float(0x431d620d), SkBits2Float(0x43eb29fc), SkBits2Float(0x431c6e15), SkBits2Float(0x43ead20c), SkBits2Float(0x431b5811), SkBits2Float(0x43eaad0e)); // 157.383f, 470.328f, 156.43f, 469.641f, 155.344f, 469.352f
6943path.cubicTo(SkBits2Float(0x431a420d), SkBits2Float(0x43ea8810), SkBits2Float(0x43191605), SkBits2Float(0x43ea970a), SkBits2Float(0x43180c09), SkBits2Float(0x43eae418)); // 154.258f, 469.063f, 153.086f, 469.18f, 152.047f, 469.782f
6944path.lineTo(SkBits2Float(0x43163a1d), SkBits2Float(0x43e95126)); // 150.227f, 466.634f
6945path.cubicTo(SkBits2Float(0x431a0c09), SkBits2Float(0x43e8372a), SkBits2Float(0x431eec08), SkBits2Float(0x43e8de34), SkBits2Float(0x4321220d), SkBits2Float(0x43eac72a)); // 154.047f, 464.431f, 158.922f, 465.736f, 161.133f, 469.556f
6946path.lineTo(SkBits2Float(0x431dfa1d), SkBits2Float(0x43ebb000)); // 157.977f, 471.375f
6947path.close();
6948testSimplify(reporter, path, filename);
6949}
6950
6951static void joel_8(skiatest::Reporter* reporter, const char* filename) {
6952 SkPath path;
6953path.moveTo(SkBits2Float(0x42d97520), SkBits2Float(0x410ac429)); // 108.729f, 8.67289f
6954path.cubicTo(SkBits2Float(0x42d97520), SkBits2Float(0x410ac429), SkBits2Float(0x42e9a9ce), SkBits2Float(0x41834e87), SkBits2Float(0x42e99c8c), SkBits2Float(0x41c5c960)); // 108.729f, 8.67289f, 116.832f, 16.4133f, 116.806f, 24.7233f
6955path.cubicTo(SkBits2Float(0x42e98f49), SkBits2Float(0x4204221c), SkBits2Float(0x42d97520), SkBits2Float(0x4223825f), SkBits2Float(0x42d97520), SkBits2Float(0x4223825f)); // 116.78f, 33.0333f, 108.729f, 40.8773f, 108.729f, 40.8773f
6956path.cubicTo(SkBits2Float(0x42d97520), SkBits2Float(0x4223825f), SkBits2Float(0x42dbbc54), SkBits2Float(0x42099f18), SkBits2Float(0x42d1cb74), SkBits2Float(0x41f77dc0)); // 108.729f, 40.8773f, 109.868f, 34.4054f, 104.897f, 30.9364f
6957path.cubicTo(SkBits2Float(0x42c7da94), SkBits2Float(0x41dbbd4f), SkBits2Float(0x42b1b1a1), SkBits2Float(0x41d802fb), SkBits2Float(0x42b1b1a1), SkBits2Float(0x41d802fb)); // 99.9269f, 27.4674f, 88.8469f, 27.0015f, 88.8469f, 27.0015f
6958path.cubicTo(SkBits2Float(0x42a75637), SkBits2Float(0x41d6909f), SkBits2Float(0x4296c543), SkBits2Float(0x41f1b139), SkBits2Float(0x4296c543), SkBits2Float(0x41f1b139)); // 83.6684f, 26.8206f, 75.3853f, 30.2115f, 75.3853f, 30.2115f
6959path.lineTo(SkBits2Float(0x42824475), SkBits2Float(0x41c69d70)); // 65.1337f, 24.8269f
6960path.lineTo(SkBits2Float(0x4296c543), SkBits2Float(0x419b89a8)); // 75.3853f, 19.4422f
6961path.cubicTo(SkBits2Float(0x4296c543), SkBits2Float(0x419b89a8), SkBits2Float(0x42a6b798), SkBits2Float(0x41b89815), SkBits2Float(0x42b1b1a1), SkBits2Float(0x41b95c48)); // 75.3853f, 19.4422f, 83.3586f, 23.0743f, 88.8469f, 23.1701f
6962path.cubicTo(SkBits2Float(0x42b1b1a1), SkBits2Float(0x41b95c48), SkBits2Float(0x42c80258), SkBits2Float(0x41b03f7a), SkBits2Float(0x42d1cb74), SkBits2Float(0x419340ee)); // 88.8469f, 23.1701f, 100.005f, 22.031f, 104.897f, 18.4067f
6963path.cubicTo(SkBits2Float(0x42db9490), SkBits2Float(0x416c84c2), SkBits2Float(0x42d97520), SkBits2Float(0x410ac42a), SkBits2Float(0x42d97520), SkBits2Float(0x410ac42a)); // 109.79f, 14.7824f, 108.729f, 8.67289f, 108.729f, 8.67289f
6964path.lineTo(SkBits2Float(0x42d97520), SkBits2Float(0x410ac429)); // 108.729f, 8.67289f
6965path.close();
6966testSimplify(reporter, path, filename);
6967}
6968
6969static void joel_9(skiatest::Reporter* reporter, const char* filename) {
6970#if DEBUG_UNDER_DEVELOPMENT
6971// fails with image mismatch
6972 SkPath path;
6973path.moveTo(SkBits2Float(0x4310dbe7), SkBits2Float(0x438e9604)); // 144.859f, 285.172f
6974path.lineTo(SkBits2Float(0x4310dbe7), SkBits2Float(0x438e9604)); // 144.859f, 285.172f
6975path.lineTo(SkBits2Float(0x4310dbe7), SkBits2Float(0x438e9604)); // 144.859f, 285.172f
6976path.lineTo(SkBits2Float(0x430f21ca), SkBits2Float(0x438e4efa)); // 143.132f, 284.617f
6977path.lineTo(SkBits2Float(0x4310dbe7), SkBits2Float(0x438e9604)); // 144.859f, 285.172f
6978path.close();
6979path.moveTo(SkBits2Float(0x4307ec08), SkBits2Float(0x438f6c08)); // 135.922f, 286.844f
6980path.lineTo(SkBits2Float(0x4307ec08), SkBits2Float(0x438f6c08)); // 135.922f, 286.844f
6981path.lineTo(SkBits2Float(0x4307ec08), SkBits2Float(0x438f6c08)); // 135.922f, 286.844f
6982path.lineTo(SkBits2Float(0x43075df4), SkBits2Float(0x43904916)); // 135.367f, 288.571f
6983path.lineTo(SkBits2Float(0x4307ec08), SkBits2Float(0x438f6c08)); // 135.922f, 286.844f
6984path.close();
6985path.moveTo(SkBits2Float(0x4307ec08), SkBits2Float(0x438f6c08)); // 135.922f, 286.844f
6986path.cubicTo(SkBits2Float(0x430911eb), SkBits2Float(0x438f9c08), SkBits2Float(0x430a3df4), SkBits2Float(0x438f8b02), SkBits2Float(0x430b3df4), SkBits2Float(0x438f49fc)); // 137.07f, 287.219f, 138.242f, 287.086f, 139.242f, 286.578f
6987path.cubicTo(SkBits2Float(0x430c3be8), SkBits2Float(0x438f09fc), SkBits2Float(0x430d07f0), SkBits2Float(0x438e99fc), SkBits2Float(0x430d67f0), SkBits2Float(0x438e070a)); // 140.234f, 286.078f, 141.031f, 285.203f, 141.406f, 284.055f
6988path.lineTo(SkBits2Float(0x4310dbe8), SkBits2Float(0x438e9604)); // 144.859f, 285.172f
6989path.cubicTo(SkBits2Float(0x430f7df4), SkBits2Float(0x4390b000), SkBits2Float(0x430afdf4), SkBits2Float(0x4391d3f8), SkBits2Float(0x4306cc09), SkBits2Float(0x43912604)); // 143.492f, 289.375f, 138.992f, 291.656f, 134.797f, 290.297f
6990path.lineTo(SkBits2Float(0x4307ec08), SkBits2Float(0x438f6c08)); // 135.922f, 286.844f
6991path.close();
6992path.moveTo(SkBits2Float(0x4301ae14), SkBits2Float(0x438c1efa)); // 129.68f, 280.242f
6993path.lineTo(SkBits2Float(0x4301ae14), SkBits2Float(0x438c1efa)); // 129.68f, 280.242f
6994path.lineTo(SkBits2Float(0x4301ae14), SkBits2Float(0x438c1efa)); // 129.68f, 280.242f
6995path.lineTo(SkBits2Float(0x43036831), SkBits2Float(0x438c66ea)); // 131.407f, 280.804f
6996path.lineTo(SkBits2Float(0x4301ae14), SkBits2Float(0x438c1efa)); // 129.68f, 280.242f
6997path.close();
6998path.moveTo(SkBits2Float(0x4305220c), SkBits2Float(0x438caefa)); // 133.133f, 281.367f
6999path.cubicTo(SkBits2Float(0x4304c20c), SkBits2Float(0x438d4106), SkBits2Float(0x4304e20c), SkBits2Float(0x438dd7f0), SkBits2Float(0x43056418), SkBits2Float(0x438e56ea)); // 132.758f, 282.508f, 132.883f, 283.687f, 133.391f, 284.679f
7000path.cubicTo(SkBits2Float(0x4305e831), SkBits2Float(0x438ed6ea), SkBits2Float(0x4306c624), SkBits2Float(0x438f3be8), SkBits2Float(0x4307ec08), SkBits2Float(0x438f6be8)); // 133.907f, 285.679f, 134.774f, 286.468f, 135.922f, 286.843f
7001path.lineTo(SkBits2Float(0x4306cc08), SkBits2Float(0x439125e4)); // 134.797f, 290.296f
7002path.cubicTo(SkBits2Float(0x43029a1c), SkBits2Float(0x439076ea), SkBits2Float(0x43005021), SkBits2Float(0x438e37f0), SkBits2Float(0x4301ae14), SkBits2Float(0x438c1eda)); // 130.602f, 288.929f, 128.313f, 284.437f, 129.68f, 280.241f
7003path.lineTo(SkBits2Float(0x4305220c), SkBits2Float(0x438caefa)); // 133.133f, 281.367f
7004path.close();
7005path.moveTo(SkBits2Float(0x430bbdf4), SkBits2Float(0x43898efa)); // 139.742f, 275.117f
7006path.lineTo(SkBits2Float(0x430bbdf4), SkBits2Float(0x43898efa)); // 139.742f, 275.117f
7007path.lineTo(SkBits2Float(0x430b2e15), SkBits2Float(0x438a6c08)); // 139.18f, 276.844f
7008path.lineTo(SkBits2Float(0x430bbdf4), SkBits2Float(0x43898efa)); // 139.742f, 275.117f
7009path.close();
7010path.moveTo(SkBits2Float(0x430a9be7), SkBits2Float(0x438b48f6)); // 138.609f, 278.57f
7011path.cubicTo(SkBits2Float(0x43097604), SkBits2Float(0x438b19fc), SkBits2Float(0x43084c08), SkBits2Float(0x438b29fc), SkBits2Float(0x43074c08), SkBits2Float(0x438b6b02)); // 137.461f, 278.203f, 136.297f, 278.328f, 135.297f, 278.836f
7012path.cubicTo(SkBits2Float(0x43064c08), SkBits2Float(0x438bac08), SkBits2Float(0x4305820c), SkBits2Float(0x438c1c08), SkBits2Float(0x4305220c), SkBits2Float(0x438caefa)); // 134.297f, 279.344f, 133.508f, 280.219f, 133.133f, 281.367f
7013path.lineTo(SkBits2Float(0x4301ae14), SkBits2Float(0x438c1efa)); // 129.68f, 280.242f
7014path.cubicTo(SkBits2Float(0x43030c08), SkBits2Float(0x438a04fe), SkBits2Float(0x430789fb), SkBits2Float(0x4388e106), SkBits2Float(0x430bbdf3), SkBits2Float(0x43898efa)); // 131.047f, 276.039f, 135.539f, 273.758f, 139.742f, 275.117f
7015path.lineTo(SkBits2Float(0x430a9be7), SkBits2Float(0x438b48f6)); // 138.609f, 278.57f
7016path.close();
7017path.moveTo(SkBits2Float(0x430d67f0), SkBits2Float(0x438e070a)); // 141.406f, 284.055f
7018path.cubicTo(SkBits2Float(0x430dc5e4), SkBits2Float(0x438d7418), SkBits2Float(0x430da5e4), SkBits2Float(0x438cde14), SkBits2Float(0x430d25e4), SkBits2Float(0x438c5e14)); // 141.773f, 282.907f, 141.648f, 281.735f, 141.148f, 280.735f
7019path.cubicTo(SkBits2Float(0x430ca001), SkBits2Float(0x438bde14), SkBits2Float(0x430bc1cb), SkBits2Float(0x438b7916), SkBits2Float(0x430a9be8), SkBits2Float(0x438b4916)); // 140.625f, 279.735f, 139.757f, 278.946f, 138.609f, 278.571f
7020path.lineTo(SkBits2Float(0x430bbdf4), SkBits2Float(0x43898f1a)); // 139.742f, 275.118f
7021path.cubicTo(SkBits2Float(0x430fefe0), SkBits2Float(0x438a3f1a), SkBits2Float(0x43123811), SkBits2Float(0x438c7d0e), SkBits2Float(0x4310dbe8), SkBits2Float(0x438e9624)); // 143.937f, 276.493f, 146.219f, 280.977f, 144.859f, 285.173f
7022path.lineTo(SkBits2Float(0x430d67f0), SkBits2Float(0x438e070a)); // 141.406f, 284.055f
7023path.close();
7024testSimplify(reporter, path, filename);
7025#endif
7026}
7027
7028static void joel_10(skiatest::Reporter* reporter, const char* filename) {
7029#if DEBUG_UNDER_DEVELOPMENT
7030// fails with image mismatch
7031 SkPath path;
7032path.moveTo(SkBits2Float(0x440fc979), SkBits2Float(0x43d88000)); // 575.148f, 433
7033path.lineTo(SkBits2Float(0x440fc979), SkBits2Float(0x43d88000)); // 575.148f, 433
7034path.lineTo(SkBits2Float(0x440fc979), SkBits2Float(0x43d88000)); // 575.148f, 433
7035path.lineTo(SkBits2Float(0x44103800), SkBits2Float(0x43d8c7f0)); // 576.875f, 433.562f
7036path.lineTo(SkBits2Float(0x440fc979), SkBits2Float(0x43d88000)); // 575.148f, 433
7037path.close();
7038path.moveTo(SkBits2Float(0x44124d81), SkBits2Float(0x43d5f000)); // 585.211f, 427.875f
7039path.lineTo(SkBits2Float(0x44124d81), SkBits2Float(0x43d5f000)); // 585.211f, 427.875f
7040path.lineTo(SkBits2Float(0x44122906), SkBits2Float(0x43d6cdf4)); // 584.641f, 429.609f
7041path.lineTo(SkBits2Float(0x44124d81), SkBits2Float(0x43d5f000)); // 585.211f, 427.875f
7042path.close();
7043path.moveTo(SkBits2Float(0x44120581), SkBits2Float(0x43d7ab02)); // 584.086f, 431.336f
7044path.cubicTo(SkBits2Float(0x4411bc08), SkBits2Float(0x43d77b02), SkBits2Float(0x44117083), SkBits2Float(0x43d78b02), SkBits2Float(0x44113106), SkBits2Float(0x43d7cc08)); // 582.938f, 430.961f, 581.758f, 431.086f, 580.766f, 431.594f
7045path.cubicTo(SkBits2Float(0x4410f189), SkBits2Float(0x43d80d0e), SkBits2Float(0x4410be87), SkBits2Float(0x43d87d0e), SkBits2Float(0x4410a687), SkBits2Float(0x43d91000)); // 579.774f, 432.102f, 578.977f, 432.977f, 578.602f, 434.125f
7046path.lineTo(SkBits2Float(0x440fc979), SkBits2Float(0x43d88000)); // 575.148f, 433
7047path.cubicTo(SkBits2Float(0x441020f6), SkBits2Float(0x43d66604), SkBits2Float(0x441140f6), SkBits2Float(0x43d5420c), SkBits2Float(0x44124d71), SkBits2Float(0x43d5f000)); // 576.515f, 428.797f, 581.015f, 426.516f, 585.21f, 427.875f
7048path.lineTo(SkBits2Float(0x44120581), SkBits2Float(0x43d7ab02)); // 584.086f, 431.336f
7049path.close();
7050path.moveTo(SkBits2Float(0x441394fe), SkBits2Float(0x43daf810)); // 590.328f, 437.938f
7051path.lineTo(SkBits2Float(0x441394fe), SkBits2Float(0x43daf810)); // 590.328f, 437.938f
7052path.lineTo(SkBits2Float(0x441394fe), SkBits2Float(0x43daf810)); // 590.328f, 437.938f
7053path.lineTo(SkBits2Float(0x44132677), SkBits2Float(0x43dab020)); // 588.601f, 437.376f
7054path.lineTo(SkBits2Float(0x441394fe), SkBits2Float(0x43daf810)); // 590.328f, 437.938f
7055path.close();
7056path.moveTo(SkBits2Float(0x4412b800), SkBits2Float(0x43da67f0)); // 586.875f, 436.812f
7057path.cubicTo(SkBits2Float(0x4412d000), SkBits2Float(0x43d9d4fe), SkBits2Float(0x4412c800), SkBits2Float(0x43d94000), SkBits2Float(0x4412a77d), SkBits2Float(0x43d8befa)); // 587.25f, 435.664f, 587.125f, 434.5f, 586.617f, 433.492f
7058path.cubicTo(SkBits2Float(0x44128677), SkBits2Float(0x43d84000), SkBits2Float(0x44124efa), SkBits2Float(0x43d7d9fc), SkBits2Float(0x44120581), SkBits2Float(0x43d7ab02)); // 586.101f, 432.5f, 585.234f, 431.703f, 584.086f, 431.336f
7059path.lineTo(SkBits2Float(0x44124d81), SkBits2Float(0x43d5f000)); // 585.211f, 427.875f
7060path.cubicTo(SkBits2Float(0x441359fc), SkBits2Float(0x43d69efa), SkBits2Float(0x4413ec7b), SkBits2Float(0x43d8ddf4), SkBits2Float(0x441394fe), SkBits2Float(0x43daf7f0)); // 589.406f, 429.242f, 591.695f, 433.734f, 590.328f, 437.937f
7061path.lineTo(SkBits2Float(0x4412b800), SkBits2Float(0x43da67f0)); // 586.875f, 436.812f
7062path.close();
7063path.moveTo(SkBits2Float(0x44111106), SkBits2Float(0x43dd870a)); // 580.266f, 443.055f
7064path.lineTo(SkBits2Float(0x44111106), SkBits2Float(0x43dd870a)); // 580.266f, 443.055f
7065path.lineTo(SkBits2Float(0x44111106), SkBits2Float(0x43dd870a)); // 580.266f, 443.055f
7066path.lineTo(SkBits2Float(0x441134fe), SkBits2Float(0x43dca9fc)); // 580.828f, 441.328f
7067path.lineTo(SkBits2Float(0x44111106), SkBits2Float(0x43dd870a)); // 580.266f, 443.055f
7068path.close();
7069path.moveTo(SkBits2Float(0x44115979), SkBits2Float(0x43dbcd0e)); // 581.398f, 439.602f
7070path.cubicTo(SkBits2Float(0x4411a27f), SkBits2Float(0x43dbfc08), SkBits2Float(0x4411ed71), SkBits2Float(0x43dbed0e), SkBits2Float(0x44122d71), SkBits2Float(0x43dbac08)); // 582.539f, 439.969f, 583.71f, 439.852f, 584.71f, 439.344f
7071path.cubicTo(SkBits2Float(0x44126cee), SkBits2Float(0x43db6b02), SkBits2Float(0x44129ff0), SkBits2Float(0x43dafb02), SkBits2Float(0x4412b7f0), SkBits2Float(0x43da6810)); // 585.702f, 438.836f, 586.499f, 437.961f, 586.874f, 436.813f
7072path.lineTo(SkBits2Float(0x441394ee), SkBits2Float(0x43daf810)); // 590.327f, 437.938f
7073path.cubicTo(SkBits2Float(0x44133cee), SkBits2Float(0x43dd1106), SkBits2Float(0x44121df4), SkBits2Float(0x43de3604), SkBits2Float(0x441110f6), SkBits2Float(0x43dd870a)); // 588.952f, 442.133f, 584.468f, 444.422f, 580.265f, 443.055f
7074path.lineTo(SkBits2Float(0x44115979), SkBits2Float(0x43dbcd0e)); // 581.398f, 439.602f
7075path.close();
7076path.moveTo(SkBits2Float(0x4410a687), SkBits2Float(0x43d91000)); // 578.602f, 434.125f
7077path.cubicTo(SkBits2Float(0x44108f0a), SkBits2Float(0x43d9a2f2), SkBits2Float(0x44109687), SkBits2Float(0x43da37f0), SkBits2Float(0x4410b70a), SkBits2Float(0x43dab8f6)); // 578.235f, 435.273f, 578.352f, 436.437f, 578.86f, 437.445f
7078path.cubicTo(SkBits2Float(0x4410d78d), SkBits2Float(0x43db37f0), SkBits2Float(0x44111010), SkBits2Float(0x43db9cee), SkBits2Float(0x44115989), SkBits2Float(0x43dbccee)); // 579.368f, 438.437f, 580.251f, 439.226f, 581.399f, 439.601f
7079path.lineTo(SkBits2Float(0x44111106), SkBits2Float(0x43dd86ea)); // 580.266f, 443.054f
7080path.cubicTo(SkBits2Float(0x4410048b), SkBits2Float(0x43dcd7f0), SkBits2Float(0x440f720c), SkBits2Float(0x43da99dc), SkBits2Float(0x440fc989), SkBits2Float(0x43d87fe0)); // 576.071f, 441.687f, 573.782f, 437.202f, 575.149f, 432.999f
7081path.lineTo(SkBits2Float(0x4410a687), SkBits2Float(0x43d91000)); // 578.602f, 434.125f
7082path.close();
7083testSimplify(reporter, path, filename);
7084#endif
7085}
7086
7087static void joel_11(skiatest::Reporter* reporter, const char* filename) {
7088#if DEBUG_UNDER_DEVELOPMENT
7089// fails with image mismatch
7090 SkPath path;
7091path.moveTo(SkBits2Float(0x43c9d000), SkBits2Float(0x4411977d)); // 403.625f, 582.367f
7092path.lineTo(SkBits2Float(0x43c9d000), SkBits2Float(0x4411977d)); // 403.625f, 582.367f
7093path.lineTo(SkBits2Float(0x43c9d000), SkBits2Float(0x4411977d)); // 403.625f, 582.367f
7094path.lineTo(SkBits2Float(0x43ca0106), SkBits2Float(0x441208f6)); // 404.008f, 584.14f
7095path.lineTo(SkBits2Float(0x43c9d000), SkBits2Float(0x4411977d)); // 403.625f, 582.367f
7096path.close();
7097path.moveTo(SkBits2Float(0x43ce8d0e), SkBits2Float(0x44132106)); // 413.102f, 588.516f
7098path.lineTo(SkBits2Float(0x43ce8d0e), SkBits2Float(0x44132106)); // 413.102f, 588.516f
7099path.lineTo(SkBits2Float(0x43ce8d0e), SkBits2Float(0x44132106)); // 413.102f, 588.516f
7100path.lineTo(SkBits2Float(0x43cda916), SkBits2Float(0x44133989)); // 411.321f, 588.899f
7101path.lineTo(SkBits2Float(0x43ce8d0e), SkBits2Float(0x44132106)); // 413.102f, 588.516f
7102path.close();
7103path.moveTo(SkBits2Float(0x43ccc4fe), SkBits2Float(0x44135179)); // 409.539f, 589.273f
7104path.cubicTo(SkBits2Float(0x43cca604), SkBits2Float(0x44130571), SkBits2Float(0x43cc4c08), SkBits2Float(0x4412c8f6), SkBits2Float(0x43cbd4fe), SkBits2Float(0x4412a179)); // 409.297f, 588.085f, 408.594f, 587.14f, 407.664f, 586.523f
7105path.cubicTo(SkBits2Float(0x43cb5c08), SkBits2Float(0x44127a7f), SkBits2Float(0x43cac7f0), SkBits2Float(0x44126af2), SkBits2Float(0x43ca3106), SkBits2Float(0x44127af2)); // 406.719f, 585.914f, 405.562f, 585.671f, 404.383f, 585.921f
7106path.lineTo(SkBits2Float(0x43c9d000), SkBits2Float(0x4411976d)); // 403.625f, 582.366f
7107path.cubicTo(SkBits2Float(0x43cbf9fc), SkBits2Float(0x44115cee), SkBits2Float(0x43ce170a), SkBits2Float(0x44120cee), SkBits2Float(0x43ce8d0e), SkBits2Float(0x441320e6)); // 407.953f, 581.452f, 412.18f, 584.202f, 413.102f, 588.514f
7108path.lineTo(SkBits2Float(0x43ccc4fe), SkBits2Float(0x44135179)); // 409.539f, 589.273f
7109path.close();
7110path.moveTo(SkBits2Float(0x43cb78f6), SkBits2Float(0x44157efa)); // 406.945f, 597.984f
7111path.lineTo(SkBits2Float(0x43cb78f6), SkBits2Float(0x44157f7d)); // 406.945f, 597.992f
7112path.lineTo(SkBits2Float(0x43cb78f6), SkBits2Float(0x44157efa)); // 406.945f, 597.984f
7113path.lineTo(SkBits2Float(0x43cb49fc), SkBits2Float(0x44150d81)); // 406.578f, 596.211f
7114path.lineTo(SkBits2Float(0x43cb78f6), SkBits2Float(0x44157efa)); // 406.945f, 597.984f
7115path.close();
7116path.moveTo(SkBits2Float(0x43cb18f6), SkBits2Float(0x44149b85)); // 406.195f, 594.43f
7117path.cubicTo(SkBits2Float(0x43cbb000), SkBits2Float(0x44148b85), SkBits2Float(0x43cc28f6), SkBits2Float(0x44145f0a), SkBits2Float(0x43cc76ea), SkBits2Float(0x44142302)); // 407.375f, 594.18f, 408.32f, 593.485f, 408.929f, 592.547f
7118path.cubicTo(SkBits2Float(0x43ccc4de), SkBits2Float(0x4413e687), SkBits2Float(0x43cce4de), SkBits2Float(0x44139cfe), SkBits2Float(0x43ccc4de), SkBits2Float(0x44135189)); // 409.538f, 591.602f, 409.788f, 590.453f, 409.538f, 589.274f
7119path.lineTo(SkBits2Float(0x43ce8cce), SkBits2Float(0x44132106)); // 413.1f, 588.516f
7120path.cubicTo(SkBits2Float(0x43cf00c6), SkBits2Float(0x44143581), SkBits2Float(0x43cda2d2), SkBits2Float(0x44154408), SkBits2Float(0x43cb78d6), SkBits2Float(0x44157f0a)); // 414.006f, 592.836f, 411.272f, 597.063f, 406.944f, 597.985f
7121path.lineTo(SkBits2Float(0x43cb18f6), SkBits2Float(0x44149b85)); // 406.195f, 594.43f
7122path.close();
7123path.moveTo(SkBits2Float(0x43c883f8), SkBits2Float(0x4413c4fe)); // 401.031f, 591.078f
7124path.lineTo(SkBits2Float(0x43c883f8), SkBits2Float(0x4413c4fe)); // 401.031f, 591.078f
7125path.lineTo(SkBits2Float(0x43c883f8), SkBits2Float(0x4413c4fe)); // 401.031f, 591.078f
7126path.lineTo(SkBits2Float(0x43c7a106), SkBits2Float(0x4413dd81)); // 399.258f, 591.461f
7127path.lineTo(SkBits2Float(0x43c883f8), SkBits2Float(0x4413c4fe)); // 401.031f, 591.078f
7128path.close();
7129path.moveTo(SkBits2Float(0x43c883f8), SkBits2Float(0x4413c4fe)); // 401.031f, 591.078f
7130path.cubicTo(SkBits2Float(0x43c8a4fe), SkBits2Float(0x44141083), SkBits2Float(0x43c8fdf4), SkBits2Float(0x44144d81), SkBits2Float(0x43c974fe), SkBits2Float(0x4414747b)); // 401.289f, 592.258f, 401.984f, 593.211f, 402.914f, 593.82f
7131path.cubicTo(SkBits2Float(0x43c9edf4), SkBits2Float(0x44149b75), SkBits2Float(0x43ca820c), SkBits2Float(0x4414ab75), SkBits2Float(0x43cb18f6), SkBits2Float(0x44149b75)); // 403.859f, 594.429f, 405.016f, 594.679f, 406.195f, 594.429f
7132path.lineTo(SkBits2Float(0x43cb78f6), SkBits2Float(0x44157efa)); // 406.945f, 597.984f
7133path.cubicTo(SkBits2Float(0x43c95000), SkBits2Float(0x4415b979), SkBits2Float(0x43c732f2), SkBits2Float(0x441509fc), SkBits2Float(0x43c6bcee), SkBits2Float(0x4413f581)); // 402.625f, 598.898f, 398.398f, 596.156f, 397.476f, 591.836f
7134path.lineTo(SkBits2Float(0x43c883f8), SkBits2Float(0x4413c4fe)); // 401.031f, 591.078f
7135path.close();
7136path.moveTo(SkBits2Float(0x43ca3106), SkBits2Float(0x44127b02)); // 404.383f, 585.922f
7137path.cubicTo(SkBits2Float(0x43c999fc), SkBits2Float(0x44128b02), SkBits2Float(0x43c92000), SkBits2Float(0x4412b77d), SkBits2Float(0x43c8d20c), SkBits2Float(0x4412f408)); // 403.203f, 586.172f, 402.25f, 586.867f, 401.641f, 587.813f
7138path.cubicTo(SkBits2Float(0x43c88418), SkBits2Float(0x44133010), SkBits2Float(0x43c86418), SkBits2Float(0x44137989), SkBits2Float(0x43c88418), SkBits2Float(0x4413c50e)); // 401.032f, 588.751f, 400.782f, 589.899f, 401.032f, 591.079f
7139path.lineTo(SkBits2Float(0x43c6bd0e), SkBits2Float(0x4413f591)); // 397.477f, 591.837f
7140path.cubicTo(SkBits2Float(0x43c64810), SkBits2Float(0x4412e116), SkBits2Float(0x43c7a70a), SkBits2Float(0x4411d28f), SkBits2Float(0x43c9d000), SkBits2Float(0x4411978d)); // 396.563f, 587.517f, 399.305f, 583.29f, 403.625f, 582.368f
7141path.lineTo(SkBits2Float(0x43ca3106), SkBits2Float(0x44127b02)); // 404.383f, 585.922f
7142path.close();
7143testSimplify(reporter, path, filename);
7144#endif
7145}
7146
7147static void make_joel_12(SkPath& path) {
7148path.moveTo(SkBits2Float(0x4324e9fc), SkBits2Float(0x437211ec)); // 164.914f, 242.07f
7149path.lineTo(SkBits2Float(0x4324e9fc), SkBits2Float(0x437211ec)); // 164.914f, 242.07f
7150path.lineTo(SkBits2Float(0x4324e9fc), SkBits2Float(0x437211ec)); // 164.914f, 242.07f
7151path.lineTo(SkBits2Float(0x43235810), SkBits2Float(0x437129fc)); // 163.344f, 241.164f
7152path.lineTo(SkBits2Float(0x4324e9fc), SkBits2Float(0x437211ec)); // 164.914f, 242.07f
7153path.close();
7154path.moveTo(SkBits2Float(0x431a020c), SkBits2Float(0x4374fdf4)); // 154.008f, 244.992f
7155path.lineTo(SkBits2Float(0x431a020c), SkBits2Float(0x4374fdf4)); // 154.008f, 244.992f
7156path.lineTo(SkBits2Float(0x431a020c), SkBits2Float(0x4374fdf4)); // 154.008f, 244.992f
7157path.lineTo(SkBits2Float(0x431aec08), SkBits2Float(0x437369fc)); // 154.922f, 243.414f
7158path.lineTo(SkBits2Float(0x431a020c), SkBits2Float(0x4374fdf4)); // 154.008f, 244.992f
7159path.close();
7160path.moveTo(SkBits2Float(0x431bd3f8), SkBits2Float(0x4371d810)); // 155.828f, 241.844f
7161path.cubicTo(SkBits2Float(0x431ce000), SkBits2Float(0x4372722d), SkBits2Float(0x431e0e15), SkBits2Float(0x43729020), SkBits2Float(0x431f2000), SkBits2Float(0x43724831)); // 156.875f, 242.446f, 158.055f, 242.563f, 159.125f, 242.282f
7162path.cubicTo(SkBits2Float(0x43203604), SkBits2Float(0x4371fe35), SkBits2Float(0x43212c08), SkBits2Float(0x43714a3d), SkBits2Float(0x4321c5e3), SkBits2Float(0x43704041)); // 160.211f, 241.993f, 161.172f, 241.29f, 161.773f, 240.251f
7163path.lineTo(SkBits2Float(0x4324e9fc), SkBits2Float(0x4372122d)); // 164.914f, 242.071f
7164path.cubicTo(SkBits2Float(0x4322b3f8), SkBits2Float(0x4375e419), SkBits2Float(0x431dd810), SkBits2Float(0x4377322d), SkBits2Float(0x431a020c), SkBits2Float(0x4374fe35)); // 162.703f, 245.891f, 157.844f, 247.196f, 154.008f, 244.993f
7165path.lineTo(SkBits2Float(0x431bd3f8), SkBits2Float(0x4371d810)); // 155.828f, 241.844f
7166path.close();
7167path.moveTo(SkBits2Float(0x43171810), SkBits2Float(0x436a1604)); // 151.094f, 234.086f
7168path.lineTo(SkBits2Float(0x43171810), SkBits2Float(0x436a1604)); // 151.094f, 234.086f
7169path.lineTo(SkBits2Float(0x43171810), SkBits2Float(0x436a1604)); // 151.094f, 234.086f
7170path.lineTo(SkBits2Float(0x4318a9fc), SkBits2Float(0x436afdf4)); // 152.664f, 234.992f
7171path.lineTo(SkBits2Float(0x43171810), SkBits2Float(0x436a1604)); // 151.094f, 234.086f
7172path.close();
7173path.moveTo(SkBits2Float(0x431a4000), SkBits2Float(0x436be7f0)); // 154.25f, 235.906f
7174path.cubicTo(SkBits2Float(0x4319a20c), SkBits2Float(0x436cf3f8), SkBits2Float(0x431985e3), SkBits2Float(0x436e1df4), SkBits2Float(0x4319ce14), SkBits2Float(0x436f33f8)); // 153.633f, 236.953f, 153.523f, 238.117f, 153.805f, 239.203f
7175path.cubicTo(SkBits2Float(0x431a1a1c), SkBits2Float(0x437047f0), SkBits2Float(0x431ac831), SkBits2Float(0x43713df4), SkBits2Float(0x431bd3f7), SkBits2Float(0x4371d811)); // 154.102f, 240.281f, 154.782f, 241.242f, 155.828f, 241.844f
7176path.lineTo(SkBits2Float(0x431a020b), SkBits2Float(0x4374fdf4)); // 154.008f, 244.992f
7177path.cubicTo(SkBits2Float(0x4316322c), SkBits2Float(0x4372c5e4), SkBits2Float(0x4314e417), SkBits2Float(0x436de9fc), SkBits2Float(0x4317180f), SkBits2Float(0x436a1604)); // 150.196f, 242.773f, 148.891f, 237.914f, 151.094f, 234.086f
7178path.lineTo(SkBits2Float(0x431a4000), SkBits2Float(0x436be7f0)); // 154.25f, 235.906f
7179path.close();
7180path.moveTo(SkBits2Float(0x43220000), SkBits2Float(0x436729fc)); // 162, 231.164f
7181path.lineTo(SkBits2Float(0x43220000), SkBits2Float(0x436729fc)); // 162, 231.164f
7182path.lineTo(SkBits2Float(0x43220000), SkBits2Float(0x436729fc)); // 162, 231.164f
7183path.lineTo(SkBits2Float(0x43211810), SkBits2Float(0x4368bbe8)); // 161.094f, 232.734f
7184path.lineTo(SkBits2Float(0x43220000), SkBits2Float(0x436729fc)); // 162, 231.164f
7185path.close();
7186path.moveTo(SkBits2Float(0x43202e14), SkBits2Float(0x436a4fdf)); // 160.18f, 234.312f
7187path.cubicTo(SkBits2Float(0x431f2418), SkBits2Float(0x4369b5c2), SkBits2Float(0x431df810), SkBits2Float(0x436995c2), SkBits2Float(0x431ce20c), SkBits2Float(0x4369dfbe)); // 159.141f, 233.71f, 157.969f, 233.585f, 156.883f, 233.874f
7188path.cubicTo(SkBits2Float(0x431bcc08), SkBits2Float(0x436a2bc6), SkBits2Float(0x431ad810), SkBits2Float(0x436adba5), SkBits2Float(0x431a4000), SkBits2Float(0x436be7ae)); // 155.797f, 234.171f, 154.844f, 234.858f, 154.25f, 235.905f
7189path.lineTo(SkBits2Float(0x43171810), SkBits2Float(0x436a15c2)); // 151.094f, 234.085f
7190path.cubicTo(SkBits2Float(0x43194e14), SkBits2Float(0x436643d6), SkBits2Float(0x431e2c08), SkBits2Float(0x4364f3b6), SkBits2Float(0x43220000), SkBits2Float(0x436729ba)); // 153.305f, 230.265f, 158.172f, 228.952f, 162, 231.163f
7191path.lineTo(SkBits2Float(0x43202e14), SkBits2Float(0x436a4fdf)); // 160.18f, 234.312f
7192path.close();
7193path.moveTo(SkBits2Float(0x4321c5e3), SkBits2Float(0x43704000)); // 161.773f, 240.25f
7194path.cubicTo(SkBits2Float(0x43226000), SkBits2Float(0x436f3604), SkBits2Float(0x43228000), SkBits2Float(0x436e09fc), SkBits2Float(0x43223604), SkBits2Float(0x436cf3f8)); // 162.375f, 239.211f, 162.5f, 238.039f, 162.211f, 236.953f
7195path.cubicTo(SkBits2Float(0x4321ec08), SkBits2Float(0x436be000), SkBits2Float(0x43213a1d), SkBits2Float(0x436ae9fc), SkBits2Float(0x43202e14), SkBits2Float(0x436a4fdf)); // 161.922f, 235.875f, 161.227f, 234.914f, 160.18f, 234.312f
7196path.lineTo(SkBits2Float(0x43220000), SkBits2Float(0x436729fc)); // 162, 231.164f
7197path.cubicTo(SkBits2Float(0x4325d1ec), SkBits2Float(0x43696000), SkBits2Float(0x4327220c), SkBits2Float(0x436e4000), SkBits2Float(0x4324e9fc), SkBits2Float(0x437211ec)); // 165.82f, 233.375f, 167.133f, 238.25f, 164.914f, 242.07f
7198path.lineTo(SkBits2Float(0x4321c5e3), SkBits2Float(0x43704000)); // 161.773f, 240.25f
7199path.close();
7200}
7201
7202static void joel_12(skiatest::Reporter* reporter, const char* filename) {
7203 SkPath path;
7204 make_joel_12(path);
7205 testSimplify(reporter, path, filename);
7206}
7207
7208static void joel_12x(skiatest::Reporter* reporter, const char* filename) {
7209 SkPath path;
7210 path.setFillType(SkPathFillType::kEvenOdd);
7211 make_joel_12(path);
7212 testSimplify(reporter, path, filename);
7213}
7214
7215static void make_joel_13(SkPath& path) {
7216path.moveTo(SkBits2Float(0x43b4126f), SkBits2Float(0x43c058f6)); // 360.144f, 384.695f
7217path.cubicTo(SkBits2Float(0x43bd7c6b), SkBits2Float(0x43c05b02), SkBits2Float(0x43c51d71), SkBits2Float(0x43b8e8f6), SkBits2Float(0x43c5276d), SkBits2Float(0x43afc1ec)); // 378.972f, 384.711f, 394.23f, 369.82f, 394.308f, 351.515f
7218path.cubicTo(SkBits2Float(0x43c51d71), SkBits2Float(0x43a688f6), SkBits2Float(0x43bd7c6b), SkBits2Float(0x439f16ea), SkBits2Float(0x43b4126f), SkBits2Float(0x439f16ea)); // 394.23f, 333.07f, 378.972f, 318.179f, 360.144f, 318.179f
7219path.cubicTo(SkBits2Float(0x43aaa979), SkBits2Float(0x439f16ea), SkBits2Float(0x43a3076d), SkBits2Float(0x43a688f6), SkBits2Float(0x43a31063), SkBits2Float(0x43afc1ec)); // 341.324f, 318.179f, 326.058f, 333.07f, 326.128f, 351.515f
7220path.cubicTo(SkBits2Float(0x43a3076d), SkBits2Float(0x43b8e8f6), SkBits2Float(0x43aaa959), SkBits2Float(0x43c05b02), SkBits2Float(0x43b4126f), SkBits2Float(0x43c058f6)); // 326.058f, 369.82f, 341.323f, 384.711f, 360.144f, 384.695f
7221path.close();
7222}
7223
7224static void joel_13(skiatest::Reporter* reporter, const char* filename) {
7225 SkPath path;
7226 make_joel_13(path);
7227 testSimplify(reporter, path, filename);
7228}
7229
7230
7231static void joel_13x(skiatest::Reporter* reporter, const char* filename) {
7232 SkPath path;
7233 path.setFillType(SkPathFillType::kEvenOdd);
7234 make_joel_13(path);
7235 testSimplify(reporter, path, filename);
7236}
7237
7238static void make_joel_14(SkPath& path) {
7239path.moveTo(SkBits2Float(0x43f3b354), SkBits2Float(0x43d6770a)); // 487.401f, 428.93f
7240path.lineTo(SkBits2Float(0x43f3b354), SkBits2Float(0x43d6770a)); // 487.401f, 428.93f
7241path.close();
7242path.moveTo(SkBits2Float(0x43f0fd50), SkBits2Float(0x43d6770a)); // 481.979f, 428.93f
7243path.lineTo(SkBits2Float(0x43f0fd50), SkBits2Float(0x43d6770a)); // 481.979f, 428.93f
7244path.close();
7245path.moveTo(SkBits2Float(0x43f0fd50), SkBits2Float(0x43d6770a)); // 481.979f, 428.93f
7246path.lineTo(SkBits2Float(0x43f3b354), SkBits2Float(0x43d6770a)); // 487.401f, 428.93f
7247path.lineTo(SkBits2Float(0x43f0fd50), SkBits2Float(0x43d6770a)); // 481.979f, 428.93f
7248path.close();
7249path.moveTo(SkBits2Float(0x43dfe76d), SkBits2Float(0x43d792f1)); // 447.808f, 431.148f
7250path.lineTo(SkBits2Float(0x43dfe76d), SkBits2Float(0x43d792f1)); // 447.808f, 431.148f
7251path.close();
7252path.moveTo(SkBits2Float(0x43dfe76d), SkBits2Float(0x43d792f1)); // 447.808f, 431.148f
7253path.cubicTo(SkBits2Float(0x43e51979), SkBits2Float(0x43d611eb), SkBits2Float(0x43eb8667), SkBits2Float(0x43d765e3), SkBits2Float(0x43f0fd71), SkBits2Float(0x43d676e9)); // 458.199f, 428.14f, 471.05f, 430.796f, 481.98f, 428.929f
7254path.cubicTo(SkBits2Float(0x43eb8667), SkBits2Float(0x43d76604), SkBits2Float(0x43e51958), SkBits2Float(0x43d6120c), SkBits2Float(0x43dfe76d), SkBits2Float(0x43d792f1)); // 471.05f, 430.797f, 458.198f, 428.141f, 447.808f, 431.148f
7255path.close();
7256path.moveTo(SkBits2Float(0x43df776d), SkBits2Float(0x43d6d603)); // 446.933f, 429.672f
7257path.lineTo(SkBits2Float(0x43df776d), SkBits2Float(0x43d6d603)); // 446.933f, 429.672f
7258path.close();
7259path.moveTo(SkBits2Float(0x43df776d), SkBits2Float(0x43d6d603)); // 446.933f, 429.672f
7260path.lineTo(SkBits2Float(0x43dfe76d), SkBits2Float(0x43d79311)); // 447.808f, 431.149f
7261path.lineTo(SkBits2Float(0x43df776d), SkBits2Float(0x43d6d603)); // 446.933f, 429.672f
7262path.close();
7263path.moveTo(SkBits2Float(0x43dd3169), SkBits2Float(0x43d792f1)); // 442.386f, 431.148f
7264path.lineTo(SkBits2Float(0x43dd3169), SkBits2Float(0x43d792f1)); // 442.386f, 431.148f
7265path.close();
7266path.moveTo(SkBits2Float(0x43dd3169), SkBits2Float(0x43d792f1)); // 442.386f, 431.148f
7267path.cubicTo(SkBits2Float(0x43de376d), SkBits2Float(0x43d743f7), SkBits2Float(0x43de2873), SkBits2Float(0x43d68df3), SkBits2Float(0x43df776d), SkBits2Float(0x43d6d5e3)); // 444.433f, 430.531f, 444.316f, 429.109f, 446.933f, 429.671f
7268path.cubicTo(SkBits2Float(0x43de2852), SkBits2Float(0x43d68df3), SkBits2Float(0x43de376d), SkBits2Float(0x43d743f7), SkBits2Float(0x43dd3169), SkBits2Float(0x43d792f1)); // 444.315f, 429.109f, 444.433f, 430.531f, 442.386f, 431.148f
7269path.close();
7270path.moveTo(SkBits2Float(0x43dcc169), SkBits2Float(0x43d6d603)); // 441.511f, 429.672f
7271path.lineTo(SkBits2Float(0x43dcc169), SkBits2Float(0x43d6d603)); // 441.511f, 429.672f
7272path.close();
7273path.moveTo(SkBits2Float(0x43dcc169), SkBits2Float(0x43d6d603)); // 441.511f, 429.672f
7274path.lineTo(SkBits2Float(0x43dd3169), SkBits2Float(0x43d79311)); // 442.386f, 431.149f
7275path.lineTo(SkBits2Float(0x43dcc169), SkBits2Float(0x43d6d603)); // 441.511f, 429.672f
7276path.close();
7277path.moveTo(SkBits2Float(0x43dad959), SkBits2Float(0x43d6d603)); // 437.698f, 429.672f
7278path.lineTo(SkBits2Float(0x43dad959), SkBits2Float(0x43d6d603)); // 437.698f, 429.672f
7279path.close();
7280path.moveTo(SkBits2Float(0x43dad959), SkBits2Float(0x43d6d603)); // 437.698f, 429.672f
7281path.lineTo(SkBits2Float(0x43dcc149), SkBits2Float(0x43d6d603)); // 441.51f, 429.672f
7282path.lineTo(SkBits2Float(0x43dad959), SkBits2Float(0x43d6d603)); // 437.698f, 429.672f
7283path.close();
7284path.moveTo(SkBits2Float(0x43e3cb65), SkBits2Float(0x43e3bd0d)); // 455.589f, 455.477f
7285path.lineTo(SkBits2Float(0x43e3cb65), SkBits2Float(0x43e3bd0d)); // 455.589f, 455.477f
7286path.close();
7287path.moveTo(SkBits2Float(0x43e3cb65), SkBits2Float(0x43e3bd0d)); // 455.589f, 455.477f
7288path.lineTo(SkBits2Float(0x43dad959), SkBits2Float(0x43d6d603)); // 437.698f, 429.672f
7289path.lineTo(SkBits2Float(0x43e3cb65), SkBits2Float(0x43e3bd0d)); // 455.589f, 455.477f
7290path.close();
7291path.moveTo(SkBits2Float(0x43e22d51), SkBits2Float(0x43e41b01)); // 452.354f, 456.211f
7292path.lineTo(SkBits2Float(0x43e22d51), SkBits2Float(0x43e41b01)); // 452.354f, 456.211f
7293path.close();
7294path.moveTo(SkBits2Float(0x43e22d51), SkBits2Float(0x43e41b01)); // 452.354f, 456.211f
7295path.cubicTo(SkBits2Float(0x43e2ba5f), SkBits2Float(0x43e3f9fb), SkBits2Float(0x43e37e57), SkBits2Float(0x43e46df3), SkBits2Float(0x43e3cb45), SkBits2Float(0x43e3bd0d)); // 453.456f, 455.953f, 454.987f, 456.859f, 455.588f, 455.477f
7296path.cubicTo(SkBits2Float(0x43e37e57), SkBits2Float(0x43e46df2), SkBits2Float(0x43e2ba60), SkBits2Float(0x43e3f9fb), SkBits2Float(0x43e22d51), SkBits2Float(0x43e41b01)); // 454.987f, 456.859f, 453.456f, 455.953f, 452.354f, 456.211f
7297path.close();
7298path.moveTo(SkBits2Float(0x43e22d51), SkBits2Float(0x43e479fb)); // 452.354f, 456.953f
7299path.lineTo(SkBits2Float(0x43e22d51), SkBits2Float(0x43e479fb)); // 452.354f, 456.953f
7300path.close();
7301path.moveTo(SkBits2Float(0x43e22d51), SkBits2Float(0x43e479fb)); // 452.354f, 456.953f
7302path.lineTo(SkBits2Float(0x43e22d51), SkBits2Float(0x43e41b01)); // 452.354f, 456.211f
7303path.lineTo(SkBits2Float(0x43e22d51), SkBits2Float(0x43e479fb)); // 452.354f, 456.953f
7304path.close();
7305path.moveTo(SkBits2Float(0x43e35a5f), SkBits2Float(0x43e479fb)); // 454.706f, 456.953f
7306path.lineTo(SkBits2Float(0x43e35a5f), SkBits2Float(0x43e479fb)); // 454.706f, 456.953f
7307path.close();
7308path.moveTo(SkBits2Float(0x43e35a5f), SkBits2Float(0x43e479fb)); // 454.706f, 456.953f
7309path.lineTo(SkBits2Float(0x43e22d51), SkBits2Float(0x43e479fb)); // 452.354f, 456.953f
7310path.lineTo(SkBits2Float(0x43e35a5f), SkBits2Float(0x43e479fb)); // 454.706f, 456.953f
7311path.close();
7312path.moveTo(SkBits2Float(0x43e35a5f), SkBits2Float(0x43e41b01)); // 454.706f, 456.211f
7313path.lineTo(SkBits2Float(0x43e35a5f), SkBits2Float(0x43e41b01)); // 454.706f, 456.211f
7314path.close();
7315path.moveTo(SkBits2Float(0x43e35a5f), SkBits2Float(0x43e41b01)); // 454.706f, 456.211f
7316path.lineTo(SkBits2Float(0x43e35a5f), SkBits2Float(0x43e479fb)); // 454.706f, 456.953f
7317path.lineTo(SkBits2Float(0x43e35a5f), SkBits2Float(0x43e41b01)); // 454.706f, 456.211f
7318path.close();
7319path.moveTo(SkBits2Float(0x43e1726f), SkBits2Float(0x43e90c07)); // 450.894f, 466.094f
7320path.lineTo(SkBits2Float(0x43e1726f), SkBits2Float(0x43e90c07)); // 450.894f, 466.094f
7321path.close();
7322path.moveTo(SkBits2Float(0x43e1726f), SkBits2Float(0x43e90c07)); // 450.894f, 466.094f
7323path.cubicTo(SkBits2Float(0x43e2226f), SkBits2Float(0x43e769fb), SkBits2Float(0x43e50a7f), SkBits2Float(0x43e63915), SkBits2Float(0x43e35a5f), SkBits2Float(0x43e41b01)); // 452.269f, 462.828f, 458.082f, 460.446f, 454.706f, 456.211f
7324path.cubicTo(SkBits2Float(0x43e50a5f), SkBits2Float(0x43e638f5), SkBits2Float(0x43e2226f), SkBits2Float(0x43e769fb), SkBits2Float(0x43e1726f), SkBits2Float(0x43e90c07)); // 458.081f, 460.445f, 452.269f, 462.828f, 450.894f, 466.094f
7325path.close();
7326path.moveTo(SkBits2Float(0x43f09f5d), SkBits2Float(0x43ea2709)); // 481.245f, 468.305f
7327path.lineTo(SkBits2Float(0x43f09f5d), SkBits2Float(0x43ea2709)); // 481.245f, 468.305f
7328path.close();
7329path.moveTo(SkBits2Float(0x43f09f5d), SkBits2Float(0x43ea2709)); // 481.245f, 468.305f
7330path.cubicTo(SkBits2Float(0x43ebbc6b), SkBits2Float(0x43ea4105), SkBits2Float(0x43e56c6b), SkBits2Float(0x43ec9fff), SkBits2Float(0x43e1724f), SkBits2Float(0x43e90c07)); // 471.472f, 468.508f, 458.847f, 473.25f, 450.893f, 466.094f
7331path.cubicTo(SkBits2Float(0x43e56c6c), SkBits2Float(0x43ec9fff), SkBits2Float(0x43ebbc6c), SkBits2Float(0x43ea4105), SkBits2Float(0x43f09f5d), SkBits2Float(0x43ea2709)); // 458.847f, 473.25f, 471.472f, 468.508f, 481.245f, 468.305f
7332path.close();
7333path.moveTo(SkBits2Float(0x43eea45b), SkBits2Float(0x43e9c7ee)); // 477.284f, 467.562f
7334path.lineTo(SkBits2Float(0x43eea45b), SkBits2Float(0x43e9c7ee)); // 477.284f, 467.562f
7335path.close();
7336path.moveTo(SkBits2Float(0x43eea45b), SkBits2Float(0x43e9c7ee)); // 477.284f, 467.562f
7337path.cubicTo(SkBits2Float(0x43ef0c4b), SkBits2Float(0x43ea7ef8), SkBits2Float(0x43eff355), SkBits2Float(0x43ea10e4), SkBits2Float(0x43f09f5d), SkBits2Float(0x43ea26e8)); // 478.096f, 468.992f, 479.901f, 468.132f, 481.245f, 468.304f
7338path.cubicTo(SkBits2Float(0x43eff355), SkBits2Float(0x43ea1105), SkBits2Float(0x43ef0c6b), SkBits2Float(0x43ea7ef8), SkBits2Float(0x43eea45b), SkBits2Float(0x43e9c7ee)); // 479.901f, 468.133f, 478.097f, 468.992f, 477.284f, 467.562f
7339path.close();
7340path.moveTo(SkBits2Float(0x43ee4667), SkBits2Float(0x43ea2709)); // 476.55f, 468.305f
7341path.lineTo(SkBits2Float(0x43ee4667), SkBits2Float(0x43ea2709)); // 476.55f, 468.305f
7342path.close();
7343path.moveTo(SkBits2Float(0x43ee4667), SkBits2Float(0x43ea2709)); // 476.55f, 468.305f
7344path.lineTo(SkBits2Float(0x43eea45b), SkBits2Float(0x43e9c80f)); // 477.284f, 467.563f
7345path.lineTo(SkBits2Float(0x43ee4667), SkBits2Float(0x43ea2709)); // 476.55f, 468.305f
7346path.close();
7347path.moveTo(SkBits2Float(0x43e9f26f), SkBits2Float(0x43e6c2f0)); // 467.894f, 461.523f
7348path.lineTo(SkBits2Float(0x43e9f26f), SkBits2Float(0x43e6c2f0)); // 467.894f, 461.523f
7349path.close();
7350path.moveTo(SkBits2Float(0x43e9f26f), SkBits2Float(0x43e6c2f0)); // 467.894f, 461.523f
7351path.cubicTo(SkBits2Float(0x43eb8873), SkBits2Float(0x43e7dcec), SkBits2Float(0x43eb747b), SkBits2Float(0x43ea9b00), SkBits2Float(0x43ee4667), SkBits2Float(0x43ea26e8)); // 471.066f, 463.726f, 470.91f, 469.211f, 476.55f, 468.304f
7352path.cubicTo(SkBits2Float(0x43eb745b), SkBits2Float(0x43ea9b01), SkBits2Float(0x43eb8853), SkBits2Float(0x43e7dd0d), SkBits2Float(0x43e9f26f), SkBits2Float(0x43e6c2f0)); // 470.909f, 469.211f, 471.065f, 463.727f, 467.894f, 461.523f
7353path.close();
7354path.moveTo(SkBits2Float(0x43ebee56), SkBits2Float(0x43decc07)); // 471.862f, 445.594f
7355path.lineTo(SkBits2Float(0x43ebee56), SkBits2Float(0x43decc07)); // 471.862f, 445.594f
7356path.close();
7357path.moveTo(SkBits2Float(0x43ebee56), SkBits2Float(0x43decc07)); // 471.862f, 445.594f
7358path.cubicTo(SkBits2Float(0x43e85f5c), SkBits2Float(0x43e04915), SkBits2Float(0x43eaa148), SkBits2Float(0x43e41c07), SkBits2Float(0x43e9f24e), SkBits2Float(0x43e6c311)); // 464.745f, 448.571f, 469.26f, 456.219f, 467.893f, 461.524f
7359path.cubicTo(SkBits2Float(0x43eaa169), SkBits2Float(0x43e41c07), SkBits2Float(0x43e85f5c), SkBits2Float(0x43e048f4), SkBits2Float(0x43ebee56), SkBits2Float(0x43decc07)); // 469.261f, 456.219f, 464.745f, 448.57f, 471.862f, 445.594f
7360path.close();
7361path.moveTo(SkBits2Float(0x43eac168), SkBits2Float(0x43dd3fff)); // 469.511f, 442.5f
7362path.lineTo(SkBits2Float(0x43eac168), SkBits2Float(0x43dd3fff)); // 469.511f, 442.5f
7363path.close();
7364path.moveTo(SkBits2Float(0x43eac168), SkBits2Float(0x43dd3fff)); // 469.511f, 442.5f
7365path.cubicTo(SkBits2Float(0x43eb245a), SkBits2Float(0x43ddc7ef), SkBits2Float(0x43eaf45a), SkBits2Float(0x43dedd0d), SkBits2Float(0x43ebee76), SkBits2Float(0x43decc07)); // 470.284f, 443.562f, 469.909f, 445.727f, 471.863f, 445.594f
7366path.cubicTo(SkBits2Float(0x43eaf459), SkBits2Float(0x43dedd0d), SkBits2Float(0x43eb2459), SkBits2Float(0x43ddc7ee), SkBits2Float(0x43eac168), SkBits2Float(0x43dd3fff)); // 469.909f, 445.727f, 470.284f, 443.562f, 469.511f, 442.5f
7367path.close();
7368path.moveTo(SkBits2Float(0x43ec4c6a), SkBits2Float(0x43dce105)); // 472.597f, 441.758f
7369path.lineTo(SkBits2Float(0x43ec4c6a), SkBits2Float(0x43dce105)); // 472.597f, 441.758f
7370path.close();
7371path.moveTo(SkBits2Float(0x43ec4c6a), SkBits2Float(0x43dce105)); // 472.597f, 441.758f
7372path.cubicTo(SkBits2Float(0x43ebcb64), SkBits2Float(0x43dd08f5), SkBits2Float(0x43eb0c6a), SkBits2Float(0x43dc9603), SkBits2Float(0x43eac168), SkBits2Float(0x43dd3fff)); // 471.589f, 442.07f, 470.097f, 441.172f, 469.511f, 442.5f
7373path.cubicTo(SkBits2Float(0x43eb0c6a), SkBits2Float(0x43dc9603), SkBits2Float(0x43ebcb64), SkBits2Float(0x43dd08f5), SkBits2Float(0x43ec4c6a), SkBits2Float(0x43dce105)); // 470.097f, 441.172f, 471.589f, 442.07f, 472.597f, 441.758f
7374path.close();
7375path.moveTo(SkBits2Float(0x43ecbb64), SkBits2Float(0x43ddb105)); // 473.464f, 443.383f
7376path.lineTo(SkBits2Float(0x43ecbb64), SkBits2Float(0x43ddb105)); // 473.464f, 443.383f
7377path.close();
7378path.moveTo(SkBits2Float(0x43ecbb64), SkBits2Float(0x43ddb105)); // 473.464f, 443.383f
7379path.lineTo(SkBits2Float(0x43ec4c6a), SkBits2Float(0x43dce105)); // 472.597f, 441.758f
7380path.lineTo(SkBits2Float(0x43ecbb64), SkBits2Float(0x43ddb105)); // 473.464f, 443.383f
7381path.close();
7382path.moveTo(SkBits2Float(0x43eea45a), SkBits2Float(0x43dc24fd)); // 477.284f, 440.289f
7383path.lineTo(SkBits2Float(0x43eea45a), SkBits2Float(0x43dc24fd)); // 477.284f, 440.289f
7384path.close();
7385path.moveTo(SkBits2Float(0x43eea45a), SkBits2Float(0x43dc24fd)); // 477.284f, 440.289f
7386path.cubicTo(SkBits2Float(0x43eef354), SkBits2Float(0x43dd4c07), SkBits2Float(0x43ed4a5e), SkBits2Float(0x43dcfef9), SkBits2Float(0x43ecbb64), SkBits2Float(0x43ddb105)); // 477.901f, 442.594f, 474.581f, 441.992f, 473.464f, 443.383f
7387path.cubicTo(SkBits2Float(0x43ed4a5e), SkBits2Float(0x43dcfef9), SkBits2Float(0x43eef354), SkBits2Float(0x43dd4c07), SkBits2Float(0x43eea45a), SkBits2Float(0x43dc24fd)); // 474.581f, 441.992f, 477.901f, 442.594f, 477.284f, 440.289f
7388path.close();
7389path.moveTo(SkBits2Float(0x43f09f5c), SkBits2Float(0x43dc24fd)); // 481.245f, 440.289f
7390path.lineTo(SkBits2Float(0x43f09f5c), SkBits2Float(0x43dc24fd)); // 481.245f, 440.289f
7391path.close();
7392path.moveTo(SkBits2Float(0x43f09f5c), SkBits2Float(0x43dc24fd)); // 481.245f, 440.289f
7393path.cubicTo(SkBits2Float(0x43effc6a), SkBits2Float(0x43daeced), SkBits2Float(0x43ef6a5e), SkBits2Float(0x43dbe4fd), SkBits2Float(0x43eea45a), SkBits2Float(0x43dc24fd)); // 479.972f, 437.851f, 478.831f, 439.789f, 477.284f, 440.289f
7394path.cubicTo(SkBits2Float(0x43ef6a5e), SkBits2Float(0x43dbe4fd), SkBits2Float(0x43effc6a), SkBits2Float(0x43daed0d), SkBits2Float(0x43f09f5c), SkBits2Float(0x43dc24fd)); // 478.831f, 439.789f, 479.972f, 437.852f, 481.245f, 440.289f
7395path.close();
7396path.moveTo(SkBits2Float(0x43f2f76c), SkBits2Float(0x43dbc603)); // 485.933f, 439.547f
7397path.lineTo(SkBits2Float(0x43f2f76c), SkBits2Float(0x43dbc603)); // 485.933f, 439.547f
7398path.close();
7399path.moveTo(SkBits2Float(0x43f2f76c), SkBits2Float(0x43dbc603)); // 485.933f, 439.547f
7400path.cubicTo(SkBits2Float(0x43f24c6a), SkBits2Float(0x43dc3b01), SkBits2Float(0x43f16b64), SkBits2Float(0x43dc2311), SkBits2Float(0x43f09f5c), SkBits2Float(0x43dc24fd)); // 484.597f, 440.461f, 482.839f, 440.274f, 481.245f, 440.289f
7401path.cubicTo(SkBits2Float(0x43f16b64), SkBits2Float(0x43dc23f7), SkBits2Float(0x43f24c6a), SkBits2Float(0x43dc3b01), SkBits2Float(0x43f2f76c), SkBits2Float(0x43dbc603)); // 482.839f, 440.281f, 484.597f, 440.461f, 485.933f, 439.547f
7402path.close();
7403path.moveTo(SkBits2Float(0x43f4de55), SkBits2Float(0x43d97d0d)); // 489.737f, 434.977f
7404path.lineTo(SkBits2Float(0x43f4de55), SkBits2Float(0x43d97d0d)); // 489.737f, 434.977f
7405path.close();
7406path.moveTo(SkBits2Float(0x43f4de55), SkBits2Float(0x43d97d0d)); // 489.737f, 434.977f
7407path.cubicTo(SkBits2Float(0x43f47665), SkBits2Float(0x43da020b), SkBits2Float(0x43f42851), SkBits2Float(0x43db9417), SkBits2Float(0x43f2f74b), SkBits2Float(0x43dbc603)); // 488.925f, 436.016f, 488.315f, 439.157f, 485.932f, 439.547f
7408path.cubicTo(SkBits2Float(0x43f42851), SkBits2Float(0x43db93f7), SkBits2Float(0x43f47666), SkBits2Float(0x43da020b), SkBits2Float(0x43f4de55), SkBits2Float(0x43d97d0d)); // 488.315f, 439.156f, 488.925f, 436.016f, 489.737f, 434.977f
7409path.close();
7410path.moveTo(SkBits2Float(0x43f48061), SkBits2Float(0x43d97d0d)); // 489.003f, 434.977f
7411path.lineTo(SkBits2Float(0x43f48061), SkBits2Float(0x43d97d0d)); // 489.003f, 434.977f
7412path.close();
7413path.moveTo(SkBits2Float(0x43f48061), SkBits2Float(0x43d97d0d)); // 489.003f, 434.977f
7414path.lineTo(SkBits2Float(0x43f4de55), SkBits2Float(0x43d97d0d)); // 489.737f, 434.977f
7415path.lineTo(SkBits2Float(0x43f48061), SkBits2Float(0x43d97d0d)); // 489.003f, 434.977f
7416path.close();
7417path.moveTo(SkBits2Float(0x43f3b353), SkBits2Float(0x43d67709)); // 487.401f, 428.93f
7418path.cubicTo(SkBits2Float(0x43f39957), SkBits2Float(0x43d79ef9), SkBits2Float(0x43f3ca5d), SkBits2Float(0x43d8a603), SkBits2Float(0x43f48061), SkBits2Float(0x43d97d0d)); // 487.198f, 431.242f, 487.581f, 433.297f, 489.003f, 434.977f
7419path.cubicTo(SkBits2Float(0x43f3ca5d), SkBits2Float(0x43d8a603), SkBits2Float(0x43f39957), SkBits2Float(0x43d79ef9), SkBits2Float(0x43f3b353), SkBits2Float(0x43d67709)); // 487.581f, 433.297f, 487.198f, 431.242f, 487.401f, 428.93f
7420path.close();
7421}
7422
7423static void joel_14(skiatest::Reporter* reporter, const char* filename) {
7424 SkPath path;
7425 make_joel_14(path);
7426testSimplify(reporter, path, filename);
7427}
7428
7429static void joel_14x(skiatest::Reporter* reporter, const char* filename) {
7430 SkPath path;
7431 path.setFillType(SkPathFillType::kEvenOdd);
7432 make_joel_14(path);
7433testSimplify(reporter, path, filename);
7434}
7435
7436static void make_joel_15(SkPath& path) {
7437path.moveTo(SkBits2Float(0x439e276d), SkBits2Float(0x43dad106)); // 316.308f, 437.633f
7438path.lineTo(SkBits2Float(0x439e276d), SkBits2Float(0x43dad106)); // 316.308f, 437.633f
7439path.close();
7440path.moveTo(SkBits2Float(0x439c1959), SkBits2Float(0x43d78000)); // 312.198f, 431
7441path.lineTo(SkBits2Float(0x439c1959), SkBits2Float(0x43d78000)); // 312.198f, 431
7442path.close();
7443path.moveTo(SkBits2Float(0x439c1959), SkBits2Float(0x43d78000)); // 312.198f, 431
7444path.cubicTo(SkBits2Float(0x439ea45b), SkBits2Float(0x43d6d000), SkBits2Float(0x439cce57), SkBits2Float(0x43d9f3f8), SkBits2Float(0x439e274d), SkBits2Float(0x43dad106)); // 317.284f, 429.625f, 313.612f, 435.906f, 316.307f, 437.633f
7445path.cubicTo(SkBits2Float(0x439cce57), SkBits2Float(0x43d9f3f8), SkBits2Float(0x439ea45b), SkBits2Float(0x43d6d000), SkBits2Float(0x439c1959), SkBits2Float(0x43d78000)); // 313.612f, 435.906f, 317.284f, 429.625f, 312.198f, 431
7446path.close();
7447path.moveTo(SkBits2Float(0x439c1959), SkBits2Float(0x43d8f8f6)); // 312.198f, 433.945f
7448path.lineTo(SkBits2Float(0x439c1959), SkBits2Float(0x43d8f8f6)); // 312.198f, 433.945f
7449path.close();
7450path.moveTo(SkBits2Float(0x439c1959), SkBits2Float(0x43d8f8f6)); // 312.198f, 433.945f
7451path.lineTo(SkBits2Float(0x439c1959), SkBits2Float(0x43d78000)); // 312.198f, 431
7452path.lineTo(SkBits2Float(0x439c1959), SkBits2Float(0x43d8f8f6)); // 312.198f, 433.945f
7453path.close();
7454path.moveTo(SkBits2Float(0x439f7853), SkBits2Float(0x43e5820c)); // 318.94f, 459.016f
7455path.lineTo(SkBits2Float(0x439f7853), SkBits2Float(0x43e5820c)); // 318.94f, 459.016f
7456path.close();
7457path.moveTo(SkBits2Float(0x439f7853), SkBits2Float(0x43e5820c)); // 318.94f, 459.016f
7458path.cubicTo(SkBits2Float(0x439e1647), SkBits2Float(0x43e17106), SkBits2Float(0x439d945b), SkBits2Float(0x43dd020c), SkBits2Float(0x439c1959), SkBits2Float(0x43d8f916)); // 316.174f, 450.883f, 315.159f, 442.016f, 312.198f, 433.946f
7459path.cubicTo(SkBits2Float(0x439d945b), SkBits2Float(0x43dd020c), SkBits2Float(0x439e1667), SkBits2Float(0x43e17106), SkBits2Float(0x439f7853), SkBits2Float(0x43e5820c)); // 315.159f, 442.016f, 316.175f, 450.883f, 318.94f, 459.016f
7460path.close();
7461path.moveTo(SkBits2Float(0x439ffc6c), SkBits2Float(0x43e7f106)); // 319.972f, 463.883f
7462path.lineTo(SkBits2Float(0x439ffc6c), SkBits2Float(0x43e7f106)); // 319.972f, 463.883f
7463path.close();
7464path.moveTo(SkBits2Float(0x439ffc6c), SkBits2Float(0x43e7f106)); // 319.972f, 463.883f
7465path.cubicTo(SkBits2Float(0x439f5668), SkBits2Float(0x43e758f6), SkBits2Float(0x439fec6c), SkBits2Float(0x43e63604), SkBits2Float(0x439f7874), SkBits2Float(0x43e5820c)); // 318.675f, 462.695f, 319.847f, 460.422f, 318.941f, 459.016f
7466path.cubicTo(SkBits2Float(0x439fec6c), SkBits2Float(0x43e63604), SkBits2Float(0x439f5668), SkBits2Float(0x43e758f5), SkBits2Float(0x439ffc6c), SkBits2Float(0x43e7f106)); // 319.847f, 460.422f, 318.675f, 462.695f, 319.972f, 463.883f
7467path.close();
7468path.moveTo(SkBits2Float(0x43a12853), SkBits2Float(0x43ede9fc)); // 322.315f, 475.828f
7469path.lineTo(SkBits2Float(0x43a12853), SkBits2Float(0x43ede9fc)); // 322.315f, 475.828f
7470path.close();
7471path.moveTo(SkBits2Float(0x43a12853), SkBits2Float(0x43ede9fc)); // 322.315f, 475.828f
7472path.cubicTo(SkBits2Float(0x43a18c4b), SkBits2Float(0x43eb7604), SkBits2Float(0x439fe45b), SkBits2Float(0x43ea4b02), SkBits2Float(0x439ffc4b), SkBits2Float(0x43e7f106)); // 323.096f, 470.922f, 319.784f, 468.586f, 319.971f, 463.883f
7473path.cubicTo(SkBits2Float(0x439fe45b), SkBits2Float(0x43ea4b02), SkBits2Float(0x43a18c6c), SkBits2Float(0x43eb7604), SkBits2Float(0x43a12853), SkBits2Float(0x43ede9fc)); // 319.784f, 468.586f, 323.097f, 470.922f, 322.315f, 475.828f
7474path.close();
7475path.moveTo(SkBits2Float(0x43a1e45b), SkBits2Float(0x43ef63f8)); // 323.784f, 478.781f
7476path.lineTo(SkBits2Float(0x43a1e45b), SkBits2Float(0x43ef63f8)); // 323.784f, 478.781f
7477path.close();
7478path.moveTo(SkBits2Float(0x43a1e45b), SkBits2Float(0x43ef63f8)); // 323.784f, 478.781f
7479path.cubicTo(SkBits2Float(0x43a20561), SkBits2Float(0x43eeb9fc), SkBits2Float(0x43a1ae57), SkBits2Float(0x43ee4be8), SkBits2Float(0x43a12853), SkBits2Float(0x43ede9fc)); // 324.042f, 477.453f, 323.362f, 476.593f, 322.315f, 475.828f
7480path.cubicTo(SkBits2Float(0x43a1ae57), SkBits2Float(0x43ee4c08), SkBits2Float(0x43a20561), SkBits2Float(0x43eeb9fc), SkBits2Float(0x43a1e45b), SkBits2Float(0x43ef63f8)); // 323.362f, 476.594f, 324.042f, 477.453f, 323.784f, 478.781f
7481path.close();
7482path.moveTo(SkBits2Float(0x439fb169), SkBits2Float(0x43f032f2)); // 319.386f, 480.398f
7483path.lineTo(SkBits2Float(0x439fb169), SkBits2Float(0x43f032f2)); // 319.386f, 480.398f
7484path.close();
7485path.moveTo(SkBits2Float(0x439fb169), SkBits2Float(0x43f032f2)); // 319.386f, 480.398f
7486path.cubicTo(SkBits2Float(0x43a08063), SkBits2Float(0x43f022f2), SkBits2Float(0x43a1ec6b), SkBits2Float(0x43f078f6), SkBits2Float(0x43a1e45b), SkBits2Float(0x43ef63f8)); // 321.003f, 480.273f, 323.847f, 480.945f, 323.784f, 478.781f
7487path.cubicTo(SkBits2Float(0x43a1ec6b), SkBits2Float(0x43f078f6), SkBits2Float(0x43a08063), SkBits2Float(0x43f022f2), SkBits2Float(0x439fb169), SkBits2Float(0x43f032f2)); // 323.847f, 480.945f, 321.003f, 480.273f, 319.386f, 480.398f
7488path.close();
7489path.moveTo(SkBits2Float(0x439e4d50), SkBits2Float(0x43f16106)); // 316.604f, 482.758f
7490path.lineTo(SkBits2Float(0x439e4d50), SkBits2Float(0x43f16106)); // 316.604f, 482.758f
7491path.close();
7492path.moveTo(SkBits2Float(0x439e4d50), SkBits2Float(0x43f16106)); // 316.604f, 482.758f
7493path.cubicTo(SkBits2Float(0x439de45a), SkBits2Float(0x43f05000), SkBits2Float(0x439f445a), SkBits2Float(0x43f0b20c), SkBits2Float(0x439fb148), SkBits2Float(0x43f03312)); // 315.784f, 480.625f, 318.534f, 481.391f, 319.385f, 480.399f
7494path.cubicTo(SkBits2Float(0x439f445a), SkBits2Float(0x43f0b20c), SkBits2Float(0x439de45a), SkBits2Float(0x43f05000), SkBits2Float(0x439e4d50), SkBits2Float(0x43f16106)); // 318.534f, 481.391f, 315.784f, 480.625f, 316.604f, 482.758f
7495path.close();
7496path.moveTo(SkBits2Float(0x43a0de56), SkBits2Float(0x43f7470a)); // 321.737f, 494.555f
7497path.lineTo(SkBits2Float(0x43a0de56), SkBits2Float(0x43f7470a)); // 321.737f, 494.555f
7498path.close();
7499path.moveTo(SkBits2Float(0x43a0de56), SkBits2Float(0x43f7470a)); // 321.737f, 494.555f
7500path.cubicTo(SkBits2Float(0x439f4062), SkBits2Float(0x43f5a106), SkBits2Float(0x439f2b64), SkBits2Float(0x43f33106), SkBits2Float(0x439e4d50), SkBits2Float(0x43f16106)); // 318.503f, 491.258f, 318.339f, 486.383f, 316.604f, 482.758f
7501path.cubicTo(SkBits2Float(0x439f2b64), SkBits2Float(0x43f33106), SkBits2Float(0x439f4062), SkBits2Float(0x43f5a106), SkBits2Float(0x43a0de56), SkBits2Float(0x43f7470a)); // 318.339f, 486.383f, 318.503f, 491.258f, 321.737f, 494.555f
7502path.close();
7503path.moveTo(SkBits2Float(0x43a3945a), SkBits2Float(0x43fa13f8)); // 327.159f, 500.156f
7504path.lineTo(SkBits2Float(0x43a3945a), SkBits2Float(0x43fa13f8)); // 327.159f, 500.156f
7505path.close();
7506path.moveTo(SkBits2Float(0x43a3945a), SkBits2Float(0x43fa13f8)); // 327.159f, 500.156f
7507path.cubicTo(SkBits2Float(0x43a2dc4a), SkBits2Float(0x43f8ab02), SkBits2Float(0x43a0d74c), SkBits2Float(0x43f8f4fe), SkBits2Float(0x43a0de56), SkBits2Float(0x43f746ea)); // 325.721f, 497.336f, 321.682f, 497.914f, 321.737f, 494.554f
7508path.cubicTo(SkBits2Float(0x43a0d76d), SkBits2Float(0x43f8f4fe), SkBits2Float(0x43a2dc6a), SkBits2Float(0x43f8ab03), SkBits2Float(0x43a3945a), SkBits2Float(0x43fa13f8)); // 321.683f, 497.914f, 325.722f, 497.336f, 327.159f, 500.156f
7509path.close();
7510path.moveTo(SkBits2Float(0x43a58e56), SkBits2Float(0x43fa98f6)); // 331.112f, 501.195f
7511path.lineTo(SkBits2Float(0x43a58e56), SkBits2Float(0x43fa98f6)); // 331.112f, 501.195f
7512path.close();
7513path.moveTo(SkBits2Float(0x43a58e56), SkBits2Float(0x43fa98f6)); // 331.112f, 501.195f
7514path.cubicTo(SkBits2Float(0x43a50148), SkBits2Float(0x43fa2be8), SkBits2Float(0x43a45646), SkBits2Float(0x43fa02f2), SkBits2Float(0x43a3945a), SkBits2Float(0x43fa13f8)); // 330.01f, 500.343f, 328.674f, 500.023f, 327.159f, 500.156f
7515path.cubicTo(SkBits2Float(0x43a45666), SkBits2Float(0x43fa02f2), SkBits2Float(0x43a50168), SkBits2Float(0x43fa2c08), SkBits2Float(0x43a58e56), SkBits2Float(0x43fa98f6)); // 328.675f, 500.023f, 330.011f, 500.344f, 331.112f, 501.195f
7516path.close();
7517path.moveTo(SkBits2Float(0x43a64958), SkBits2Float(0x43f8c000)); // 332.573f, 497.5f
7518path.lineTo(SkBits2Float(0x43a64958), SkBits2Float(0x43f8c000)); // 332.573f, 497.5f
7519path.close();
7520path.moveTo(SkBits2Float(0x43a64958), SkBits2Float(0x43f8c000)); // 332.573f, 497.5f
7521path.lineTo(SkBits2Float(0x43a58e56), SkBits2Float(0x43fa98f6)); // 331.112f, 501.195f
7522path.lineTo(SkBits2Float(0x43a64958), SkBits2Float(0x43f8c000)); // 332.573f, 497.5f
7523path.close();
7524path.moveTo(SkBits2Float(0x43a73e56), SkBits2Float(0x43f5820c)); // 334.487f, 491.016f
7525path.lineTo(SkBits2Float(0x43a73e56), SkBits2Float(0x43f5820c)); // 334.487f, 491.016f
7526path.close();
7527path.moveTo(SkBits2Float(0x43a73e56), SkBits2Float(0x43f5820c)); // 334.487f, 491.016f
7528path.cubicTo(SkBits2Float(0x43a64d50), SkBits2Float(0x43f654fe), SkBits2Float(0x43a7174c), SkBits2Float(0x43f7de14), SkBits2Float(0x43a64958), SkBits2Float(0x43f8c000)); // 332.604f, 492.664f, 334.182f, 495.735f, 332.573f, 497.5f
7529path.cubicTo(SkBits2Float(0x43a7176c), SkBits2Float(0x43f7ddf4), SkBits2Float(0x43a64d50), SkBits2Float(0x43f654fe), SkBits2Float(0x43a73e56), SkBits2Float(0x43f5820c)); // 334.183f, 495.734f, 332.604f, 492.664f, 334.487f, 491.016f
7530path.close();
7531path.moveTo(SkBits2Float(0x43a6f26f), SkBits2Float(0x43f20b02)); // 333.894f, 484.086f
7532path.lineTo(SkBits2Float(0x43a6f26f), SkBits2Float(0x43f20b02)); // 333.894f, 484.086f
7533path.close();
7534path.moveTo(SkBits2Float(0x43a6f26f), SkBits2Float(0x43f20b02)); // 333.894f, 484.086f
7535path.cubicTo(SkBits2Float(0x43a78d71), SkBits2Float(0x43f2f810), SkBits2Float(0x43a72873), SkBits2Float(0x43f453f8), SkBits2Float(0x43a73e77), SkBits2Float(0x43f5820c)); // 335.105f, 485.938f, 334.316f, 488.656f, 334.488f, 491.016f
7536path.cubicTo(SkBits2Float(0x43a72852), SkBits2Float(0x43f453f8), SkBits2Float(0x43a78d50), SkBits2Float(0x43f2f810), SkBits2Float(0x43a6f26f), SkBits2Float(0x43f20b02)); // 334.315f, 488.656f, 335.104f, 485.938f, 333.894f, 484.086f
7537path.close();
7538path.moveTo(SkBits2Float(0x43a6ba5f), SkBits2Float(0x43ef3d0e)); // 333.456f, 478.477f
7539path.lineTo(SkBits2Float(0x43a6ba5f), SkBits2Float(0x43ef3d0e)); // 333.456f, 478.477f
7540path.close();
7541path.moveTo(SkBits2Float(0x43a6ba5f), SkBits2Float(0x43ef3d0e)); // 333.456f, 478.477f
7542path.cubicTo(SkBits2Float(0x43a60e57), SkBits2Float(0x43f04000), SkBits2Float(0x43a82355), SkBits2Float(0x43f0fc08), SkBits2Float(0x43a6f26f), SkBits2Float(0x43f20b02)); // 332.112f, 480.5f, 336.276f, 481.969f, 333.894f, 484.086f
7543path.cubicTo(SkBits2Float(0x43a82354), SkBits2Float(0x43f0fc08), SkBits2Float(0x43a60e56), SkBits2Float(0x43f04000), SkBits2Float(0x43a6ba5f), SkBits2Float(0x43ef3d0e)); // 336.276f, 481.969f, 332.112f, 480.5f, 333.456f, 478.477f
7544path.close();
7545path.moveTo(SkBits2Float(0x43a35c6b), SkBits2Float(0x43ef88f5)); // 326.722f, 479.07f
7546path.lineTo(SkBits2Float(0x43a35c6b), SkBits2Float(0x43ef88f5)); // 326.722f, 479.07f
7547path.close();
7548path.moveTo(SkBits2Float(0x43a35c6b), SkBits2Float(0x43ef88f5)); // 326.722f, 479.07f
7549path.cubicTo(SkBits2Float(0x43a4b26f), SkBits2Float(0x43efe105), SkBits2Float(0x43a5b76d), SkBits2Float(0x43ee2ef9), SkBits2Float(0x43a6ba5f), SkBits2Float(0x43ef3ced)); // 329.394f, 479.758f, 331.433f, 476.367f, 333.456f, 478.476f
7550path.cubicTo(SkBits2Float(0x43a5b76d), SkBits2Float(0x43ee2ef9), SkBits2Float(0x43a4b26f), SkBits2Float(0x43efe106), SkBits2Float(0x43a35c6b), SkBits2Float(0x43ef88f5)); // 331.433f, 476.367f, 329.394f, 479.758f, 326.722f, 479.07f
7551path.close();
7552path.moveTo(SkBits2Float(0x43a08063), SkBits2Float(0x43e5a70a)); // 321.003f, 459.305f
7553path.lineTo(SkBits2Float(0x43a08063), SkBits2Float(0x43e5a70a)); // 321.003f, 459.305f
7554path.close();
7555path.moveTo(SkBits2Float(0x43a08063), SkBits2Float(0x43e5a70a)); // 321.003f, 459.305f
7556path.cubicTo(SkBits2Float(0x43a15169), SkBits2Float(0x43e90312), SkBits2Float(0x43a2626f), SkBits2Float(0x43ec4312), SkBits2Float(0x43a35c6b), SkBits2Float(0x43ef8916)); // 322.636f, 466.024f, 324.769f, 472.524f, 326.722f, 479.071f
7557path.cubicTo(SkBits2Float(0x43a2626f), SkBits2Float(0x43ec42f1), SkBits2Float(0x43a15169), SkBits2Float(0x43e902f1), SkBits2Float(0x43a08063), SkBits2Float(0x43e5a70a)); // 324.769f, 472.523f, 322.636f, 466.023f, 321.003f, 459.305f
7558path.close();
7559path.moveTo(SkBits2Float(0x43a05a5f), SkBits2Float(0x43e407ef)); // 320.706f, 456.062f
7560path.lineTo(SkBits2Float(0x43a05a5f), SkBits2Float(0x43e407ef)); // 320.706f, 456.062f
7561path.close();
7562path.moveTo(SkBits2Float(0x43a05a5f), SkBits2Float(0x43e407ef)); // 320.706f, 456.062f
7563path.lineTo(SkBits2Float(0x43a08063), SkBits2Float(0x43e5a6e9)); // 321.003f, 459.304f
7564path.lineTo(SkBits2Float(0x43a05a5f), SkBits2Float(0x43e407ef)); // 320.706f, 456.062f
7565path.close();
7566path.moveTo(SkBits2Float(0x439ecf5d), SkBits2Float(0x43dd3fff)); // 317.62f, 442.5f
7567path.lineTo(SkBits2Float(0x439ecf5d), SkBits2Float(0x43dd3fff)); // 317.62f, 442.5f
7568path.close();
7569path.moveTo(SkBits2Float(0x439ecf5d), SkBits2Float(0x43dd3fff)); // 317.62f, 442.5f
7570path.cubicTo(SkBits2Float(0x439e9c6b), SkBits2Float(0x43dfcb01), SkBits2Float(0x439fbe57), SkBits2Float(0x43e1cc07), SkBits2Float(0x43a05a5f), SkBits2Float(0x43e407ef)); // 317.222f, 447.586f, 319.487f, 451.594f, 320.706f, 456.062f
7571path.cubicTo(SkBits2Float(0x439fbe57), SkBits2Float(0x43e1cc08), SkBits2Float(0x439e9c6b), SkBits2Float(0x43dfcb01), SkBits2Float(0x439ecf5d), SkBits2Float(0x43dd3fff)); // 319.487f, 451.594f, 317.222f, 447.586f, 317.62f, 442.5f
7572path.close();
7573path.moveTo(SkBits2Float(0x439e276d), SkBits2Float(0x43dad105)); // 316.308f, 437.633f
7574path.cubicTo(SkBits2Float(0x439e4979), SkBits2Float(0x43dba4fd), SkBits2Float(0x439dc375), SkBits2Float(0x43dce915), SkBits2Float(0x439ecf5d), SkBits2Float(0x43dd3fff)); // 316.574f, 439.289f, 315.527f, 441.821f, 317.62f, 442.5f
7575path.cubicTo(SkBits2Float(0x439dc355), SkBits2Float(0x43dce8f5), SkBits2Float(0x439e4959), SkBits2Float(0x43dba4fd), SkBits2Float(0x439e276d), SkBits2Float(0x43dad105)); // 315.526f, 441.82f, 316.573f, 439.289f, 316.308f, 437.633f
7576path.close();
7577}
7578
7579static void joel_15(skiatest::Reporter* reporter, const char* filename) {
7580 SkPath path;
7581 make_joel_15(path);
7582testSimplify(reporter, path, filename);
7583}
7584
7585static void joel_15x(skiatest::Reporter* reporter, const char* filename) {
7586 SkPath path;
7587 path.setFillType(SkPathFillType::kEvenOdd);
7588 make_joel_15(path);
7589testSimplify(reporter, path, filename);
7590}
7591
7592static void make_joel_16(SkPath& path) {
7593path.moveTo(SkBits2Float(0x420e6c8b), SkBits2Float(0x426bdf3b)); // 35.606f, 58.968f
7594path.lineTo(SkBits2Float(0x420fcccd), SkBits2Float(0x426c7ef9)); // 35.95f, 59.124f
7595path.cubicTo(SkBits2Float(0x420fcccd), SkBits2Float(0x426c7ef9), SkBits2Float(0x42093d71), SkBits2Float(0x426c6e97), SkBits2Float(0x42036c8b), SkBits2Float(0x426cbf7c)); // 35.95f, 59.124f, 34.31f, 59.108f, 32.856f, 59.187f
7596path.cubicTo(SkBits2Float(0x41fb3958), SkBits2Float(0x426d0f5b), SkBits2Float(0x41f076c8), SkBits2Float(0x426d48b3), SkBits2Float(0x41ef47ae), SkBits2Float(0x426d947a)); // 31.403f, 59.265f, 30.058f, 59.321f, 29.91f, 59.395f
7597path.cubicTo(SkBits2Float(0x41ee1aa0), SkBits2Float(0x426ddf3b), SkBits2Float(0x41ec6041), SkBits2Float(0x426edb22), SkBits2Float(0x41eb1aa0), SkBits2Float(0x426fee97)); // 29.763f, 59.468f, 29.547f, 59.714f, 29.388f, 59.983f
7598path.cubicTo(SkBits2Float(0x41eb1eb9), SkBits2Float(0x426feb85), SkBits2Float(0x41e9ba5e), SkBits2Float(0x42711eb8), SkBits2Float(0x41e9ba5e), SkBits2Float(0x42711eb8)); // 29.39f, 59.98f, 29.216f, 60.28f, 29.216f, 60.28f
7599path.lineTo(SkBits2Float(0x41e99999), SkBits2Float(0x42718f5c)); // 29.2f, 60.39f
7600path.cubicTo(SkBits2Float(0x41ea76c8), SkBits2Float(0x4271a5e3), SkBits2Float(0x4212dd2f), SkBits2Float(0x42707efa), SkBits2Float(0x4212dd2f), SkBits2Float(0x42707efa)); // 29.308f, 60.412f, 36.716f, 60.124f, 36.716f, 60.124f
7601path.cubicTo(SkBits2Float(0x4212dd2f), SkBits2Float(0x42707efa), SkBits2Float(0x42124395), SkBits2Float(0x42707be8), SkBits2Float(0x42131ba6), SkBits2Float(0x4270b646)); // 36.716f, 60.124f, 36.566f, 60.121f, 36.777f, 60.178f
7602path.cubicTo(SkBits2Float(0x42131581), SkBits2Float(0x42710000), SkBits2Float(0x42130831), SkBits2Float(0x42711688), SkBits2Float(0x4213072b), SkBits2Float(0x42711688)); // 36.771f, 60.25f, 36.758f, 60.272f, 36.757f, 60.272f
7603path.cubicTo(SkBits2Float(0x4212fae1), SkBits2Float(0x42711aa1), SkBits2Float(0x42127cee), SkBits2Float(0x42714eda), SkBits2Float(0x42127cee), SkBits2Float(0x42714eda)); // 36.745f, 60.276f, 36.622f, 60.327f, 36.622f, 60.327f
7604path.cubicTo(SkBits2Float(0x42127ae2), SkBits2Float(0x42714eda), SkBits2Float(0x41c67ae2), SkBits2Float(0x42730f5d), SkBits2Float(0x41c345a2), SkBits2Float(0x427329fd)); // 36.62f, 60.327f, 24.81f, 60.765f, 24.409f, 60.791f
7605path.cubicTo(SkBits2Float(0x41c247ae), SkBits2Float(0x42733e78), SkBits2Float(0x41c04396), SkBits2Float(0x42738e57), SkBits2Float(0x41bf4bc7), SkBits2Float(0x4273e45b)); // 24.285f, 60.811f, 24.033f, 60.889f, 23.912f, 60.973f
7606path.cubicTo(SkBits2Float(0x41bf5c29), SkBits2Float(0x4273e042), SkBits2Float(0x41be9db3), SkBits2Float(0x4274322e), SkBits2Float(0x41be9db3), SkBits2Float(0x4274322e)); // 23.92f, 60.969f, 23.827f, 61.049f, 23.827f, 61.049f
7607path.lineTo(SkBits2Float(0x41be26ea), SkBits2Float(0x42746c8c)); // 23.769f, 61.106f
7608path.cubicTo(SkBits2Float(0x41be1eb9), SkBits2Float(0x427470a5), SkBits2Float(0x41bde354), SkBits2Float(0x42748313), SkBits2Float(0x41bde354), SkBits2Float(0x42748313)); // 23.765f, 61.11f, 23.736f, 61.128f, 23.736f, 61.128f
7609path.lineTo(SkBits2Float(0x41bcc083), SkBits2Float(0x42751582)); // 23.594f, 61.271f
7610path.lineTo(SkBits2Float(0x41bcf3b6), SkBits2Float(0x427526ea)); // 23.619f, 61.288f
7611path.lineTo(SkBits2Float(0x41bd0e56), SkBits2Float(0x42756979)); // 23.632f, 61.353f
7612path.lineTo(SkBits2Float(0x41bd7cee), SkBits2Float(0x42758313)); // 23.686f, 61.378f
7613path.cubicTo(SkBits2Float(0x41be8107), SkBits2Float(0x427572b1), SkBits2Float(0x41bf2d0f), SkBits2Float(0x42754290), SkBits2Float(0x41bfd2f2), SkBits2Float(0x4275147b)); // 23.813f, 61.362f, 23.897f, 61.315f, 23.978f, 61.27f
7614path.lineTo(SkBits2Float(0x41c0ba5f), SkBits2Float(0x4274da1d)); // 24.091f, 61.213f
7615path.lineTo(SkBits2Float(0x41c0ef9e), SkBits2Float(0x4274de36)); // 24.117f, 61.217f
7616path.lineTo(SkBits2Float(0x41c13f7d), SkBits2Float(0x4274d3f9)); // 24.156f, 61.207f
7617path.cubicTo(SkBits2Float(0x41c13f7d), SkBits2Float(0x4274d3f9), SkBits2Float(0x41c174bc), SkBits2Float(0x4274c18a), SkBits2Float(0x41c17cee), SkBits2Float(0x4274be78)); // 24.156f, 61.207f, 24.182f, 61.189f, 24.186f, 61.186f
7618path.cubicTo(SkBits2Float(0x41c18107), SkBits2Float(0x4274bf7e), SkBits2Float(0x41c1e561), SkBits2Float(0x4274b022), SkBits2Float(0x41c1e561), SkBits2Float(0x4274b022)); // 24.188f, 61.187f, 24.237f, 61.172f, 24.237f, 61.172f
7619path.lineTo(SkBits2Float(0x41c45e36), SkBits2Float(0x42746e99)); // 24.546f, 61.108f
7620path.cubicTo(SkBits2Float(0x41c4624f), SkBits2Float(0x42746e99), SkBits2Float(0x41cf999a), SkBits2Float(0x42743853), SkBits2Float(0x41cf999a), SkBits2Float(0x42743853)); // 24.548f, 61.108f, 25.95f, 61.055f, 25.95f, 61.055f
7621path.lineTo(SkBits2Float(0x420d126f), SkBits2Float(0x4272b43a)); // 35.268f, 60.676f
7622path.cubicTo(SkBits2Float(0x420d0938), SkBits2Float(0x4272c084), SkBits2Float(0x420cfcee), SkBits2Float(0x4272c49c), SkBits2Float(0x420cfcee), SkBits2Float(0x4272d917)); // 35.259f, 60.688f, 35.247f, 60.692f, 35.247f, 60.712f
7623path.lineTo(SkBits2Float(0x420d0938), SkBits2Float(0x4272b43a)); // 35.259f, 60.676f
7624path.cubicTo(SkBits2Float(0x420c7be8), SkBits2Float(0x42737efb), SkBits2Float(0x420b3128), SkBits2Float(0x42743128), SkBits2Float(0x420a27f0), SkBits2Float(0x4274c18a)); // 35.121f, 60.874f, 34.798f, 61.048f, 34.539f, 61.189f
7625path.lineTo(SkBits2Float(0x42099eb9), SkBits2Float(0x42750c4b)); // 34.405f, 61.262f
7626path.cubicTo(SkBits2Float(0x420872b1), SkBits2Float(0x4275b022), SkBits2Float(0x4206fbe8), SkBits2Float(0x42764397), SkBits2Float(0x42054396), SkBits2Float(0x4276c084)); // 34.112f, 61.422f, 33.746f, 61.566f, 33.316f, 61.688f
7627path.cubicTo(SkBits2Float(0x42028313), SkBits2Float(0x42776b86), SkBits2Float(0x42007be8), SkBits2Float(0x4278de36), SkBits2Float(0x41fe7ae2), SkBits2Float(0x427b0f5d)); // 32.628f, 61.855f, 32.121f, 62.217f, 31.81f, 62.765f
7628path.cubicTo(SkBits2Float(0x41fe4fe0), SkBits2Float(0x427b21cc), SkBits2Float(0x41fdbe78), SkBits2Float(0x427b8419), SkBits2Float(0x41fdbe78), SkBits2Float(0x427b8419)); // 31.789f, 62.783f, 31.718f, 62.879f, 31.718f, 62.879f
7629path.cubicTo(SkBits2Float(0x41fdccce), SkBits2Float(0x427b71aa), SkBits2Float(0x41fd1cad), SkBits2Float(0x427c27f0), SkBits2Float(0x41fd1cad), SkBits2Float(0x427c27f0)); // 31.725f, 62.861f, 31.639f, 63.039f, 31.639f, 63.039f
7630path.lineTo(SkBits2Float(0x41fc1eb9), SkBits2Float(0x427d178e)); // 31.515f, 63.273f
7631path.lineTo(SkBits2Float(0x41fc7efb), SkBits2Float(0x427d020d)); // 31.562f, 63.252f
7632path.lineTo(SkBits2Float(0x41fbb647), SkBits2Float(0x427d3646)); // 31.464f, 63.303f
7633path.lineTo(SkBits2Float(0x41fbe76e), SkBits2Float(0x427d25e4)); // 31.488f, 63.287f
7634path.lineTo(SkBits2Float(0x41fae149), SkBits2Float(0x427d1fbf)); // 31.36f, 63.281f
7635path.lineTo(SkBits2Float(0x41fa5812), SkBits2Float(0x427d178e)); // 31.293f, 63.273f
7636path.cubicTo(SkBits2Float(0x41f88108), SkBits2Float(0x427cf9dc), SkBits2Float(0x41f73541), SkBits2Float(0x427cb646), SkBits2Float(0x41f5d70c), SkBits2Float(0x427c6d92)); // 31.063f, 63.244f, 30.901f, 63.178f, 30.73f, 63.107f
7637path.lineTo(SkBits2Float(0x41f5999b), SkBits2Float(0x427c6148)); // 30.7f, 63.095f
7638path.cubicTo(SkBits2Float(0x41f5999b), SkBits2Float(0x427c6148), SkBits2Float(0x41f2d0e7), SkBits2Float(0x427bdc29), SkBits2Float(0x41f2a9fd), SkBits2Float(0x427bd4fe)); // 30.7f, 63.095f, 30.352f, 62.965f, 30.333f, 62.958f
7639path.cubicTo(SkBits2Float(0x41f28d51), SkBits2Float(0x427bc49c), SkBits2Float(0x41f26667), SkBits2Float(0x427bb021), SkBits2Float(0x41f26667), SkBits2Float(0x427bb021)); // 30.319f, 62.942f, 30.3f, 62.922f, 30.3f, 62.922f
7640path.lineTo(SkBits2Float(0x41efed92), SkBits2Float(0x427b1db2)); // 29.991f, 62.779f
7641path.lineTo(SkBits2Float(0x41ec9582), SkBits2Float(0x427a624e)); // 29.573f, 62.596f
7642path.cubicTo(SkBits2Float(0x41eca1cc), SkBits2Float(0x427a645a), SkBits2Float(0x41eaf9dc), SkBits2Float(0x427a3021), SkBits2Float(0x41eaf9dc), SkBits2Float(0x427a3021)); // 29.579f, 62.598f, 29.372f, 62.547f, 29.372f, 62.547f
7643path.cubicTo(SkBits2Float(0x41eaf9dc), SkBits2Float(0x427a3021), SkBits2Float(0x41ea126f), SkBits2Float(0x427a1894), SkBits2Float(0x41e9f3b7), SkBits2Float(0x427a1687)); // 29.372f, 62.547f, 29.259f, 62.524f, 29.244f, 62.522f
7644path.cubicTo(SkBits2Float(0x41e9ccce), SkBits2Float(0x427a072b), SkBits2Float(0x41e99375), SkBits2Float(0x4279f1aa), SkBits2Float(0x41e99375), SkBits2Float(0x4279f1aa)); // 29.225f, 62.507f, 29.197f, 62.486f, 29.197f, 62.486f
7645path.lineTo(SkBits2Float(0x41e86e98), SkBits2Float(0x4279d604)); // 29.054f, 62.459f
7646path.lineTo(SkBits2Float(0x41e6147b), SkBits2Float(0x4279a3d7)); // 28.76f, 62.41f
7647path.cubicTo(SkBits2Float(0x41e00625), SkBits2Float(0x42796b85), SkBits2Float(0x41db49ba), SkBits2Float(0x427a7ae1), SkBits2Float(0x41d62b02), SkBits2Float(0x427bc8b4)); // 28.003f, 62.355f, 27.411f, 62.62f, 26.771f, 62.946f
7648path.cubicTo(SkBits2Float(0x41d24fdf), SkBits2Float(0x427cba5e), SkBits2Float(0x41cecccd), SkBits2Float(0x427ce872), SkBits2Float(0x41ca0e56), SkBits2Float(0x427c6872)); // 26.289f, 63.182f, 25.85f, 63.227f, 25.257f, 63.102f
7649path.cubicTo(SkBits2Float(0x41ca0a3d), SkBits2Float(0x427c676c), SkBits2Float(0x41c9353f), SkBits2Float(0x427c570a), SkBits2Float(0x41c9353f), SkBits2Float(0x427c570a)); // 25.255f, 63.101f, 25.151f, 63.085f, 25.151f, 63.085f
7650path.lineTo(SkBits2Float(0x41c73b64), SkBits2Float(0x427c26e9)); // 24.904f, 63.038f
7651path.lineTo(SkBits2Float(0x41c774bc), SkBits2Float(0x427c374b)); // 24.932f, 63.054f
7652path.lineTo(SkBits2Float(0x41c67ef9), SkBits2Float(0x427c0312)); // 24.812f, 63.003f
7653path.cubicTo(SkBits2Float(0x41c4df3b), SkBits2Float(0x427bc5a1), SkBits2Float(0x41c2a3d6), SkBits2Float(0x427b8d4f), SkBits2Float(0x41c0851e), SkBits2Float(0x427b6978)); // 24.609f, 62.943f, 24.33f, 62.888f, 24.065f, 62.853f
7654path.cubicTo(SkBits2Float(0x41bf1893), SkBits2Float(0x427b52f1), SkBits2Float(0x41bd2d0e), SkBits2Float(0x427b52f1), SkBits2Float(0x41bc020c), SkBits2Float(0x427b5e34)); // 23.887f, 62.831f, 23.647f, 62.831f, 23.501f, 62.842f
7655path.lineTo(SkBits2Float(0x41bac6a8), SkBits2Float(0x427b6871)); // 23.347f, 62.852f
7656path.cubicTo(SkBits2Float(0x41b9db23), SkBits2Float(0x427b72ae), SkBits2Float(0x41b87cee), SkBits2Float(0x427b820b), SkBits2Float(0x41b7fbe7), SkBits2Float(0x427b655f)); // 23.232f, 62.862f, 23.061f, 62.877f, 22.998f, 62.849f
7657path.cubicTo(SkBits2Float(0x41b7fbe7), SkBits2Float(0x427b5f3a), SkBits2Float(0x41b7dd2f), SkBits2Float(0x427b48b3), SkBits2Float(0x41b7dd2f), SkBits2Float(0x427b48b3)); // 22.998f, 62.843f, 22.983f, 62.821f, 22.983f, 62.821f
7658path.lineTo(SkBits2Float(0x41b7a5e3), SkBits2Float(0x427b22d0)); // 22.956f, 62.784f
7659path.cubicTo(SkBits2Float(0x41b7be76), SkBits2Float(0x427b3332), SkBits2Float(0x41b74395), SkBits2Float(0x427aed91), SkBits2Float(0x41b74395), SkBits2Float(0x427aed91)); // 22.968f, 62.8f, 22.908f, 62.732f, 22.908f, 62.732f
7660path.lineTo(SkBits2Float(0x41b70c49), SkBits2Float(0x427acfdf)); // 22.881f, 62.703f
7661path.cubicTo(SkBits2Float(0x41b70418), SkBits2Float(0x427ad916), SkBits2Float(0x41b6d70a), SkBits2Float(0x427a9168), SkBits2Float(0x41b6d70a), SkBits2Float(0x427a9168)); // 22.877f, 62.712f, 22.855f, 62.642f, 22.855f, 62.642f
7662path.lineTo(SkBits2Float(0x41b6bc6a), SkBits2Float(0x427a645a)); // 22.842f, 62.598f
7663path.lineTo(SkBits2Float(0x41b66e97), SkBits2Float(0x427a75c2)); // 22.804f, 62.615f
7664path.cubicTo(SkBits2Float(0x41b6872a), SkBits2Float(0x427a71a9), SkBits2Float(0x41b5a9fb), SkBits2Float(0x4279c6a7), SkBits2Float(0x41b5a9fb), SkBits2Float(0x4279c6a7)); // 22.816f, 62.611f, 22.708f, 62.444f, 22.708f, 62.444f
7665path.lineTo(SkBits2Float(0x41b59580), SkBits2Float(0x4279b645)); // 22.698f, 62.428f
7666path.lineTo(SkBits2Float(0x41b549b9), SkBits2Float(0x42799fbe)); // 22.661f, 62.406f
7667path.lineTo(SkBits2Float(0x41b53957), SkBits2Float(0x42799ba5)); // 22.653f, 62.402f
7668path.cubicTo(SkBits2Float(0x41b52b01), SkBits2Float(0x42798d4f), SkBits2Float(0x41b4a3d6), SkBits2Float(0x427920c4), SkBits2Float(0x41b4a3d6), SkBits2Float(0x427920c4)); // 22.646f, 62.388f, 22.58f, 62.282f, 22.58f, 62.282f
7669path.lineTo(SkBits2Float(0x41b43126), SkBits2Float(0x4278be76)); // 22.524f, 62.186f
7670path.lineTo(SkBits2Float(0x41b3ed90), SkBits2Float(0x4278ab01)); // 22.491f, 62.167f
7671path.lineTo(SkBits2Float(0x41b3be75), SkBits2Float(0x42789ba5)); // 22.468f, 62.152f
7672path.lineTo(SkBits2Float(0x41b3d0e4), SkBits2Float(0x4278b957)); // 22.477f, 62.181f
7673path.lineTo(SkBits2Float(0x41b351ea), SkBits2Float(0x42786353)); // 22.415f, 62.097f
7674path.lineTo(SkBits2Float(0x41b33957), SkBits2Float(0x42786353)); // 22.403f, 62.097f
7675path.cubicTo(SkBits2Float(0x41b326e8), SkBits2Float(0x42785a1c), SkBits2Float(0x41b2fbe6), SkBits2Float(0x427846a7), SkBits2Float(0x41b2fbe6), SkBits2Float(0x427846a7)); // 22.394f, 62.088f, 22.373f, 62.069f, 22.373f, 62.069f
7676path.lineTo(SkBits2Float(0x41b2353e), SkBits2Float(0x4277f8d4)); // 22.276f, 61.993f
7677path.cubicTo(SkBits2Float(0x41b26040), SkBits2Float(0x42780624), SkBits2Float(0x41b16e96), SkBits2Float(0x4277d0e4), SkBits2Float(0x41b16e96), SkBits2Float(0x4277d0e4)); // 22.297f, 62.006f, 22.179f, 61.954f, 22.179f, 61.954f
7678path.cubicTo(SkBits2Float(0x41b16e96), SkBits2Float(0x4277d0e4), SkBits2Float(0x41b10417), SkBits2Float(0x4277c188), SkBits2Float(0x41b0fffe), SkBits2Float(0x4277c188)); // 22.179f, 61.954f, 22.127f, 61.939f, 22.125f, 61.939f
7679path.cubicTo(SkBits2Float(0x41b0fffe), SkBits2Float(0x4277bf7c), SkBits2Float(0x41b03f7b), SkBits2Float(0x427778d4), SkBits2Float(0x41b03f7b), SkBits2Float(0x427778d4)); // 22.125f, 61.937f, 22.031f, 61.868f, 22.031f, 61.868f
7680path.lineTo(SkBits2Float(0x41ae8729), SkBits2Float(0x4276f7ce)); // 21.816f, 61.742f
7681path.cubicTo(SkBits2Float(0x41adb644), SkBits2Float(0x4276d0e5), SkBits2Float(0x41ad22cf), SkBits2Float(0x42768e55), SkBits2Float(0x41ac8729), SkBits2Float(0x427648b3)); // 21.714f, 61.704f, 21.642f, 61.639f, 21.566f, 61.571f
7682path.lineTo(SkBits2Float(0x41ab957f), SkBits2Float(0x4275e24d)); // 21.448f, 61.471f
7683path.cubicTo(SkBits2Float(0x41aa8f5a), SkBits2Float(0x42757df3), SkBits2Float(0x41a9b644), SkBits2Float(0x42751fbe), SkBits2Float(0x41a8a3d5), SkBits2Float(0x42747fff)); // 21.32f, 61.373f, 21.214f, 61.281f, 21.08f, 61.125f
7684path.cubicTo(SkBits2Float(0x41a6d708), SkBits2Float(0x4273a3d6), SkBits2Float(0x41a645a0), SkBits2Float(0x4272dd2e), SkBits2Float(0x41a58935), SkBits2Float(0x4271b126)); // 20.855f, 60.91f, 20.784f, 60.716f, 20.692f, 60.423f
7685path.lineTo(SkBits2Float(0x41a5851c), SkBits2Float(0x4271a7ef)); // 20.69f, 60.414f
7686path.lineTo(SkBits2Float(0x41a56a7c), SkBits2Float(0x42719687)); // 20.677f, 60.397f
7687path.lineTo(SkBits2Float(0x41a54dd0), SkBits2Float(0x4271820c)); // 20.663f, 60.377f
7688path.cubicTo(SkBits2Float(0x41a50209), SkBits2Float(0x42711062), SkBits2Float(0x41a4ced6), SkBits2Float(0x42707efa), SkBits2Float(0x41a4be74), SkBits2Float(0x426ff4bc)); // 20.626f, 60.266f, 20.601f, 60.124f, 20.593f, 59.989f
7689path.cubicTo(SkBits2Float(0x41a51478), SkBits2Float(0x427073b6), SkBits2Float(0x41a576c6), SkBits2Float(0x42710b43), SkBits2Float(0x41a576c6), SkBits2Float(0x42710b43)); // 20.635f, 60.113f, 20.683f, 60.261f, 20.683f, 60.261f
7690path.cubicTo(SkBits2Float(0x41a71478), SkBits2Float(0x42730418), SkBits2Float(0x41a9df39), SkBits2Float(0x42746666), SkBits2Float(0x41adc6a5), SkBits2Float(0x427526e9)); // 20.885f, 60.754f, 21.234f, 61.1f, 21.722f, 61.288f
7691path.cubicTo(SkBits2Float(0x41adc499), SkBits2Float(0x427525e3), SkBits2Float(0x41ae47ab), SkBits2Float(0x42754395), SkBits2Float(0x41ae47ab), SkBits2Float(0x42754395)); // 21.721f, 61.287f, 21.785f, 61.316f, 21.785f, 61.316f
7692path.lineTo(SkBits2Float(0x41afe55d), SkBits2Float(0x4275978d)); // 21.987f, 61.398f
7693path.cubicTo(SkBits2Float(0x41b27cea), SkBits2Float(0x4275e147), SkBits2Float(0x41b54dd0), SkBits2Float(0x4275d916), SkBits2Float(0x41b772ad), SkBits2Float(0x42758106)); // 22.311f, 61.47f, 22.663f, 61.462f, 22.931f, 61.376f
7694path.cubicTo(SkBits2Float(0x41b8df38), SkBits2Float(0x42753d70), SkBits2Float(0x41ba1684), SkBits2Float(0x4274d1eb), SkBits2Float(0x41bb4186), SkBits2Float(0x42746979)); // 23.109f, 61.31f, 23.261f, 61.205f, 23.407f, 61.103f
7695path.lineTo(SkBits2Float(0x41bdbc67), SkBits2Float(0x4273a1cb)); // 23.717f, 60.908f
7696path.cubicTo(SkBits2Float(0x41c0f1a6), SkBits2Float(0x4272cccd), SkBits2Float(0x41c3cabd), SkBits2Float(0x4272b958), SkBits2Float(0x41c71684), SkBits2Float(0x4272a3d7)); // 24.118f, 60.7f, 24.474f, 60.681f, 24.886f, 60.66f
7697path.lineTo(SkBits2Float(0x41ca4392), SkBits2Float(0x42728831)); // 25.283f, 60.633f
7698path.lineTo(SkBits2Float(0x41def9d8), SkBits2Float(0x42723f7d)); // 27.872f, 60.562f
7699path.cubicTo(SkBits2Float(0x41e15a1a), SkBits2Float(0x42722d0e), SkBits2Float(0x41e4105f), SkBits2Float(0x42723333), SkBits2Float(0x41e60e53), SkBits2Float(0x4271c7ae)); // 28.169f, 60.544f, 28.508f, 60.55f, 28.757f, 60.445f
7700path.cubicTo(SkBits2Float(0x41e87ceb), SkBits2Float(0x42715810), SkBits2Float(0x41e97ef7), SkBits2Float(0x427077cf), SkBits2Float(0x41ea9165), SkBits2Float(0x426f8a3d)); // 29.061f, 60.336f, 29.187f, 60.117f, 29.321f, 59.885f
7701path.lineTo(SkBits2Float(0x41ebccc9), SkBits2Float(0x426e8a3d)); // 29.475f, 59.635f
7702path.cubicTo(SkBits2Float(0x41ebced5), SkBits2Float(0x426e8937), SkBits2Float(0x41ec2d0b), SkBits2Float(0x426e4ccc), SkBits2Float(0x41ec2d0b), SkBits2Float(0x426e4ccc)); // 29.476f, 59.634f, 29.522f, 59.575f, 29.522f, 59.575f
7703path.lineTo(SkBits2Float(0x41ecae11), SkBits2Float(0x426dde34)); // 29.585f, 59.467f
7704path.lineTo(SkBits2Float(0x41ecdf38), SkBits2Float(0x426dde34)); // 29.609f, 59.467f
7705path.lineTo(SkBits2Float(0x41ed26e6), SkBits2Float(0x426dc082)); // 29.644f, 59.438f
7706path.cubicTo(SkBits2Float(0x41ee1ca9), SkBits2Float(0x426d5a1c), SkBits2Float(0x41eeccc9), SkBits2Float(0x426d1061), SkBits2Float(0x41f01684), SkBits2Float(0x426ce978)); // 29.764f, 59.338f, 29.85f, 59.266f, 30.011f, 59.228f
7707path.cubicTo(SkBits2Float(0x41f29fbb), SkBits2Float(0x426c8e55), SkBits2Float(0x420cced8), SkBits2Float(0x426bd4fd), SkBits2Float(0x420e6c8a), SkBits2Float(0x426bdf3b)); // 30.328f, 59.139f, 35.202f, 58.958f, 35.606f, 58.968f
7708path.moveTo(SkBits2Float(0x41b60622), SkBits2Float(0x427adb22)); // 22.753f, 62.714f
7709path.lineTo(SkBits2Float(0x41b60416), SkBits2Float(0x427ad709)); // 22.752f, 62.71f
7710path.cubicTo(SkBits2Float(0x41b60416), SkBits2Float(0x427ad603), SkBits2Float(0x41b60416), SkBits2Float(0x427ad915), SkBits2Float(0x41b60622), SkBits2Float(0x427adb22)); // 22.752f, 62.709f, 22.752f, 62.712f, 22.753f, 62.714f
7711path.moveTo(SkBits2Float(0x41bed2ef), SkBits2Float(0x4274cbc6)); // 23.853f, 61.199f
7712path.close();
7713path.moveTo(SkBits2Float(0x41c04fdd), SkBits2Float(0x42746560)); // 24.039f, 61.099f
7714path.close();
7715}
7716
7717static void joel_16(skiatest::Reporter* reporter, const char* filename) {
7718 SkPath path;
7719 make_joel_16(path);
7720testSimplify(reporter, path, filename);
7721}
7722
7723static void joel_16x(skiatest::Reporter* reporter, const char* filename) {
7724 SkPath path;
7725 path.setFillType(SkPathFillType::kEvenOdd);
7726 make_joel_16(path);
7727testSimplify(reporter, path, filename);
7728}
7729
7730static void coincubics(skiatest::Reporter* reporter, const char* filename) {
7731 SkPath path;
7732 path.moveTo(SkDoubleToScalar(0.00000000000000000), SkDoubleToScalar(0.00000000000000000));
7733 path.cubicTo(SkDoubleToScalar(0.00022939755581319332), SkDoubleToScalar(0.00022927834652364254),
7734 SkDoubleToScalar(0.00022930106206331402), SkDoubleToScalar(0.00022929999977350235),
7735 SkDoubleToScalar(0.00022930069826543331), SkDoubleToScalar(0.00022913678549230099));
7736 path.lineTo(SkDoubleToScalar(0.00022930069826543331), SkDoubleToScalar(0.00022930069826543331));
7737 path.cubicTo(SkDoubleToScalar(0.00011465034913271666), SkDoubleToScalar(0.00011465034913271666),
7738 SkDoubleToScalar(0.00011465061106719077), SkDoubleToScalar(0.00011460937093943357),
7739 SkDoubleToScalar(0.00014331332931760699), SkDoubleToScalar(0.00014325146912597120));
7740testSimplify(reporter, path, filename);
7741}
7742
7743static void grshapearc(skiatest::Reporter* reporter, const char* filename) {
7744 SkPath path;
7745path.setFillType(SkPathFillType::kWinding);
7746path.moveTo(25.0098f, 23.1973f);
7747path.lineTo(25.5689f, 22.3682f);
7748path.conicTo(26.1281f, 21.5392f, 26.9572f, 22.0984f, 0.707107f);
7749path.conicTo(27.7862f, 22.6576f, 27.227f, 23.4866f, 0.707107f);
7750path.lineTo(26.6678f, 24.3156f);
7751path.conicTo(26.1086f, 25.1447f, 25.2796f, 24.5855f, 0.707107f);
7752path.conicTo(24.4506f, 24.0263f, 25.0098f, 23.1973f, 0.707107f);
7753path.close();
7754path.moveTo(26.6873f, 20.7101f);
7755path.lineTo(27.2465f, 19.8811f);
7756path.conicTo(27.8057f, 19.0521f, 28.6348f, 19.6113f, 0.707107f);
7757path.conicTo(29.4638f, 20.1704f, 28.9046f, 20.9995f, 0.707107f);
7758path.lineTo(28.3454f, 21.8285f);
7759path.conicTo(27.7862f, 22.6576f, 26.9572f, 22.0984f, 0.707107f);
7760path.conicTo(26.1281f, 21.5392f, 26.6873f, 20.7101f, 0.707107f);
7761path.close();
7762path.moveTo(28.3649f, 18.223f);
7763path.lineTo(28.9241f, 17.394f);
7764path.conicTo(29.4833f, 16.565f, 30.3123f, 17.1241f, 0.707107f);
7765path.conicTo(31.1414f, 17.6833f, 30.5822f, 18.5124f, 0.707107f);
7766path.lineTo(30.023f, 19.3414f);
7767path.conicTo(29.4638f, 20.1704f, 28.6348f, 19.6113f, 0.707107f);
7768path.conicTo(27.8057f, 19.0521f, 28.3649f, 18.223f, 0.707107f);
7769path.close();
7770path.moveTo(30.0425f, 15.7359f);
7771path.lineTo(30.6017f, 14.9069f);
7772path.conicTo(31.1609f, 14.0778f, 31.9899f, 14.637f, 0.707107f);
7773path.conicTo(32.8189f, 15.1962f, 32.2598f, 16.0253f, 0.707107f);
7774path.lineTo(31.7006f, 16.8543f);
7775path.conicTo(31.1414f, 17.6833f, 30.3123f, 17.1241f, 0.707107f);
7776path.conicTo(29.4833f, 16.565f, 30.0425f, 15.7359f, 0.707107f);
7777path.close();
7778path.moveTo(31.7201f, 13.2488f);
7779path.lineTo(32.2793f, 12.4198f);
7780path.conicTo(32.8385f, 11.5907f, 33.6675f, 12.1499f, 0.707107f);
7781path.conicTo(34.4965f, 12.7091f, 33.9373f, 13.5381f, 0.707107f);
7782path.lineTo(33.3781f, 14.3672f);
7783path.conicTo(32.8189f, 15.1962f, 31.9899f, 14.637f, 0.707107f);
7784path.conicTo(31.1609f, 14.0778f, 31.7201f, 13.2488f, 0.707107f);
7785path.close();
7786path.moveTo(33.3976f, 10.7617f);
7787path.lineTo(33.9568f, 9.93265f);
7788path.conicTo(34.516f, 9.10361f, 35.3451f, 9.6628f, 0.707107f);
7789path.conicTo(36.1741f, 10.222f, 35.6149f, 11.051f, 0.707107f);
7790path.lineTo(35.0557f, 11.8801f);
7791path.conicTo(34.4965f, 12.7091f, 33.6675f, 12.1499f, 0.707107f);
7792path.conicTo(32.8385f, 11.5907f, 33.3976f, 10.7617f, 0.707107f);
7793path.close();
7794path.moveTo(35.0752f, 8.27457f);
7795path.lineTo(35.6344f, 7.44554f);
7796path.conicTo(36.1936f, 6.6165f, 37.0226f, 7.17569f, 0.707107f);
7797path.conicTo(37.8517f, 7.73488f, 37.2925f, 8.56392f, 0.707107f);
7798path.lineTo(36.7333f, 9.39296f);
7799path.conicTo(36.1741f, 10.222f, 35.3451f, 9.6628f, 0.707107f);
7800path.conicTo(34.516f, 9.10361f, 35.0752f, 8.27457f, 0.707107f);
7801path.close();
7802path.moveTo(36.7528f, 5.78746f);
7803path.lineTo(37.312f, 4.95842f);
7804path.conicTo(37.8712f, 4.12939f, 38.7002f, 4.68858f, 0.707107f);
7805path.conicTo(39.5293f, 5.24777f, 38.9701f, 6.07681f, 0.707107f);
7806path.lineTo(38.4109f, 6.90585f);
7807path.conicTo(37.8517f, 7.73488f, 37.0226f, 7.17569f, 0.707107f);
7808path.conicTo(36.1936f, 6.6165f, 36.7528f, 5.78746f, 0.707107f);
7809path.close();
7810path.moveTo(39.9447f, 3.72429f);
7811path.quadTo(40.3524f, 4.01069f, 40.7489f, 4.31248f);
7812path.conicTo(41.5445f, 4.9182f, 40.9388f, 5.71387f, 0.707107f);
7813path.conicTo(40.3331f, 6.50955f, 39.5374f, 5.90383f, 0.707107f);
7814path.quadTo(39.1714f, 5.62521f, 38.7951f, 5.36088f);
7815path.conicTo(37.9768f, 4.78608f, 38.5516f, 3.96779f, 0.707107f);
7816path.conicTo(39.1264f, 3.14949f, 39.9447f, 3.72429f, 0.707107f);
7817path.close();
7818path.moveTo(42.3194f, 5.60826f);
7819path.quadTo(42.707f, 5.95446f, 43.0804f, 6.31583f);
7820path.conicTo(43.7991f, 7.01122f, 43.1037f, 7.72985f, 0.707107f);
7821path.conicTo(42.4083f, 8.44848f, 41.6896f, 7.75308f, 0.707107f);
7822path.quadTo(41.3448f, 7.41944f, 40.9871f, 7.09992f);
7823path.conicTo(40.2413f, 6.43379f, 40.9074f, 5.68796f, 0.707107f);
7824path.conicTo(41.5735f, 4.94212f, 42.3194f, 5.60826f, 0.707107f);
7825path.close();
7826path.moveTo(44.5406f, 7.84871f);
7827path.quadTo(44.8959f, 8.25352f, 45.2341f, 8.67266f);
7828path.conicTo(45.862f, 9.4509f, 45.0838f, 10.0789f, 0.707107f);
7829path.conicTo(44.3056f, 10.7068f, 43.6776f, 9.9286f, 0.707107f);
7830path.quadTo(43.3654f, 9.54174f, 43.0374f, 9.16805f);
7831path.conicTo(42.3778f, 8.41649f, 43.1293f, 7.75682f, 0.707107f);
7832path.conicTo(43.8809f, 7.09715f, 44.5406f, 7.84871f, 0.707107f);
7833path.close();
7834path.moveTo(46.528f, 10.4211f);
7835path.quadTo(46.815f, 10.8449f, 47.0851f, 11.2796f);
7836path.conicTo(47.6128f, 12.129f, 46.7633f, 12.6567f, 0.707107f);
7837path.conicTo(45.9139f, 13.1844f, 45.3862f, 12.335f, 0.707107f);
7838path.quadTo(45.1369f, 11.9337f, 44.872f, 11.5426f);
7839path.conicTo(44.3113f, 10.7146f, 45.1393f, 10.1538f, 0.707107f);
7840path.conicTo(45.9673f, 9.5931f, 46.528f, 10.4211f, 0.707107f);
7841path.close();
7842path.moveTo(48.1056f, 13.0782f);
7843path.quadTo(48.3449f, 13.542f, 48.5654f, 14.015f);
7844path.conicTo(48.9879f, 14.9213f, 48.0816f, 15.3438f, 0.707107f);
7845path.conicTo(47.1752f, 15.7663f, 46.7527f, 14.86f, 0.707107f);
7846path.quadTo(46.5492f, 14.4234f, 46.3283f, 13.9953f);
7847path.conicTo(45.8698f, 13.1066f, 46.7584f, 12.6481f, 0.707107f);
7848path.conicTo(47.6471f, 12.1895f, 48.1056f, 13.0782f, 0.707107f);
7849path.close();
7850path.moveTo(49.3755f, 15.9538f);
7851path.quadTo(49.5594f, 16.4493f, 49.7229f, 16.9516f);
7852path.conicTo(50.0325f, 17.9025f, 49.0816f, 18.2121f, 0.707107f);
7853path.conicTo(48.1307f, 18.5216f, 47.8212f, 17.5707f, 0.707107f);
7854path.quadTo(47.6702f, 17.1069f, 47.5005f, 16.6497f);
7855path.conicTo(47.1526f, 15.7122f, 48.0901f, 15.3642f, 0.707107f);
7856path.conicTo(49.0276f, 15.0163f, 49.3755f, 15.9538f, 0.707107f);
7857path.close();
7858path.moveTo(50.2964f, 18.9923f);
7859path.quadTo(50.4191f, 19.5089f, 50.5206f, 20.0302f);
7860path.conicTo(50.7117f, 21.0117f, 49.7302f, 21.2029f, 0.707107f);
7861path.conicTo(48.7486f, 21.394f, 48.5575f, 20.4125f, 0.707107f);
7862path.quadTo(48.4638f, 19.9313f, 48.3505f, 19.4544f);
7863path.conicTo(48.1194f, 18.4815f, 49.0924f, 18.2504f, 0.707107f);
7864path.conicTo(50.0653f, 18.0193f, 50.2964f, 18.9923f, 0.707107f);
7865path.close();
7866path.moveTo(50.8373f, 22.0956f);
7867path.quadTo(50.8955f, 22.6138f, 50.933f, 23.1341f);
7868path.conicTo(51.0047f, 24.1315f, 50.0073f, 24.2033f, 0.707107f);
7869path.conicTo(49.0099f, 24.275f, 48.9381f, 23.2776f, 0.707107f);
7870path.quadTo(48.9036f, 22.7975f, 48.8498f, 22.3191f);
7871path.conicTo(48.7381f, 21.3253f, 49.7318f, 21.2136f, 0.707107f);
7872path.conicTo(50.7255f, 21.1019f, 50.8373f, 22.0956f, 0.707107f);
7873path.close();
7874path.moveTo(50.9992f, 25.2099f);
7875path.quadTo(50.9949f, 25.7358f, 50.9694f, 26.2608f);
7876path.conicTo(50.9209f, 27.2596f, 49.9221f, 27.2111f, 0.707107f);
7877path.conicTo(48.9233f, 27.1626f, 48.9718f, 26.1638f, 0.707107f);
7878path.quadTo(48.9953f, 25.679f, 48.9992f, 25.1938f);
7879path.conicTo(49.0073f, 24.1938f, 50.0073f, 24.2019f, 0.707107f);
7880path.conicTo(51.0072f, 24.21f, 50.9992f, 25.2099f, 0.707107f);
7881path.close();
7882path.moveTo(50.7839f, 28.3454f);
7883path.quadTo(50.7172f, 28.8596f, 50.63f, 29.3708f);
7884path.conicTo(50.4619f, 30.3565f, 49.4761f, 30.1884f, 0.707107f);
7885path.conicTo(48.4903f, 30.0203f, 48.6584f, 29.0346f, 0.707107f);
7886path.quadTo(48.7389f, 28.5627f, 48.8005f, 28.088f);
7887path.conicTo(48.9292f, 27.0963f, 49.9209f, 27.225f, 0.707107f);
7888path.conicTo(50.9126f, 27.3537f, 50.7839f, 28.3454f, 0.707107f);
7889path.close();
7890path.moveTo(50.1906f, 31.437f);
7891path.quadTo(50.0558f, 31.9646f, 49.899f, 32.4861f);
7892path.conicTo(49.611f, 33.4438f, 48.6534f, 33.1558f, 0.707107f);
7893path.conicTo(47.6957f, 32.8679f, 47.9837f, 31.9103f, 0.707107f);
7894path.quadTo(48.1284f, 31.4289f, 48.2528f, 30.9418f);
7895path.conicTo(48.5004f, 29.9729f, 49.4693f, 30.2205f, 0.707107f);
7896path.conicTo(50.4382f, 30.4681f, 50.1906f, 31.437f, 0.707107f);
7897path.close();
7898path.moveTo(49.1978f, 34.5114f);
7899path.quadTo(49.0051f, 35.0016f, 48.7927f, 35.4837f);
7900path.conicTo(48.3895f, 36.3988f, 47.4744f, 35.9956f, 0.707107f);
7901path.conicTo(46.5593f, 35.5923f, 46.9625f, 34.6772f, 0.707107f);
7902path.quadTo(47.1586f, 34.2323f, 47.3364f, 33.7797f);
7903path.conicTo(47.7023f, 32.849f, 48.6329f, 33.2149f, 0.707107f);
7904path.conicTo(49.5636f, 33.5807f, 49.1978f, 34.5114f, 0.707107f);
7905path.close();
7906path.moveTo(47.8852f, 37.3397f);
7907path.quadTo(47.6449f, 37.7853f, 47.3876f, 38.2211f);
7908path.conicTo(46.879f, 39.0821f, 46.018f, 38.5736f, 0.707107f);
7909path.conicTo(45.1569f, 38.0651f, 45.6655f, 37.204f, 0.707107f);
7910path.quadTo(45.903f, 36.8018f, 46.1248f, 36.3906f);
7911path.conicTo(46.5993f, 35.5103f, 47.4796f, 35.9849f, 0.707107f);
7912path.conicTo(48.3598f, 36.4595f, 47.8852f, 37.3397f, 0.707107f);
7913path.close();
7914path.moveTo(46.3154f, 39.8881f);
7915path.quadTo(46.0303f, 40.2962f, 45.7299f, 40.693f);
7916path.conicTo(45.1264f, 41.4903f, 44.3291f, 40.8867f, 0.707107f);
7917path.conicTo(43.5318f, 40.2831f, 44.1353f, 39.4858f, 0.707107f);
7918path.quadTo(44.4126f, 39.1195f, 44.6757f, 38.7428f);
7919path.conicTo(45.2483f, 37.923f, 46.0682f, 38.4956f, 0.707107f);
7920path.conicTo(46.888f, 39.0682f, 46.3154f, 39.8881f, 0.707107f);
7921path.close();
7922path.moveTo(44.4398f, 42.2654f);
7923path.quadTo(44.095f, 42.6536f, 43.7349f, 43.0278f);
7924path.conicTo(43.0415f, 43.7484f, 42.321f, 43.055f, 0.707107f);
7925path.conicTo(41.6004f, 42.3616f, 42.2938f, 41.641f, 0.707107f);
7926path.quadTo(42.6261f, 41.2957f, 42.9444f, 40.9374f);
7927path.conicTo(43.6084f, 40.1897f, 44.3561f, 40.8537f, 0.707107f);
7928path.conicTo(45.1038f, 41.5177f, 44.4398f, 42.2654f, 0.707107f);
7929path.close();
7930path.moveTo(42.2075f, 44.4911f);
7931path.quadTo(41.804f, 44.8473f, 41.3862f, 45.1865f);
7932path.conicTo(40.6098f, 45.8167f, 39.9795f, 45.0403f, 0.707107f);
7933path.conicTo(39.3493f, 44.2639f, 40.1257f, 43.6336f, 0.707107f);
7934path.quadTo(40.5114f, 43.3205f, 40.8838f, 42.9918f);
7935path.conicTo(41.6335f, 42.3299f, 42.2953f, 43.0796f, 0.707107f);
7936path.conicTo(42.9572f, 43.8292f, 42.2075f, 44.4911f, 0.707107f);
7937path.close();
7938path.moveTo(39.6379f, 46.488f);
7939path.quadTo(39.2151f, 46.776f, 38.7814f, 47.0471f);
7940path.conicTo(37.9334f, 47.5771f, 37.4034f, 46.7292f, 0.707107f);
7941path.conicTo(36.8733f, 45.8812f, 37.7213f, 45.3511f, 0.707107f);
7942path.quadTo(38.1217f, 45.1009f, 38.5119f, 44.835f);
7943path.conicTo(39.3383f, 44.2721f, 39.9013f, 45.0985f, 0.707107f);
7944path.conicTo(40.4643f, 45.925f, 39.6379f, 46.488f, 0.707107f);
7945path.close();
7946path.moveTo(36.9864f, 48.0722f);
7947path.quadTo(36.5234f, 48.3127f, 36.0513f, 48.5344f);
7948path.conicTo(35.1461f, 48.9595f, 34.7211f, 48.0543f, 0.707107f);
7949path.conicTo(34.296f, 47.1491f, 35.2012f, 46.7241f, 0.707107f);
7950path.quadTo(35.6371f, 46.5194f, 36.0644f, 46.2974f);
7951path.conicTo(36.9518f, 45.8364f, 37.4128f, 46.7238f, 0.707107f);
7952path.conicTo(37.8738f, 47.6112f, 36.9864f, 48.0722f, 0.707107f);
7953path.close();
7954path.moveTo(34.1153f, 49.3498f);
7955path.quadTo(33.6206f, 49.535f, 33.1187f, 49.6999f);
7956path.conicTo(32.1687f, 50.0122f, 31.8565f, 49.0622f, 0.707107f);
7957path.conicTo(31.5442f, 48.1122f, 32.4942f, 47.7999f, 0.707107f);
7958path.quadTo(32.9575f, 47.6477f, 33.4141f, 47.4767f);
7959path.conicTo(34.3507f, 47.1261f, 34.7012f, 48.0627f, 0.707107f);
7960path.conicTo(35.0518f, 48.9992f, 34.1153f, 49.3498f, 0.707107f);
7961path.close();
7962path.moveTo(31.08f, 50.2791f);
7963path.quadTo(30.5637f, 50.4033f, 30.0427f, 50.5063f);
7964path.conicTo(29.0617f, 50.7002f, 28.8678f, 49.7192f, 0.707107f);
7965path.conicTo(28.6738f, 48.7382f, 29.6548f, 48.5443f, 0.707107f);
7966path.quadTo(30.1357f, 48.4492f, 30.6122f, 48.3346f);
7967path.conicTo(31.5845f, 48.1007f, 31.8184f, 49.073f, 0.707107f);
7968path.conicTo(32.0522f, 50.0453f, 31.08f, 50.2791f, 0.707107f);
7969path.close();
7970path.moveTo(27.9769f, 50.829f);
7971path.quadTo(27.4588f, 50.8887f, 26.9386f, 50.9276f);
7972path.conicTo(25.9414f, 51.0022f, 25.8668f, 50.005f, 0.707107f);
7973path.conicTo(25.7923f, 49.0078f, 26.7895f, 48.9332f, 0.707107f);
7974path.quadTo(27.2696f, 48.8973f, 27.7479f, 48.8422f);
7975path.conicTo(28.7413f, 48.7277f, 28.8558f, 49.7211f, 0.707107f);
7976path.conicTo(28.9703f, 50.7145f, 27.9769f, 50.829f, 0.707107f);
7977path.close();
7978path.moveTo(24.8625f, 50.9996f);
7979path.quadTo(24.3373f, 50.9969f, 23.8128f, 50.9729f);
7980path.conicTo(22.8138f, 50.9272f, 22.8595f, 49.9283f, 0.707107f);
7981path.conicTo(22.9051f, 48.9293f, 23.9041f, 48.975f, 0.707107f);
7982path.quadTo(24.3884f, 48.9971f, 24.8731f, 48.9997f);
7983path.conicTo(25.8731f, 49.005f, 25.8678f, 50.005f, 0.707107f);
7984path.conicTo(25.8624f, 51.0049f, 24.8625f, 50.9996f, 0.707107f);
7985path.close();
7986path.moveTo(21.7268f, 50.7931f);
7987path.quadTo(21.2121f, 50.7278f, 20.7005f, 50.642f);
7988path.conicTo(19.7143f, 50.4767f, 19.8796f, 49.4905f, 0.707107f);
7989path.conicTo(20.045f, 48.5042f, 21.0312f, 48.6696f, 0.707107f);
7990path.quadTo(21.5036f, 48.7488f, 21.9786f, 48.8091f);
7991path.conicTo(22.9707f, 48.9349f, 22.8448f, 49.927f, 0.707107f);
7992path.conicTo(22.7189f, 50.919f, 21.7268f, 50.7931f, 0.707107f);
7993path.close();
7994path.moveTo(18.6372f, 50.2094f);
7995path.quadTo(18.1089f, 50.0761f, 17.5865f, 49.9207f);
7996path.conicTo(16.628f, 49.6356f, 16.9132f, 48.6771f, 0.707107f);
7997path.conicTo(17.1983f, 47.7186f, 18.1568f, 48.0037f, 0.707107f);
7998path.quadTo(18.639f, 48.1472f, 19.1267f, 48.2702f);
7999path.conicTo(20.0963f, 48.515f, 19.8516f, 49.4846f, 0.707107f);
8000path.conicTo(19.6068f, 50.4542f, 18.6372f, 50.2094f, 0.707107f);
8001path.close();
8002path.moveTo(15.5577f, 49.2248f);
8003path.quadTo(15.0665f, 49.0334f, 14.5834f, 48.8222f);
8004path.conicTo(13.6672f, 48.4215f, 14.0678f, 47.5053f, 0.707107f);
8005path.conicTo(14.4684f, 46.589f, 15.3847f, 46.9897f, 0.707107f);
8006path.quadTo(15.8306f, 47.1846f, 16.284f, 47.3614f);
8007path.conicTo(17.2158f, 47.7246f, 16.8526f, 48.6563f, 0.707107f);
8008path.conicTo(16.4894f, 49.588f, 15.5577f, 49.2248f, 0.707107f);
8009path.close();
8010path.moveTo(12.7231f, 47.9189f);
8011path.quadTo(12.2765f, 47.6797f, 11.8395f, 47.4233f);
8012path.conicTo(10.9771f, 46.9171f, 11.4833f, 46.0547f, 0.707107f);
8013path.conicTo(11.9894f, 45.1922f, 12.8519f, 45.6984f, 0.707107f);
8014path.quadTo(13.2552f, 45.9351f, 13.6675f, 46.156f);
8015path.conicTo(14.549f, 46.6282f, 14.0768f, 47.5096f, 0.707107f);
8016path.conicTo(13.6046f, 48.3911f, 12.7231f, 47.9189f, 0.707107f);
8017path.close();
8018path.moveTo(10.1686f, 46.3548f);
8019path.quadTo(9.76024f, 46.0712f, 9.363f, 45.7722f);
8020path.conicTo(8.56406f, 45.1708f, 9.16549f, 44.3718f, 0.707107f);
8021path.conicTo(9.76691f, 43.5729f, 10.5658f, 44.1743f, 0.707107f);
8022path.quadTo(10.9325f, 44.4504f, 11.3095f, 44.7122f);
8023path.conicTo(12.1308f, 45.2826f, 11.5604f, 46.1039f, 0.707107f);
8024path.conicTo(10.9899f, 46.9253f, 10.1686f, 46.3548f, 0.707107f);
8025path.close();
8026path.moveTo(7.78853f, 44.4876f);
8027path.quadTo(7.39972f, 44.1442f, 7.02492f, 43.7855f);
8028path.conicTo(6.3024f, 43.0942f, 6.99374f, 42.3717f, 0.707107f);
8029path.conicTo(7.68509f, 41.6492f, 8.40761f, 42.3405f, 0.707107f);
8030path.quadTo(8.7536f, 42.6715f, 9.11249f, 42.9885f);
8031path.conicTo(9.86201f, 43.6505f, 9.20003f, 44.4f, 0.707107f);
8032path.conicTo(8.53805f, 45.1496f, 7.78853f, 44.4876f, 0.707107f);
8033path.close();
8034path.moveTo(5.55855f, 42.2635f);
8035path.quadTo(5.20148f, 41.8614f, 4.86131f, 41.4449f);
8036path.conicTo(4.22883f, 40.6703f, 5.0034f, 40.0378f, 0.707107f);
8037path.conicTo(5.77797f, 39.4053f, 6.41046f, 40.1799f, 0.707107f);
8038path.quadTo(6.72443f, 40.5644f, 7.05403f, 40.9356f);
8039path.conicTo(7.71802f, 41.6833f, 6.97028f, 42.3473f, 0.707107f);
8040path.conicTo(6.22254f, 43.0113f, 5.55855f, 42.2635f, 0.707107f);
8041path.close();
8042path.moveTo(3.55261f, 39.6973f);
8043path.quadTo(3.26341f, 39.2752f, 2.99107f, 38.8422f);
8044path.conicTo(2.45867f, 37.9957f, 3.30517f, 37.4633f, 0.707107f);
8045path.conicTo(4.15167f, 36.9309f, 4.68406f, 37.7774f, 0.707107f);
8046path.quadTo(4.93548f, 38.1772f, 5.20241f, 38.5667f);
8047path.conicTo(5.76769f, 39.3916f, 4.94279f, 39.9569f, 0.707107f);
8048path.conicTo(4.11789f, 40.5222f, 3.55261f, 39.6973f, 0.707107f);
8049path.close();
8050path.moveTo(1.96145f, 37.0509f);
8051path.quadTo(1.71975f, 36.5889f, 1.49677f, 36.1175f);
8052path.conicTo(1.06917f, 35.2135f, 1.97315f, 34.7859f, 0.707107f);
8053path.conicTo(2.87712f, 34.3583f, 3.30471f, 35.2623f, 0.707107f);
8054path.quadTo(3.51053f, 35.6974f, 3.73364f, 36.1239f);
8055path.conicTo(4.19714f, 37.01f, 3.31105f, 37.4735f, 0.707107f);
8056path.conicTo(2.42495f, 37.937f, 1.96145f, 37.0509f, 0.707107f);
8057path.close();
8058path.moveTo(0.676191f, 34.1844f);
8059path.quadTo(0.489621f, 33.6902f, 0.323275f, 33.189f);
8060path.conicTo(0.00831527f, 32.2399f, 0.95742f, 31.9249f, 0.707107f);
8061path.conicTo(1.90653f, 31.6099f, 2.22149f, 32.559f, 0.707107f);
8062path.quadTo(2.37504f, 33.0218f, 2.54726f, 33.4779f);
8063path.conicTo(2.9005f, 34.4134f, 1.96497f, 34.7666f, 0.707107f);
8064path.conicTo(1.02943f, 35.1199f, 0.676191f, 34.1844f, 0.707107f);
8065path.close();
8066path.moveTo(-0.261658f, 31.1521f);
8067path.quadTo(-0.387304f, 30.6362f, -0.491779f, 30.1156f);
8068path.conicTo(-0.68853f, 29.1351f, 0.291923f, 28.9384f, 0.707107f);
8069path.conicTo(1.27238f, 28.7416f, 1.46913f, 29.7221f, 0.707107f);
8070path.quadTo(1.56557f, 30.2026f, 1.68155f, 30.6789f);
8071path.conicTo(1.91817f, 31.6505f, 0.946565f, 31.8871f, 0.707107f);
8072path.conicTo(-0.0250367f, 32.1237f, -0.261658f, 31.1521f, 0.707107f);
8073path.close();
8074path.moveTo(-0.820549f, 28.0495f);
8075path.quadTo(-0.881733f, 27.5314f, -0.922089f, 27.0113f);
8076path.conicTo(-0.999449f, 26.0143f, -0.00244591f, 25.9369f, 0.707107f);
8077path.conicTo(0.994557f, 25.8596f, 1.07192f, 26.8566f, 0.707107f);
8078path.quadTo(1.10917f, 27.3367f, 1.16565f, 27.8149f);
8079path.conicTo(1.28293f, 28.808f, 0.289834f, 28.9253f, 0.707107f);
8080path.conicTo(-0.703265f, 29.0426f, -0.820549f, 28.0495f, 0.707107f);
8081path.close();
8082path.moveTo(-0.999918f, 24.9349f);
8083path.quadTo(-0.998605f, 24.4104f, -0.976138f, 23.8863f);
8084path.conicTo(-0.933305f, 22.8873f, 0.0657772f, 22.9301f, 0.707107f);
8085path.conicTo(1.06486f, 22.9729f, 1.02203f, 23.972f, 0.707107f);
8086path.quadTo(1.00129f, 24.4557f, 1.00008f, 24.9399f);
8087path.conicTo(0.997572f, 25.9399f, -0.0024244f, 25.9374f, 0.707107f);
8088path.conicTo(-1.00242f, 25.9349f, -0.999918f, 24.9349f, 0.707107f);
8089path.close();
8090path.moveTo(-0.802212f, 21.7991f);
8091path.quadTo(-0.738311f, 21.284f, -0.653903f, 20.7719f);
8092path.conicTo(-0.491283f, 19.7852f, 0.495406f, 19.9478f, 0.707107f);
8093path.conicTo(1.48209f, 20.1104f, 1.31948f, 21.0971f, 0.707107f);
8094path.quadTo(1.24156f, 21.5698f, 1.18257f, 22.0453f);
8095path.conicTo(1.05946f, 23.0377f, 0.0670681f, 22.9146f, 0.707107f);
8096path.conicTo(-0.925325f, 22.7915f, -0.802212f, 21.7991f, 0.707107f);
8097path.close();
8098path.moveTo(-0.228066f, 18.7115f);
8099path.quadTo(-0.096172f, 18.1824f, 0.0577899f, 17.6593f);
8100path.conicTo(0.340124f, 16.7f, 1.29944f, 16.9823f, 0.707107f);
8101path.conicTo(2.25876f, 17.2646f, 1.97642f, 18.2239f, 0.707107f);
8102path.quadTo(1.8343f, 18.7068f, 1.71255f, 19.1953f);
8103path.conicTo(1.47069f, 20.1656f, 0.50038f, 19.9237f, 0.707107f);
8104path.conicTo(-0.46993f, 19.6819f, -0.228066f, 18.7115f, 0.707107f);
8105path.close();
8106path.moveTo(0.74831f, 15.6269f);
8107path.quadTo(0.938539f, 15.1347f, 1.14857f, 14.6506f);
8108path.conicTo(1.54662f, 13.7333f, 2.46398f, 14.1313f, 0.707107f);
8109path.conicTo(3.38135f, 14.5294f, 2.9833f, 15.4467f, 0.707107f);
8110path.quadTo(2.78942f, 15.8936f, 2.61382f, 16.3479f);
8111path.conicTo(2.25331f, 17.2806f, 1.32056f, 16.9201f, 0.707107f);
8112path.conicTo(0.387801f, 16.5596f, 0.74831f, 15.6269f, 0.707107f);
8113path.close();
8114path.moveTo(2.04744f, 12.7861f);
8115path.quadTo(2.28569f, 12.3384f, 2.5412f, 11.9003f);
8116path.conicTo(3.04504f, 11.0365f, 3.90884f, 11.5403f, 0.707107f);
8117path.conicTo(4.77264f, 12.0442f, 4.26881f, 12.908f, 0.707107f);
8118path.quadTo(4.03293f, 13.3123f, 3.81302f, 13.7256f);
8119path.conicTo(3.34325f, 14.6084f, 2.46046f, 14.1386f, 0.707107f);
8120path.conicTo(1.57767f, 13.6689f, 2.04744f, 12.7861f, 0.707107f);
8121path.close();
8122path.moveTo(3.60589f, 10.2253f);
8123path.quadTo(3.88812f, 9.81661f, 4.18576f, 9.419f);
8124path.conicTo(4.78503f, 8.61845f, 5.58558f, 9.21772f, 0.707107f);
8125path.conicTo(6.38613f, 9.81699f, 5.78686f, 10.6175f, 0.707107f);
8126path.quadTo(5.51211f, 10.9846f, 5.25159f, 11.3618f);
8127path.conicTo(4.68333f, 12.1847f, 3.86048f, 11.6164f, 0.707107f);
8128path.conicTo(3.03763f, 11.0481f, 3.60589f, 10.2253f, 0.707107f);
8129path.close();
8130path.moveTo(5.46482f, 7.84259f);
8131path.quadTo(5.80682f, 7.4532f, 6.16407f, 7.07773f);
8132path.conicTo(6.85339f, 6.35327f, 7.57785f, 7.04259f, 0.707107f);
8133path.conicTo(8.30231f, 7.73191f, 7.61299f, 8.45636f, 0.707107f);
8134path.quadTo(7.28322f, 8.80295f, 6.96752f, 9.16239f);
8135path.conicTo(6.30762f, 9.91375f, 5.55627f, 9.25385f, 0.707107f);
8136path.conicTo(4.80492f, 8.59395f, 5.46482f, 7.84259f, 0.707107f);
8137path.close();
8138path.moveTo(7.68062f, 5.60827f);
8139path.quadTo(8.08142f, 5.25031f, 8.49666f, 4.90921f);
8140path.conicTo(9.26938f, 4.27447f, 9.90412f, 5.04719f, 0.707107f);
8141path.conicTo(10.5389f, 5.81992f, 9.76614f, 6.45466f, 0.707107f);
8142path.quadTo(9.38285f, 6.76951f, 9.01289f, 7.09994f);
8143path.conicTo(8.26705f, 7.76607f, 7.60092f, 7.02024f, 0.707107f);
8144path.conicTo(6.93479f, 6.2744f, 7.68062f, 5.60827f, 0.707107f);
8145path.close();
8146path.moveTo(10.2392f, 3.59627f);
8147path.quadTo(10.6626f, 3.30433f, 11.0971f, 3.02935f);
8148path.conicTo(11.9421f, 2.49463f, 12.4768f, 3.33965f, 0.707107f);
8149path.conicTo(13.0116f, 4.18467f, 12.1666f, 4.7194f, 0.707107f);
8150path.quadTo(11.7654f, 4.97322f, 11.3747f, 5.24271f);
8151path.conicTo(10.5515f, 5.81043f, 9.98373f, 4.98721f, 0.707107f);
8152path.conicTo(9.41601f, 4.16399f, 10.2392f, 3.59627f, 0.707107f);
8153path.close();
8154path.moveTo(12.8847f, 1.99524f);
8155path.quadTo(13.3459f, 1.75234f, 13.8165f, 1.52812f);
8156path.conicTo(14.7193f, 1.09799f, 15.1494f, 2.00075f, 0.707107f);
8157path.conicTo(15.5795f, 2.90352f, 14.6768f, 3.33365f, 0.707107f);
8158path.quadTo(14.2424f, 3.54063f, 13.8166f, 3.76484f);
8159path.conicTo(12.9318f, 4.23081f, 12.4658f, 3.34601f, 0.707107f);
8160path.conicTo(11.9999f, 2.46122f, 12.8847f, 1.99524f, 0.707107f);
8161path.close();
8162path.moveTo(15.7467f, 0.702339f);
8163path.quadTo(16.2402f, 0.514409f, 16.7409f, 0.346672f);
8164path.conicTo(17.6891f, 0.029011f, 18.0067f, 0.977215f, 0.707107f);
8165path.conicTo(18.3244f, 1.92542f, 17.3762f, 2.24308f, 0.707107f);
8166path.quadTo(16.914f, 2.39792f, 16.4585f, 2.57139f);
8167path.conicTo(15.524f, 2.92729f, 15.1681f, 1.99276f, 0.707107f);
8168path.conicTo(14.8122f, 1.05824f, 15.7467f, 0.702339f, 0.707107f);
8169path.close();
8170path.moveTo(18.7758f, -0.24399f);
8171path.quadTo(19.2913f, -0.371107f, 19.8116f, -0.477061f);
8172path.conicTo(20.7915f, -0.676608f, 20.9911f, 0.303281f, 0.707107f);
8173path.conicTo(21.1906f, 1.28317f, 20.2107f, 1.48272f, 0.707107f);
8174path.quadTo(19.7304f, 1.58052f, 19.2546f, 1.69785f);
8175path.conicTo(18.2836f, 1.93725f, 18.0443f, 0.966329f, 0.707107f);
8176path.conicTo(17.8049f, -0.00459272f, 18.7758f, -0.24399f, 0.707107f);
8177path.close();
8178path.moveTo(21.878f, -0.811882f);
8179path.quadTo(22.396f, -0.874528f, 22.916f, -0.916348f);
8180path.conicTo(23.9128f, -0.996504f, 23.993f, 0.000278629f, 0.707107f);
8181path.conicTo(24.0731f, 0.997061f, 23.0764f, 1.07722f, 0.707107f);
8182path.quadTo(22.5963f, 1.11582f, 22.1182f, 1.17365f);
8183path.conicTo(21.1254f, 1.29372f, 21.0053f, 0.300958f, 0.707107f);
8184path.conicTo(20.8853f, -0.691807f, 21.878f, -0.811882f, 0.707107f);
8185path.close();
8186path.moveTo(24.9926f, -0.999999f);
8187path.quadTo(25.5166f, -1.00015f, 26.0401f, -0.979188f);
8188path.conicTo(27.0393f, -0.939179f, 26.9992f, 0.0600199f, 0.707107f);
8189path.conicTo(26.9592f, 1.05922f, 25.96f, 1.01921f, 0.707107f);
8190path.quadTo(25.4768f, 0.999863f, 24.9932f, 1);
8191path.conicTo(23.9932f, 1.00029f, 23.9929f, 0.000287339f, 0.707107f);
8192path.conicTo(23.9926f, -0.999713f, 24.9926f, -0.999999f, 0.707107f);
8193path.close();
8194path.moveTo(28.1286f, -0.811081f);
8195path.quadTo(28.6441f, -0.748593f, 29.1567f, -0.665572f);
8196path.conicTo(30.1439f, -0.505698f, 29.984f, 0.48144f, 0.707107f);
8197path.conicTo(29.8241f, 1.46858f, 28.837f, 1.3087f, 0.707107f);
8198path.quadTo(28.3638f, 1.23207f, 27.8879f, 1.17439f);
8199path.conicTo(26.8952f, 1.05406f, 27.0155f, 0.0613233f, 0.707107f);
8200path.conicTo(27.1359f, -0.931411f, 28.1286f, -0.811081f, 0.707107f);
8201path.close();
8202path.moveTo(31.214f, -0.246499f);
8203path.quadTo(31.7439f, -0.116076f, 32.2679f, 0.0364622f);
8204path.conicTo(33.228f, 0.315996f, 32.9485f, 1.27613f, 0.707107f);
8205path.conicTo(32.6689f, 2.23627f, 31.7088f, 1.95673f, 0.707107f);
8206path.quadTo(31.2252f, 1.81593f, 30.736f, 1.69554f);
8207path.conicTo(29.765f, 1.45654f, 30.004f, 0.48552f, 0.707107f);
8208path.conicTo(30.243f, -0.485499f, 31.214f, -0.246499f, 0.707107f);
8209path.close();
8210path.moveTo(34.3038f, 0.721629f);
8211path.quadTo(34.797f, 0.910612f, 35.282f, 1.11946f);
8212path.conicTo(36.2005f, 1.51493f, 35.805f, 2.43341f, 0.707107f);
8213path.conicTo(35.4096f, 3.35189f, 34.4911f, 2.95642f, 0.707107f);
8214path.quadTo(34.0434f, 2.76365f, 33.5881f, 2.5892f);
8215path.conicTo(32.6543f, 2.23137f, 33.0122f, 1.29758f, 0.707107f);
8216path.conicTo(33.37f, 0.363796f, 34.3038f, 0.721629f, 0.707107f);
8217path.close();
8218path.moveTo(37.1508f, 2.01396f);
8219path.quadTo(37.5996f, 2.2512f, 38.0388f, 2.50578f);
8220path.conicTo(38.904f, 3.00727f, 38.4025f, 3.87244f, 0.707107f);
8221path.conicTo(37.901f, 4.7376f, 37.0358f, 4.23612f, 0.707107f);
8222path.quadTo(36.6304f, 4.00111f, 36.2161f, 3.78211f);
8223path.conicTo(35.332f, 3.31476f, 35.7994f, 2.43069f, 0.707107f);
8224path.conicTo(36.2667f, 1.54661f, 37.1508f, 2.01396f, 0.707107f);
8225path.close();
8226path.moveTo(39.718f, 3.56681f);
8227path.quadTo(40.1269f, 3.84765f, 40.5249f, 4.14392f);
8228path.conicTo(41.3271f, 4.74104f, 40.73f, 5.54319f, 0.707107f);
8229path.conicTo(40.1329f, 6.34535f, 39.3307f, 5.74823f, 0.707107f);
8230path.quadTo(38.9634f, 5.47478f, 38.5858f, 5.21552f);
8231path.conicTo(37.7615f, 4.64945f, 38.3275f, 3.82509f, 0.707107f);
8232path.conicTo(38.8936f, 3.00074f, 39.718f, 3.56681f, 0.707107f);
8233path.close();
8234path.moveTo(42.1033f, 5.41741f);
8235path.quadTo(42.4933f, 5.75802f, 42.8694f, 6.11388f);
8236path.conicTo(43.5958f, 6.80115f, 42.9085f, 7.52755f, 0.707107f);
8237path.conicTo(42.2212f, 8.25394f, 41.4948f, 7.56667f, 0.707107f);
8238path.quadTo(41.1476f, 7.23817f, 40.7876f, 6.92375f);
8239path.conicTo(40.0345f, 6.26593f, 40.6923f, 5.51275f, 0.707107f);
8240path.conicTo(41.3501f, 4.75958f, 42.1033f, 5.41741f, 0.707107f);
8241path.close();
8242path.moveTo(44.3419f, 7.62498f);
8243path.quadTo(44.7007f, 8.02444f, 45.0428f, 8.43835f);
8244path.conicTo(45.6797f, 9.20922f, 44.9089f, 9.84622f, 0.707107f);
8245path.conicTo(44.138f, 10.4832f, 43.501f, 9.71234f, 0.707107f);
8246path.quadTo(43.1852f, 9.3302f, 42.854f, 8.96151f);
8247path.conicTo(42.1858f, 8.21759f, 42.9297f, 7.54932f, 0.707107f);
8248path.conicTo(43.6736f, 6.88106f, 44.3419f, 7.62498f, 0.707107f);
8249path.close();
8250path.moveTo(46.3599f, 10.1759f);
8251path.quadTo(46.6546f, 10.6005f, 46.9322f, 11.0366f);
8252path.conicTo(47.4693f, 11.8801f, 46.6257f, 12.4172f, 0.707107f);
8253path.conicTo(45.7822f, 12.9542f, 45.2451f, 12.1107f, 0.707107f);
8254path.quadTo(44.9889f, 11.7082f, 44.7168f, 11.3162f);
8255path.conicTo(44.1467f, 10.4947f, 44.9682f, 9.92452f, 0.707107f);
8256path.conicTo(45.7897f, 9.35435f, 46.3599f, 10.1759f, 0.707107f);
8257path.close();
8258path.moveTo(47.9708f, 12.8204f);
8259path.quadTo(48.2149f, 13.2808f, 48.4403f, 13.7506f);
8260path.conicTo(48.873f, 14.6521f, 47.9715f, 15.0848f, 0.707107f);
8261path.conicTo(47.0699f, 15.5174f, 46.6372f, 14.6159f, 0.707107f);
8262path.quadTo(46.4291f, 14.1822f, 46.2038f, 13.7573f);
8263path.conicTo(45.7354f, 12.8738f, 46.6188f, 12.4054f, 0.707107f);
8264path.conicTo(47.5023f, 11.9369f, 47.9708f, 12.8204f, 0.707107f);
8265path.close();
8266path.moveTo(49.2713f, 15.6778f);
8267path.quadTo(49.4606f, 16.1706f, 49.6297f, 16.6708f);
8268path.conicTo(49.9501f, 17.6181f, 49.0028f, 17.9384f, 0.707107f);
8269path.conicTo(48.0555f, 18.2588f, 47.7351f, 17.3115f, 0.707107f);
8270path.quadTo(47.5791f, 16.8499f, 47.4043f, 16.3949f);
8271path.conicTo(47.0458f, 15.4614f, 47.9793f, 15.1029f, 0.707107f);
8272path.conicTo(48.9128f, 14.7443f, 49.2713f, 15.6778f, 0.707107f);
8273path.close();
8274path.moveTo(50.2261f, 18.7037f);
8275path.quadTo(50.3547f, 19.2188f, 50.4621f, 19.7388f);
8276path.conicTo(50.6645f, 20.7182f, 49.6852f, 20.9205f, 0.707107f);
8277path.conicTo(48.7059f, 21.1229f, 48.5035f, 20.1436f, 0.707107f);
8278path.quadTo(48.4043f, 19.6636f, 48.2856f, 19.1881f);
8279path.conicTo(48.0435f, 18.2178f, 49.0137f, 17.9757f, 0.707107f);
8280path.conicTo(49.984f, 17.7335f, 50.2261f, 18.7037f, 0.707107f);
8281path.close();
8282path.moveTo(50.803f, 21.8055f);
8283path.quadTo(50.8671f, 22.3234f, 50.9104f, 22.8434f);
8284path.conicTo(50.9934f, 23.8399f, 49.9968f, 23.9229f, 0.707107f);
8285path.conicTo(49.0002f, 24.0058f, 48.9173f, 23.0093f, 0.707107f);
8286path.quadTo(48.8773f, 22.5293f, 48.8182f, 22.0513f);
8287path.conicTo(48.6953f, 21.0588f, 49.6877f, 20.936f, 0.707107f);
8288path.conicTo(50.6801f, 20.8131f, 50.803f, 21.8055f, 0.707107f);
8289path.close();
8290path.moveTo(50.9999f, 24.9202f);
8291path.quadTo(51.0015f, 25.4434f, 50.982f, 25.9664f);
8292path.conicTo(50.9449f, 26.9657f, 49.9456f, 26.9286f, 0.707107f);
8293path.conicTo(48.9463f, 26.8914f, 48.9834f, 25.8921f, 0.707107f);
8294path.quadTo(49.0014f, 25.4094f, 48.9999f, 24.9263f);
8295path.conicTo(48.9968f, 23.9263f, 49.9968f, 23.9232f, 0.707107f);
8296path.conicTo(50.9968f, 23.9202f, 50.9999f, 24.9202f, 0.707107f);
8297path.close();
8298path.moveTo(50.8198f, 28.0562f);
8299path.quadTo(50.7587f, 28.5721f, 50.677f, 29.0852f);
8300path.conicTo(50.5199f, 30.0728f, 49.5323f, 29.9157f, 0.707107f);
8301path.conicTo(48.5448f, 29.7586f, 48.7019f, 28.771f, 0.707107f);
8302path.quadTo(48.7772f, 28.2974f, 48.8336f, 27.8211f);
8303path.conicTo(48.9512f, 26.8281f, 49.9442f, 26.9456f, 0.707107f);
8304path.conicTo(50.9373f, 27.0632f, 50.8198f, 28.0562f, 0.707107f);
8305path.close();
8306path.moveTo(50.2647f, 31.1395f);
8307path.quadTo(50.1358f, 31.6701f, 49.9847f, 32.1949f);
8308path.conicTo(49.7079f, 33.1558f, 48.747f, 32.8791f, 0.707107f);
8309path.conicTo(47.786f, 32.6024f, 48.0628f, 31.6414f, 0.707107f);
8310path.quadTo(48.2022f, 31.1571f, 48.3213f, 30.6672f);
8311path.conicTo(48.5574f, 29.6955f, 49.5291f, 29.9317f, 0.707107f);
8312path.conicTo(50.5009f, 30.1678f, 50.2647f, 31.1395f, 0.707107f);
8313path.close();
8314path.moveTo(49.3049f, 34.2343f);
8315path.quadTo(49.1171f, 34.7285f, 48.9095f, 35.2145f);
8316path.conicTo(48.5166f, 36.1341f, 47.597f, 35.7412f, 0.707107f);
8317path.conicTo(46.6774f, 35.3483f, 47.0703f, 34.4288f, 0.707107f);
8318path.quadTo(47.262f, 33.9801f, 47.4353f, 33.524f);
8319path.conicTo(47.7904f, 32.5892f, 48.7252f, 32.9444f, 0.707107f);
8320path.conicTo(49.66f, 33.2995f, 49.3049f, 34.2343f, 0.707107f);
8321path.close();
8322path.moveTo(48.0194f, 37.0875f);
8323path.quadTo(47.7831f, 37.5374f, 47.5295f, 37.9777f);
8324path.conicTo(47.0304f, 38.8443f, 46.1638f, 38.3451f, 0.707107f);
8325path.conicTo(45.2973f, 37.846f, 45.7965f, 36.9795f, 0.707107f);
8326path.quadTo(46.0306f, 36.5729f, 46.2487f, 36.1577f);
8327path.conicTo(46.7136f, 35.2723f, 47.5989f, 35.7372f, 0.707107f);
8328path.conicTo(48.4843f, 36.2021f, 48.0194f, 37.0875f, 0.707107f);
8329path.close();
8330path.moveTo(46.4721f, 39.6612f);
8331path.quadTo(46.1926f, 40.0705f, 45.8977f, 40.4688f);
8332path.conicTo(45.3028f, 41.2726f, 44.499f, 40.6776f, 0.707107f);
8333path.conicTo(43.6953f, 40.0827f, 44.2902f, 39.2789f, 0.707107f);
8334path.quadTo(44.5624f, 38.9112f, 44.8204f, 38.5334f);
8335path.conicTo(45.3843f, 37.7075f, 46.2101f, 38.2714f, 0.707107f);
8336path.conicTo(47.036f, 38.8353f, 46.4721f, 39.6612f, 0.707107f);
8337path.close();
8338path.moveTo(44.6298f, 42.0491f);
8339path.quadTo(44.2906f, 42.4396f, 43.9361f, 42.8164f);
8340path.conicTo(43.2509f, 43.5447f, 42.5226f, 42.8595f, 0.707107f);
8341path.conicTo(41.7942f, 42.1742f, 42.4795f, 41.4459f, 0.707107f);
8342path.quadTo(42.8067f, 41.0981f, 43.1198f, 40.7376f);
8343path.conicTo(43.7756f, 39.9826f, 44.5306f, 40.6383f, 0.707107f);
8344path.conicTo(45.2856f, 41.2941f, 44.6298f, 42.0491f, 0.707107f);
8345path.close();
8346path.moveTo(42.4305f, 44.2919f);
8347path.quadTo(42.0324f, 44.6516f, 41.6198f, 44.9946f);
8348path.conicTo(40.8507f, 45.6338f, 40.2115f, 44.8648f, 0.707107f);
8349path.conicTo(39.5723f, 44.0958f, 40.3413f, 43.4566f, 0.707107f);
8350path.quadTo(40.7222f, 43.1399f, 41.0897f, 42.8079f);
8351path.conicTo(41.8317f, 42.1375f, 42.5021f, 42.8795f, 0.707107f);
8352path.conicTo(43.1725f, 43.6215f, 42.4305f, 44.2919f, 0.707107f);
8353path.close();
8354path.moveTo(39.8873f, 46.3159f);
8355path.quadTo(39.4613f, 46.6134f, 39.0238f, 46.8936f);
8356path.conicTo(38.1818f, 47.433f, 37.6424f, 46.5909f, 0.707107f);
8357path.conicTo(37.103f, 45.7489f, 37.9451f, 45.2095f, 0.707107f);
8358path.quadTo(38.3489f, 44.9508f, 38.7421f, 44.6763f);
8359path.conicTo(39.5619f, 44.1037f, 40.1345f, 44.9235f, 0.707107f);
8360path.conicTo(40.7071f, 45.7434f, 39.8873f, 46.3159f, 0.707107f);
8361path.close();
8362path.moveTo(37.2437f, 47.9367f);
8363path.quadTo(36.7842f, 48.182f, 36.3153f, 48.4086f);
8364path.conicTo(35.415f, 48.8439f, 34.9797f, 47.9435f, 0.707107f);
8365path.conicTo(34.5445f, 47.0432f, 35.4449f, 46.608f, 0.707107f);
8366path.quadTo(35.8778f, 46.3987f, 36.3019f, 46.1723f);
8367path.conicTo(37.1841f, 45.7014f, 37.655f, 46.5836f, 0.707107f);
8368path.conicTo(38.1259f, 47.4658f, 37.2437f, 47.9367f, 0.707107f);
8369path.close();
8370path.moveTo(34.3909f, 49.2448f);
8371path.quadTo(33.8988f, 49.4354f, 33.3992f, 49.606f);
8372path.conicTo(32.4528f, 49.929f, 32.1298f, 48.9826f, 0.707107f);
8373path.conicTo(31.8068f, 48.0362f, 32.7532f, 47.7132f, 0.707107f);
8374path.quadTo(33.2142f, 47.5558f, 33.6685f, 47.3798f);
8375path.conicTo(34.601f, 47.0186f, 34.9622f, 47.9511f, 0.707107f);
8376path.conicTo(35.3234f, 48.8836f, 34.3909f, 49.2448f, 0.707107f);
8377path.close();
8378path.moveTo(31.3682f, 50.208f);
8379path.quadTo(30.8535f, 50.3381f, 30.3338f, 50.447f);
8380path.conicTo(29.3551f, 50.6521f, 29.15f, 49.6734f, 0.707107f);
8381path.conicTo(28.9448f, 48.6947f, 29.9236f, 48.4895f, 0.707107f);
8382path.quadTo(30.4033f, 48.389f, 30.8784f, 48.269f);
8383path.conicTo(31.8479f, 48.024f, 32.0929f, 48.9936f, 0.707107f);
8384path.conicTo(32.3378f, 49.9631f, 31.3682f, 50.208f, 0.707107f);
8385path.close();
8386path.moveTo(28.2669f, 50.7939f);
8387path.quadTo(27.7491f, 50.8595f, 27.2292f, 50.9043f);
8388path.conicTo(26.2329f, 50.99f, 26.1472f, 49.9937f, 0.707107f);
8389path.conicTo(26.0615f, 48.9973f, 27.0578f, 48.9116f, 0.707107f);
8390path.quadTo(27.5378f, 48.8703f, 28.0156f, 48.8098f);
8391path.conicTo(29.0077f, 48.6841f, 29.1334f, 49.6762f, 0.707107f);
8392path.conicTo(29.259f, 50.6683f, 28.2669f, 50.7939f, 0.707107f);
8393path.close();
8394path.moveTo(25.1523f, 50.9996f);
8395path.quadTo(24.6297f, 51.0026f, 24.1072f, 50.9847f);
8396path.conicTo(23.1078f, 50.9503f, 23.1422f, 49.9509f, 0.707107f);
8397path.conicTo(23.1765f, 48.9515f, 24.1759f, 48.9858f, 0.707107f);
8398path.quadTo(24.658f, 49.0024f, 25.1406f, 48.9996f);
8399path.conicTo(26.1406f, 48.9937f, 26.1464f, 49.9937f, 0.707107f);
8400path.conicTo(26.1523f, 50.9937f, 25.1523f, 50.9996f, 0.707107f);
8401path.close();
8402path.moveTo(22.0162f, 50.8282f);
8403path.quadTo(21.4999f, 50.7686f, 20.9863f, 50.6883f);
8404path.conicTo(19.9983f, 50.5339f, 20.1527f, 49.5459f, 0.707107f);
8405path.conicTo(20.307f, 48.5579f, 21.295f, 48.7123f, 0.707107f);
8406path.quadTo(21.7691f, 48.7864f, 22.2457f, 48.8414f);
8407path.conicTo(23.2391f, 48.9562f, 23.1243f, 49.9496f, 0.707107f);
8408path.conicTo(23.0096f, 50.943f, 22.0162f, 50.8282f, 0.707107f);
8409path.close();
8410path.moveTo(18.9351f, 50.2827f);
8411path.quadTo(18.4037f, 50.1553f, 17.8782f, 50.0056f);
8412path.conicTo(16.9164f, 49.7317f, 17.1904f, 48.7699f, 0.707107f);
8413path.conicTo(17.4643f, 47.8082f, 18.426f, 48.0821f, 0.707107f);
8414path.quadTo(18.9112f, 48.2203f, 19.4016f, 48.3379f);
8415path.conicTo(20.374f, 48.5712f, 20.1408f, 49.5436f, 0.707107f);
8416path.conicTo(19.9075f, 50.516f, 18.9351f, 50.2827f, 0.707107f);
8417path.close();
8418path.moveTo(15.8352f, 49.3312f);
8419path.quadTo(15.3403f, 49.1448f, 14.8531f, 48.9383f);
8420path.conicTo(13.9324f, 48.548f, 14.3227f, 47.6273f, 0.707107f);
8421path.conicTo(14.713f, 46.7066f, 15.6337f, 47.0969f, 0.707107f);
8422path.quadTo(16.0832f, 47.2874f, 16.5402f, 47.4596f);
8423path.conicTo(17.476f, 47.812f, 17.1235f, 48.7479f, 0.707107f);
8424path.conicTo(16.771f, 49.6837f, 15.8352f, 49.3312f, 0.707107f);
8425path.close();
8426path.moveTo(12.9759f, 48.0526f);
8427path.quadTo(12.5249f, 47.8173f, 12.0835f, 47.5647f);
8428path.conicTo(11.2156f, 47.0679f, 11.7124f, 46.2f, 0.707107f);
8429path.conicTo(12.2092f, 45.3321f, 13.0771f, 45.8289f, 0.707107f);
8430path.quadTo(13.4846f, 46.0622f, 13.9009f, 46.2793f);
8431path.conicTo(14.7875f, 46.7418f, 14.325f, 47.6284f, 0.707107f);
8432path.conicTo(13.8626f, 48.5151f, 12.9759f, 48.0526f, 0.707107f);
8433path.close();
8434path.moveTo(10.3957f, 46.5108f);
8435path.quadTo(9.9861f, 46.2327f, 9.58733f, 45.9392f);
8436path.conicTo(8.78198f, 45.3464f, 9.37478f, 44.541f, 0.707107f);
8437path.conicTo(9.96757f, 43.7357f, 10.7729f, 44.3285f, 0.707107f);
8438path.quadTo(11.141f, 44.5994f, 11.5191f, 44.8561f);
8439path.conicTo(12.3464f, 45.4178f, 11.7847f, 46.2451f, 0.707107f);
8440path.conicTo(11.223f, 47.0725f, 10.3957f, 46.5108f, 0.707107f);
8441path.close();
8442path.moveTo(8.00525f, 44.6769f);
8443path.quadTo(7.6141f, 44.339f, 7.23672f, 43.9859f);
8444path.conicTo(6.50649f, 43.3027f, 7.18969f, 42.5725f, 0.707107f);
8445path.conicTo(7.87289f, 41.8423f, 8.60312f, 42.5255f, 0.707107f);
8446path.quadTo(8.95149f, 42.8514f, 9.31254f, 43.1632f);
8447path.conicTo(10.0693f, 43.8169f, 9.4157f, 44.5737f, 0.707107f);
8448path.conicTo(8.76206f, 45.3305f, 8.00525f, 44.6769f, 0.707107f);
8449path.close();
8450path.moveTo(5.75818f, 42.4858f);
8451path.quadTo(5.39763f, 42.089f, 5.05371f, 41.6777f);
8452path.conicTo(4.41226f, 40.9105f, 5.17942f, 40.2691f, 0.707107f);
8453path.conicTo(5.94658f, 39.6276f, 6.58804f, 40.3948f, 0.707107f);
8454path.quadTo(6.90548f, 40.7744f, 7.23832f, 41.1407f);
8455path.conicTo(7.91085f, 41.8808f, 7.17078f, 42.5533f, 0.707107f);
8456path.conicTo(6.43071f, 43.2258f, 5.75818f, 42.4858f, 0.707107f);
8457path.close();
8458path.moveTo(3.72821f, 39.9503f);
8459path.quadTo(3.42794f, 39.523f, 3.1451f, 39.0842f);
8460path.conicTo(2.6034f, 38.2436f, 3.44397f, 37.7019f, 0.707107f);
8461path.conicTo(4.28454f, 37.1602f, 4.82624f, 38.0008f, 0.707107f);
8462path.quadTo(5.08734f, 38.4059f, 5.3645f, 38.8003f);
8463path.conicTo(5.93951f, 39.6184f, 5.12137f, 40.1934f, 0.707107f);
8464path.conicTo(4.30322f, 40.7684f, 3.72821f, 39.9503f, 0.707107f);
8465path.close();
8466path.moveTo(2.09762f, 37.3078f);
8467path.quadTo(1.85114f, 36.8491f, 1.62324f, 36.381f);
8468path.conicTo(1.18551f, 35.4819f, 2.08461f, 35.0442f, 0.707107f);
8469path.conicTo(2.98372f, 34.6064f, 3.42145f, 35.5055f, 0.707107f);
8470path.quadTo(3.63184f, 35.9377f, 3.85934f, 36.361f);
8471path.conicTo(4.33272f, 37.2419f, 3.45185f, 37.7153f, 0.707107f);
8472path.conicTo(2.57099f, 38.1886f, 2.09762f, 37.3078f, 0.707107f);
8473path.close();
8474path.moveTo(0.781912f, 34.4596f);
8475path.quadTo(0.589924f, 33.9681f, 0.418029f, 33.4692f);
8476path.conicTo(0.0922952f, 32.5237f, 1.03776f, 32.198f, 0.707107f);
8477path.conicTo(1.98322f, 31.8722f, 2.30895f, 32.8177f, 0.707107f);
8478path.quadTo(2.46761f, 33.2782f, 2.64484f, 33.7319f);
8479path.conicTo(3.00867f, 34.6634f, 2.07721f, 35.0272f, 0.707107f);
8480path.conicTo(1.14575f, 35.3911f, 0.781912f, 34.4596f, 0.707107f);
8481path.close();
8482path.moveTo(-0.189761f, 31.4402f);
8483path.quadTo(-0.321263f, 30.9258f, -0.431662f, 30.4065f);
8484path.conicTo(-0.639608f, 29.4284f, 0.338532f, 29.2205f, 0.707107f);
8485path.conicTo(1.31667f, 29.0125f, 1.52462f, 29.9906f, 0.707107f);
8486path.quadTo(1.62653f, 30.47f, 1.74791f, 30.9448f);
8487path.conicTo(1.99561f, 31.9136f, 1.02677f, 32.1613f, 0.707107f);
8488path.conicTo(0.0579369f, 32.409f, -0.189761f, 31.4402f, 0.707107f);
8489path.close();
8490path.moveTo(-0.784658f, 28.3394f);
8491path.quadTo(-0.851693f, 27.8218f, -0.897902f, 27.3019f);
8492path.conicTo(-0.986437f, 26.3058f, 0.00963629f, 26.2173f, 0.707107f);
8493path.conicTo(1.00571f, 26.1288f, 1.09424f, 27.1248f, 0.707107f);
8494path.quadTo(1.1369f, 27.6047f, 1.19878f, 28.0825f);
8495path.conicTo(1.32721f, 29.0742f, 0.335496f, 29.2027f, 0.707107f);
8496path.conicTo(-0.656222f, 29.3311f, -0.784658f, 28.3394f, 0.707107f);
8497path.close();
8498path.moveTo(-0.999031f, 25.2248f);
8499path.quadTo(-1.00354f, 24.7027f, -0.987098f, 24.1809f);
8500path.conicTo(-0.955596f, 23.1814f, 0.0439078f, 23.2129f, 0.707107f);
8501path.conicTo(1.04341f, 23.2444f, 1.01191f, 24.2439f, 0.707107f);
8502path.quadTo(0.996728f, 24.7256f, 1.00089f, 25.2075f);
8503path.conicTo(1.00954f, 26.2075f, 0.00957754f, 26.2161f, 0.707107f);
8504path.conicTo(-0.990385f, 26.2248f, -0.999031f, 25.2248f, 0.707107f);
8505path.close();
8506path.moveTo(-0.836492f, 22.0887f);
8507path.quadTo(-0.778263f, 21.5719f, -0.699419f, 21.0579f);
8508path.conicTo(-0.5478f, 20.0695f, 0.440639f, 20.2211f, 0.707107f);
8509path.conicTo(1.42908f, 20.3727f, 1.27746f, 21.3612f, 0.707107f);
8510path.quadTo(1.20468f, 21.8356f, 1.15093f, 22.3126f);
8511path.conicTo(1.03896f, 23.3063f, 0.0452449f, 23.1944f, 0.707107f);
8512path.conicTo(-0.948466f, 23.0824f, -0.836492f, 22.0887f, 0.707107f);
8513path.close();
8514path.moveTo(-0.300548f, 19.0098f);
8515path.quadTo(-0.174573f, 18.4777f, -0.0263361f, 17.9514f);
8516path.conicTo(0.244762f, 16.9889f, 1.20731f, 17.26f, 0.707107f);
8517path.conicTo(2.16987f, 17.5311f, 1.89877f, 18.4936f, 0.707107f);
8518path.quadTo(1.76193f, 18.9794f, 1.64565f, 19.4706f);
8519path.conicTo(1.41526f, 20.4437f, 0.442159f, 20.2133f, 0.707107f);
8520path.conicTo(-0.530939f, 19.9829f, -0.300548f, 19.0098f, 0.707107f);
8521path.close();
8522path.moveTo(0.642658f, 15.9049f);
8523path.quadTo(0.827861f, 15.409f, 1.0331f, 14.9209f);
8524path.conicTo(1.42076f, 13.9991f, 2.34256f, 14.3868f, 0.707107f);
8525path.conicTo(3.26437f, 14.7744f, 2.87671f, 15.6962f, 0.707107f);
8526path.quadTo(2.68726f, 16.1467f, 2.5163f, 16.6046f);
8527path.conicTo(2.16648f, 17.5414f, 1.22967f, 17.1916f, 0.707107f);
8528path.conicTo(0.292846f, 16.8418f, 0.642658f, 15.9049f, 0.707107f);
8529path.close();
8530path.moveTo(1.91434f, 13.0395f);
8531path.quadTo(2.14856f, 12.5875f, 2.40031f, 12.1449f);
8532path.conicTo(2.89473f, 11.2757f, 3.76395f, 11.7701f, 0.707107f);
8533path.conicTo(4.63317f, 12.2645f, 4.13875f, 13.1337f, 0.707107f);
8534path.quadTo(3.90637f, 13.5423f, 3.69016f, 13.9596f);
8535path.conicTo(3.23014f, 14.8475f, 2.34223f, 14.3875f, 0.707107f);
8536path.conicTo(1.45432f, 13.9275f, 1.91434f, 13.0395f, 0.707107f);
8537path.close();
8538path.moveTo(3.45073f, 10.4525f);
8539path.quadTo(3.72744f, 10.0426f, 4.01954f, 9.64356f);
8540path.conicTo(4.61017f, 8.83661f, 5.41711f, 9.42725f, 0.707107f);
8541path.conicTo(6.22405f, 10.0179f, 5.63342f, 10.8248f, 0.707107f);
8542path.quadTo(5.36379f, 11.1932f, 5.10836f, 11.5716f);
8543path.conicTo(4.54884f, 12.4004f, 3.72003f, 11.8409f, 0.707107f);
8544path.conicTo(2.89121f, 11.2813f, 3.45073f, 10.4525f, 0.707107f);
8545path.close();
8546path.moveTo(5.2763f, 8.05964f);
8547path.quadTo(5.61273f, 7.66793f, 5.96445f, 7.2899f);
8548path.conicTo(6.6456f, 6.55776f, 7.37774f, 7.23892f, 0.707107f);
8549path.conicTo(8.10988f, 7.92008f, 7.42872f, 8.65221f, 0.707107f);
8550path.quadTo(7.10407f, 9.00116f, 6.79351f, 9.36274f);
8551path.conicTo(6.14196f, 10.1213f, 5.38336f, 9.46979f, 0.707107f);
8552path.conicTo(4.62475f, 8.81824f, 5.2763f, 8.05964f, 0.707107f);
8553path.close();
8554path.moveTo(7.45913f, 5.80839f);
8555path.quadTo(7.85457f, 5.44696f, 8.26455f, 5.10214f);
8556path.conicTo(9.02985f, 4.45847f, 9.67352f, 5.22377f, 0.707107f);
8557path.conicTo(10.3172f, 5.98907f, 9.5519f, 6.63274f, 0.707107f);
8558path.quadTo(9.17345f, 6.95105f, 8.80843f, 7.28467f);
8559path.conicTo(8.07029f, 7.95931f, 7.39564f, 7.22117f, 0.707107f);
8560path.conicTo(6.72099f, 6.48303f, 7.45913f, 5.80839f, 0.707107f);
8561path.close();
8562path.moveTo(9.98688f, 3.77251f);
8563path.quadTo(10.4153f, 3.46948f, 10.8557f, 3.18397f);
8564path.conicTo(11.6948f, 2.63996f, 12.2388f, 3.47904f, 0.707107f);
8565path.conicTo(12.7828f, 4.31812f, 11.9437f, 4.86213f, 0.707107f);
8566path.quadTo(11.5373f, 5.12566f, 11.1417f, 5.40539f);
8567path.conicTo(10.3253f, 5.98282f, 9.74787f, 5.16638f, 0.707107f);
8568path.conicTo(9.17044f, 4.34994f, 9.98688f, 3.77251f, 0.707107f);
8569path.close();
8570path.moveTo(12.6283f, 2.13208f);
8571path.quadTo(13.0861f, 1.88442f, 13.5534f, 1.65529f);
8572path.conicTo(14.4513f, 1.21504f, 14.8915f, 2.11291f, 0.707107f);
8573path.conicTo(15.3318f, 3.01078f, 14.4339f, 3.45104f, 0.707107f);
8574path.quadTo(14.0025f, 3.66255f, 13.58f, 3.89115f);
8575path.conicTo(12.7005f, 4.36698f, 12.2246f, 3.48744f, 0.707107f);
8576path.conicTo(11.7488f, 2.60791f, 12.6283f, 2.13208f, 0.707107f);
8577path.close();
8578path.moveTo(15.4718f, 0.808815f);
8579path.quadTo(15.9627f, 0.615476f, 16.461f, 0.442208f);
8580path.conicTo(17.4055f, 0.113784f, 17.7339f, 1.05831f, 0.707107f);
8581path.conicTo(18.0624f, 2.00284f, 17.1178f, 2.33127f, 0.707107f);
8582path.quadTo(16.6578f, 2.49121f, 16.2047f, 2.66968f);
8583path.conicTo(15.2743f, 3.03614f, 14.9078f, 2.10571f, 0.707107f);
8584path.conicTo(14.5414f, 1.17528f, 15.4718f, 0.808815f, 0.707107f);
8585path.close();
8586path.moveTo(18.4879f, -0.171272f);
8587path.quadTo(19.0019f, -0.304236f, 19.5208f, -0.416111f);
8588path.conicTo(20.4984f, -0.62685f, 20.7091f, 0.350692f, 0.707107f);
8589path.conicTo(20.9198f, 1.32823f, 19.9423f, 1.53897f, 0.707107f);
8590path.quadTo(19.4633f, 1.64224f, 18.9889f, 1.76498f);
8591path.conicTo(18.0207f, 2.01544f, 17.7703f, 1.04732f, 0.707107f);
8592path.conicTo(17.5198f, 0.0791926f, 18.4879f, -0.171272f, 0.707107f);
8593path.close();
8594path.moveTo(21.5882f, -0.77517f);
8595path.quadTo(22.1056f, -0.843665f, 22.6254f, -0.891339f);
8596path.conicTo(23.6212f, -0.982672f, 23.7126f, 0.0131486f, 0.707107f);
8597path.conicTo(23.8039f, 1.00897f, 22.8081f, 1.1003f, 0.707107f);
8598path.quadTo(22.3283f, 1.14431f, 21.8506f, 1.20754f);
8599path.conicTo(20.8592f, 1.33876f, 20.728f, 0.347405f, 0.707107f);
8600path.conicTo(20.5968f, -0.643948f, 21.5882f, -0.77517f, 0.707107f);
8601path.close();
8602path.moveTo(24.7026f, -0.998301f);
8603path.quadTo(25.2241f, -1.00426f, 25.7453f, -0.989316f);
8604path.conicTo(26.7449f, -0.960651f, 26.7162f, 0.0389383f, 0.707107f);
8605path.conicTo(26.6876f, 1.03853f, 25.688f, 1.00986f, 0.707107f);
8606path.quadTo(25.2068f, 0.996064f, 24.7255f, 1.00157f);
8607path.conicTo(23.7256f, 1.013f, 23.7141f, 0.0130688f, 0.707107f);
8608path.conicTo(23.7027f, -0.986866f, 24.7026f, -0.998301f, 0.707107f);
8609path.close();
8610path.moveTo(27.8388f, -0.844563f);
8611path.quadTo(28.3559f, -0.787759f, 28.8704f, -0.710314f);
8612path.conicTo(29.8592f, -0.561454f, 29.7104f, 0.427404f, 0.707107f);
8613path.conicTo(29.5615f, 1.41626f, 28.5726f, 1.2674f, 0.707107f);
8614path.quadTo(28.0978f, 1.19591f, 27.6204f, 1.14348f);
8615path.conicTo(26.6264f, 1.0343f, 26.7356f, 0.0402742f, 0.707107f);
8616path.conicTo(26.8447f, -0.953747f, 27.8388f, -0.844563f, 0.707107f);
8617path.close();
8618path.moveTo(30.9153f, -0.318153f);
8619path.quadTo(31.4481f, -0.193671f, 31.9752f, -0.046875f);
8620path.conicTo(32.9386f, 0.221405f, 32.6703f, 1.18475f, 0.707107f);
8621path.conicTo(32.402f, 2.14809f, 31.4387f, 1.87981f, 0.707107f);
8622path.quadTo(30.9521f, 1.74431f, 30.4603f, 1.6294f);
8623path.conicTo(29.4865f, 1.40189f, 29.714f, 0.428111f, 0.707107f);
8624path.conicTo(29.9416f, -0.545664f, 30.9153f, -0.318153f, 0.707107f);
8625path.close();
8626path.moveTo(34.0252f, 0.616677f);
8627path.quadTo(34.5221f, 0.800609f, 35.0111f, 1.00465f);
8628path.conicTo(35.934f, 1.3897f, 35.549f, 2.31259f, 0.707107f);
8629path.conicTo(35.1639f, 3.23549f, 34.241f, 2.85044f, 0.707107f);
8630path.quadTo(33.7896f, 2.66211f, 33.3309f, 2.49232f);
8631path.conicTo(32.3931f, 2.1452f, 32.7402f, 1.20738f, 0.707107f);
8632path.conicTo(33.0873f, 0.269559f, 34.0252f, 0.616677f, 0.707107f);
8633path.close();
8634path.moveTo(36.8967f, 1.88141f);
8635path.quadTo(37.3499f, 2.11462f, 37.7936f, 2.3654f);
8636path.conicTo(38.6641f, 2.85746f, 38.1721f, 3.72802f, 0.707107f);
8637path.conicTo(37.68f, 4.59858f, 36.8094f, 4.10652f, 0.707107f);
8638path.quadTo(36.3999f, 3.87504f, 35.9815f, 3.65976f);
8639path.conicTo(35.0924f, 3.2022f, 35.5499f, 2.31302f, 0.707107f);
8640path.conicTo(36.0075f, 1.42384f, 36.8967f, 1.88141f, 0.707107f);
8641path.close();
8642path.moveTo(39.4914f, 3.413f);
8643path.lineTo(39.5381f, 3.44439f);
8644path.quadTo(39.9244f, 3.70494f, 40.3002f, 3.97845f);
8645path.conicTo(41.1087f, 4.56692f, 40.5202f, 5.37544f, 0.707107f);
8646path.conicTo(39.9317f, 6.18396f, 39.1232f, 5.59549f, 0.707107f);
8647path.quadTo(38.7763f, 5.34298f, 38.4215f, 5.10371f);
8648path.lineTo(38.3749f, 5.07232f);
8649path.conicTo(37.5452f, 4.51406f, 38.1035f, 3.68439f, 0.707107f);
8650path.conicTo(38.6618f, 2.85473f, 39.4914f, 3.413f, 0.707107f);
8651path.close();
8652path.moveTo(41.8859f, 5.22965f);
8653path.quadTo(42.2782f, 5.56471f, 42.6568f, 5.91499f);
8654path.conicTo(43.3908f, 6.5941f, 42.7117f, 7.32814f, 0.707107f);
8655path.conicTo(42.0326f, 8.06218f, 41.2986f, 7.38308f, 0.707107f);
8656path.quadTo(40.949f, 7.05968f, 40.587f, 6.75043f);
8657path.conicTo(39.8266f, 6.10097f, 40.476f, 5.34058f, 0.707107f);
8658path.conicTo(41.1255f, 4.58018f, 41.8859f, 5.22965f, 0.707107f);
8659path.close();
8660path.moveTo(44.1413f, 7.40421f);
8661path.quadTo(44.5035f, 7.79829f, 44.8493f, 8.20695f);
8662path.conicTo(45.4952f, 8.97038f, 44.7317f, 9.61627f, 0.707107f);
8663path.conicTo(43.9683f, 10.2622f, 43.3224f, 9.49874f, 0.707107f);
8664path.quadTo(43.0033f, 9.1215f, 42.6689f, 8.75773f);
8665path.conicTo(41.9921f, 8.02152f, 42.7283f, 7.34476f, 0.707107f);
8666path.conicTo(43.4645f, 6.668f, 44.1413f, 7.40421f, 0.707107f);
8667path.close();
8668path.moveTo(46.183f, 9.9242f);
8669path.quadTo(46.4888f, 10.3539f, 46.777f, 10.7957f);
8670path.conicTo(47.3233f, 11.6332f, 46.4857f, 12.1796f, 0.707107f);
8671path.conicTo(45.6482f, 12.7259f, 45.1018f, 11.8883f, 0.707107f);
8672path.quadTo(44.8358f, 11.4805f, 44.5535f, 11.0839f);
8673path.conicTo(43.9737f, 10.2691f, 44.7884f, 9.6893f, 0.707107f);
8674path.conicTo(45.6032f, 9.10947f, 46.183f, 9.9242f, 0.707107f);
8675path.close();
8676path.moveTo(47.8333f, 12.5645f);
8677path.quadTo(48.0821f, 13.0214f, 48.3125f, 13.4879f);
8678path.conicTo(48.7552f, 14.3845f, 47.8586f, 14.8273f, 0.707107f);
8679path.conicTo(46.962f, 15.2701f, 46.5192f, 14.3734f, 0.707107f);
8680path.quadTo(46.3065f, 13.9428f, 46.0769f, 13.5211f);
8681path.conicTo(45.5986f, 12.6429f, 46.4768f, 12.1646f, 0.707107f);
8682path.conicTo(47.355f, 11.6863f, 47.8333f, 12.5645f, 0.707107f);
8683path.close();
8684path.moveTo(49.1641f, 15.4033f);
8685path.quadTo(49.3588f, 15.8935f, 49.5334f, 16.3912f);
8686path.conicTo(49.8645f, 17.3348f, 48.9209f, 17.6659f, 0.707107f);
8687path.conicTo(47.9773f, 17.997f, 47.6462f, 17.0534f, 0.707107f);
8688path.quadTo(47.485f, 16.5939f, 47.3053f, 16.1415f);
8689path.conicTo(46.9362f, 15.2121f, 47.8656f, 14.843f, 0.707107f);
8690path.conicTo(48.795f, 14.4739f, 49.1641f, 15.4033f, 0.707107f);
8691path.close();
8692path.moveTo(50.1526f, 18.4161f);
8693path.quadTo(50.287f, 18.9296f, 50.4003f, 19.4482f);
8694path.conicTo(50.6139f, 20.4252f, 49.6369f, 20.6387f, 0.707107f);
8695path.conicTo(48.66f, 20.8522f, 48.4465f, 19.8753f, 0.707107f);
8696path.quadTo(48.3419f, 19.3966f, 48.2178f, 18.9225f);
8697path.conicTo(47.9645f, 17.9551f, 48.9319f, 17.7019f, 0.707107f);
8698path.conicTo(49.8993f, 17.4487f, 50.1526f, 18.4161f, 0.707107f);
8699path.close();
8700path.moveTo(50.7655f, 21.5157f);
8701path.quadTo(50.8354f, 22.033f, 50.8846f, 22.5528f);
8702path.conicTo(50.9787f, 23.5483f, 49.9831f, 23.6425f, 0.707107f);
8703path.conicTo(48.9876f, 23.7366f, 48.8935f, 22.741f, 0.707107f);
8704path.quadTo(48.8481f, 22.2613f, 48.7835f, 21.7837f);
8705path.conicTo(48.6495f, 20.7928f, 49.6405f, 20.6587f, 0.707107f);
8706path.conicTo(50.6315f, 20.5247f, 50.7655f, 21.5157f, 0.707107f);
8707path.close();
8708path.moveTo(50.9974f, 24.6301f);
8709path.quadTo(51.0048f, 25.1509f, 50.9913f, 25.6715f);
8710path.conicTo(50.9655f, 26.6712f, 49.9658f, 26.6454f, 0.707107f);
8711path.conicTo(48.9662f, 26.6196f, 48.992f, 25.6199f, 0.707107f);
8712path.quadTo(49.0044f, 25.1393f, 48.9976f, 24.6585f);
8713path.conicTo(48.9834f, 23.6586f, 49.9833f, 23.6444f, 0.707107f);
8714path.conicTo(50.9832f, 23.6302f, 50.9974f, 24.6301f, 0.707107f);
8715path.close();
8716path.moveTo(50.8524f, 27.7662f);
8717path.quadTo(50.7971f, 28.2837f, 50.721f, 28.7986f);
8718path.conicTo(50.5749f, 29.7879f, 49.5856f, 29.6418f, 0.707107f);
8719path.conicTo(48.5963f, 29.4957f, 48.7425f, 28.5064f, 0.707107f);
8720path.quadTo(48.8127f, 28.0311f, 48.8638f, 27.5534f);
8721path.conicTo(48.9702f, 26.5591f, 49.9645f, 26.6655f, 0.707107f);
8722path.conicTo(50.9588f, 26.7718f, 50.8524f, 27.7662f, 0.707107f);
8723path.close();
8724path.moveTo(50.3355f, 30.8404f);
8725path.quadTo(50.2125f, 31.3739f, 50.0672f, 31.9018f);
8726path.conicTo(49.8018f, 32.8659f, 48.8376f, 32.6005f, 0.707107f);
8727path.conicTo(47.8735f, 32.335f, 48.139f, 31.3709f, 0.707107f);
8728path.quadTo(48.2731f, 30.8836f, 48.3867f, 30.3912f);
8729path.conicTo(48.6113f, 29.4167f, 49.5857f, 29.6413f, 0.707107f);
8730path.conicTo(50.5602f, 29.866f, 50.3355f, 30.8404f, 0.707107f);
8731path.close();
8732path.moveTo(49.4091f, 33.9552f);
8733path.quadTo(49.2264f, 34.4531f, 49.0236f, 34.9431f);
8734path.conicTo(48.6412f, 35.8671f, 47.7172f, 35.4846f, 0.707107f);
8735path.conicTo(46.7932f, 35.1022f, 47.1757f, 34.1782f, 0.707107f);
8736path.quadTo(47.3629f, 33.7259f, 47.5315f, 33.2663f);
8737path.conicTo(47.8759f, 32.3275f, 48.8147f, 32.672f, 0.707107f);
8738path.conicTo(49.7535f, 33.0164f, 49.4091f, 33.9552f, 0.707107f);
8739path.close();
8740path.moveTo(48.1514f, 36.8328f);
8741path.quadTo(47.9191f, 37.2871f, 47.6694f, 37.7318f);
8742path.conicTo(47.1797f, 38.6038f, 46.3078f, 38.1141f, 0.707107f);
8743path.conicTo(45.4359f, 37.6244f, 45.9256f, 36.7525f, 0.707107f);
8744path.quadTo(46.1562f, 36.3418f, 46.3705f, 35.9226f);
8745path.conicTo(46.8256f, 35.0321f, 47.716f, 35.4872f, 0.707107f);
8746path.conicTo(48.6065f, 35.9423f, 48.1514f, 36.8328f, 0.707107f);
8747path.close();
8748path.moveTo(46.6245f, 39.4354f);
8749path.lineTo(46.5563f, 39.537f);
8750path.quadTo(46.3146f, 39.8955f, 46.0624f, 40.2438f);
8751path.conicTo(45.4761f, 41.0539f, 44.666f, 40.4676f, 0.707107f);
8752path.conicTo(43.8559f, 39.8813f, 44.4422f, 39.0712f, 0.707107f);
8753path.quadTo(44.6749f, 38.7498f, 44.8955f, 38.4226f);
8754path.lineTo(44.9637f, 38.3211f);
8755path.conicTo(45.5209f, 37.4907f, 46.3513f, 38.0479f, 0.707107f);
8756path.conicTo(47.1817f, 38.605f, 46.6245f, 39.4354f, 0.707107f);
8757path.close();
8758path.moveTo(44.8168f, 41.8314f);
8759path.quadTo(44.4832f, 42.2241f, 44.1342f, 42.6034f);
8760path.conicTo(43.4572f, 43.3394f, 42.7212f, 42.6623f, 0.707107f);
8761path.conicTo(41.9853f, 41.9853f, 42.6623f, 41.2494f, 0.707107f);
8762path.quadTo(42.9845f, 40.8992f, 43.2924f, 40.5366f);
8763path.conicTo(43.9398f, 39.7745f, 44.702f, 40.4218f, 0.707107f);
8764path.conicTo(45.4642f, 41.0692f, 44.8168f, 41.8314f, 0.707107f);
8765path.close();
8766path.moveTo(42.6505f, 44.0908f);
8767path.quadTo(42.2577f, 44.454f, 41.8504f, 44.8006f);
8768path.conicTo(41.0888f, 45.4487f, 40.4408f, 44.6871f, 0.707107f);
8769path.conicTo(39.7927f, 43.9256f, 40.5542f, 43.2775f, 0.707107f);
8770path.quadTo(40.9302f, 42.9575f, 41.2928f, 42.6223f);
8771path.conicTo(42.027f, 41.9434f, 42.7059f, 42.6777f, 0.707107f);
8772path.conicTo(43.3848f, 43.412f, 42.6505f, 44.0908f, 0.707107f);
8773path.close();
8774path.moveTo(40.1383f, 46.1384f);
8775path.quadTo(39.7073f, 46.4471f, 39.2641f, 46.7378f);
8776path.conicTo(38.4281f, 47.2865f, 37.8795f, 46.4504f, 0.707107f);
8777path.conicTo(37.3308f, 45.6143f, 38.1669f, 45.0657f, 0.707107f);
8778path.quadTo(38.576f, 44.7972f, 38.9738f, 44.5124f);
8779path.conicTo(39.7868f, 43.9301f, 40.369f, 44.7432f, 0.707107f);
8780path.conicTo(40.9513f, 45.5562f, 40.1383f, 46.1384f, 0.707107f);
8781path.close();
8782path.moveTo(37.4991f, 47.7985f);
8783path.quadTo(37.0431f, 48.0485f, 36.5775f, 48.2801f);
8784path.conicTo(35.6821f, 48.7254f, 35.2368f, 47.83f, 0.707107f);
8785path.conicTo(34.7915f, 46.9346f, 35.6869f, 46.4893f, 0.707107f);
8786path.quadTo(36.1167f, 46.2755f, 36.5376f, 46.0448f);
8787path.conicTo(37.4145f, 45.5641f, 37.8952f, 46.4409f, 0.707107f);
8788path.conicTo(38.376f, 47.3178f, 37.4991f, 47.7985f, 0.707107f);
8789path.close();
8790path.moveTo(34.6651f, 49.1368f);
8791path.quadTo(34.1756f, 49.3328f, 33.6785f, 49.5089f);
8792path.conicTo(32.7358f, 49.8427f, 32.402f, 48.9f, 0.707107f);
8793path.conicTo(32.0682f, 47.9574f, 33.0109f, 47.6236f, 0.707107f);
8794path.quadTo(33.4697f, 47.4611f, 33.9216f, 47.2801f);
8795path.conicTo(34.85f, 46.9084f, 35.2217f, 47.8368f, 0.707107f);
8796path.conicTo(35.5934f, 48.7651f, 34.6651f, 49.1368f, 0.707107f);
8797path.close();
8798path.moveTo(31.6557f, 50.1337f);
8799path.quadTo(31.1425f, 50.2696f, 30.6243f, 50.3844f);
8800path.conicTo(29.648f, 50.6007f, 29.4317f, 49.6244f, 0.707107f);
8801path.conicTo(29.2153f, 48.6481f, 30.1917f, 48.4317f, 0.707107f);
8802path.quadTo(30.6701f, 48.3257f, 31.1437f, 48.2003f);
8803path.conicTo(32.1104f, 47.9443f, 32.3664f, 48.911f, 0.707107f);
8804path.conicTo(32.6223f, 49.8777f, 31.6557f, 50.1337f, 0.707107f);
8805path.close();
8806path.moveTo(28.5567f, 50.7556f);
8807path.quadTo(28.0395f, 50.827f, 27.5198f, 50.8776f);
8808path.conicTo(26.5245f, 50.9745f, 26.4276f, 49.9792f, 0.707107f);
8809path.conicTo(26.3307f, 48.9839f, 27.326f, 48.887f, 0.707107f);
8810path.quadTo(27.8056f, 48.8403f, 28.2831f, 48.7744f);
8811path.conicTo(29.2737f, 48.6376f, 29.4105f, 49.6282f, 0.707107f);
8812path.conicTo(29.5473f, 50.6188f, 28.5567f, 50.7556f, 0.707107f);
8813path.close();
8814path.moveTo(25.4424f, 50.9962f);
8815path.quadTo(24.9222f, 51.0051f, 24.4022f, 50.9931f);
8816path.conicTo(23.4025f, 50.9701f, 23.4255f, 49.9704f, 0.707107f);
8817path.conicTo(23.4485f, 48.9707f, 24.4482f, 48.9937f, 0.707107f);
8818path.quadTo(24.9283f, 49.0047f, 25.4084f, 48.9965f);
8819path.conicTo(26.4083f, 48.9795f, 26.4253f, 49.9794f, 0.707107f);
8820path.conicTo(26.4423f, 50.9792f, 25.4424f, 50.9962f, 0.707107f);
8821path.close();
8822path.moveTo(22.3065f, 50.8601f);
8823path.quadTo(21.7885f, 50.8062f, 21.2732f, 50.7315f);
8824path.conicTo(20.2835f, 50.5882f, 20.4268f, 49.5985f, 0.707107f);
8825path.conicTo(20.5702f, 48.6088f, 21.5599f, 48.7522f, 0.707107f);
8826path.quadTo(22.0355f, 48.8211f, 22.5136f, 48.8709f);
8827path.conicTo(23.5083f, 48.9745f, 23.4047f, 49.9691f, 0.707107f);
8828path.conicTo(23.3011f, 50.9637f, 22.3065f, 50.8601f, 0.707107f);
8829path.close();
8830path.moveTo(19.2346f, 50.3527f);
8831path.quadTo(18.7003f, 50.2312f, 18.1717f, 50.0873f);
8832path.conicTo(17.2068f, 49.8247f, 17.4694f, 48.8598f, 0.707107f);
8833path.conicTo(17.732f, 47.8949f, 18.6969f, 48.1575f, 0.707107f);
8834path.quadTo(19.185f, 48.2904f, 19.6781f, 48.4025f);
8835path.conicTo(20.6532f, 48.6243f, 20.4314f, 49.5994f, 0.707107f);
8836path.conicTo(20.2097f, 50.5745f, 19.2346f, 50.3527f, 0.707107f);
8837path.close();
8838path.moveTo(16.1149f, 49.4347f);
8839path.quadTo(15.6161f, 49.2533f, 15.1251f, 49.0517f);
8840path.conicTo(14.2f, 48.6719f, 14.5798f, 47.7469f, 0.707107f);
8841path.conicTo(14.9596f, 46.8218f, 15.8847f, 47.2016f, 0.707107f);
8842path.quadTo(16.3379f, 47.3877f, 16.7984f, 47.5551f);
8843path.conicTo(17.7382f, 47.8969f, 17.3964f, 48.8366f, 0.707107f);
8844path.conicTo(17.0547f, 49.7764f, 16.1149f, 49.4347f, 0.707107f);
8845path.close();
8846path.moveTo(13.2313f, 48.184f);
8847path.quadTo(12.776f, 47.9529f, 12.33f, 47.704f);
8848path.conicTo(11.4568f, 47.2167f, 11.9441f, 46.3434f, 0.707107f);
8849path.conicTo(12.4314f, 45.4702f, 13.3046f, 45.9575f, 0.707107f);
8850path.quadTo(13.7162f, 46.1872f, 14.1365f, 46.4006f);
8851path.conicTo(15.0282f, 46.8532f, 14.5756f, 47.7449f, 0.707107f);
8852path.conicTo(14.123f, 48.6366f, 13.2313f, 48.184f, 0.707107f);
8853path.close();
8854path.moveTo(10.6208f, 46.6619f);
8855path.lineTo(10.4641f, 46.5571f);
8856path.quadTo(10.1333f, 46.334f, 9.81253f, 46.1031f);
8857path.conicTo(9.00087f, 45.519f, 9.585f, 44.7073f, 0.707107f);
8858path.conicTo(10.1691f, 43.8957f, 10.9808f, 44.4798f, 0.707107f);
8859path.quadTo(11.2769f, 44.6929f, 11.5763f, 44.8948f);
8860path.lineTo(11.7329f, 44.9996f);
8861path.conicTo(12.564f, 45.5557f, 12.008f, 46.3868f, 0.707107f);
8862path.conicTo(11.4519f, 47.2179f, 10.6208f, 46.6619f, 0.707107f);
8863path.close();
8864path.moveTo(8.22326f, 44.8631f);
8865path.quadTo(7.82986f, 44.5308f, 7.44999f, 44.1833f);
8866path.conicTo(6.71217f, 43.5082f, 7.38718f, 42.7704f, 0.707107f);
8867path.conicTo(8.06219f, 42.0326f, 8.8f, 42.7076f, 0.707107f);
8868path.quadTo(9.15066f, 43.0284f, 9.51375f, 43.3351f);
8869path.conicTo(10.2777f, 43.9804f, 9.63248f, 44.7443f, 0.707107f);
8870path.conicTo(8.98724f, 45.5083f, 8.22326f, 44.8631f, 0.707107f);
8871path.close();
8872path.moveTo(5.95972f, 42.705f);
8873path.quadTo(5.59577f, 42.3136f, 5.24823f, 41.9076f);
8874path.conicTo(4.59793f, 41.148f, 5.3576f, 40.4977f, 0.707107f);
8875path.conicTo(6.11728f, 39.8473f, 6.76758f, 40.607f, 0.707107f);
8876path.quadTo(7.08843f, 40.9818f, 7.42436f, 41.3431f);
8877path.conicTo(8.10532f, 42.0754f, 7.373f, 42.7564f, 0.707107f);
8878path.conicTo(6.64068f, 43.4373f, 5.95972f, 42.705f, 0.707107f);
8879path.close();
8880path.moveTo(3.90635f, 40.2006f);
8881path.quadTo(3.59492f, 39.7684f, 3.30147f, 39.3239f);
8882path.conicTo(2.75055f, 38.4893f, 3.58511f, 37.9384f, 0.707107f);
8883path.conicTo(4.41967f, 37.3875f, 4.97059f, 38.222f, 0.707107f);
8884path.quadTo(5.24148f, 38.6324f, 5.52894f, 39.0313f);
8885path.conicTo(6.11358f, 39.8426f, 5.30228f, 40.4272f, 0.707107f);
8886path.conicTo(4.49099f, 41.0119f, 3.90635f, 40.2006f, 0.707107f);
8887path.close();
8888path.moveTo(2.23643f, 37.5626f);
8889path.quadTo(1.98525f, 37.1075f, 1.75248f, 36.6427f);
8890path.conicTo(1.30469f, 35.7486f, 2.19883f, 35.3008f, 0.707107f);
8891path.conicTo(3.09296f, 34.853f, 3.54076f, 35.7471f, 0.707107f);
8892path.quadTo(3.75563f, 36.1762f, 3.98747f, 36.5963f);
8893path.conicTo(4.47065f, 37.4718f, 3.59513f, 37.955f, 0.707107f);
8894path.conicTo(2.71961f, 38.4382f, 2.23643f, 37.5626f, 0.707107f);
8895path.close();
8896path.moveTo(0.890647f, 34.7334f);
8897path.quadTo(0.69328f, 34.2445f, 0.515902f, 33.7481f);
8898path.conicTo(0.179435f, 32.8064f, 1.12113f, 32.4699f, 0.707107f);
8899path.conicTo(2.06282f, 32.1335f, 2.39929f, 33.0752f, 0.707107f);
8900path.quadTo(2.56303f, 33.5334f, 2.74521f, 33.9847f);
8901path.conicTo(3.11957f, 34.912f, 2.19229f, 35.2863f, 0.707107f);
8902path.conicTo(1.26501f, 35.6607f, 0.890647f, 34.7334f, 0.707107f);
8903path.close();
8904path.moveTo(-0.114587f, 31.7274f);
8905path.quadTo(-0.251922f, 31.2147f, -0.368218f, 30.6968f);
8906path.conicTo(-0.587327f, 29.7211f, 0.388373f, 29.502f, 0.707107f);
8907path.conicTo(1.36407f, 29.2829f, 1.58318f, 30.2586f, 0.707107f);
8908path.quadTo(1.69053f, 30.7366f, 1.8173f, 31.2099f);
8909path.conicTo(2.07605f, 32.1758f, 1.1101f, 32.4346f, 0.707107f);
8910path.conicTo(0.144159f, 32.6933f, -0.114587f, 31.7274f, 0.707107f);
8911path.close();
8912path.moveTo(-0.745485f, 28.6291f);
8913path.quadTo(-0.818367f, 28.112f, -0.870432f, 27.5925f);
8914path.conicTo(-0.970142f, 26.5974f, 0.0248742f, 26.4977f, 0.707107f);
8915path.conicTo(1.01989f, 26.398f, 1.1196f, 27.393f, 0.707107f);
8916path.quadTo(1.16766f, 27.8726f, 1.23494f, 28.3499f);
8917path.conicTo(1.37452f, 29.3401f, 0.384305f, 29.4797f, 0.707107f);
8918path.conicTo(-0.605905f, 29.6193f, -0.745485f, 28.6291f, 0.707107f);
8919path.close();
8920path.moveTo(-0.994901f, 25.515f);
8921path.quadTo(-1.00519f, 24.9955f, -0.994722f, 24.4761f);
8922path.conicTo(-0.97457f, 23.4763f, 0.0252273f, 23.4964f, 0.707107f);
8923path.conicTo(1.02502f, 23.5166f, 1.00487f, 24.5164f, 0.707107f);
8924path.quadTo(0.995207f, 24.9959f, 1.00471f, 25.4754f);
8925path.conicTo(1.02451f, 26.4752f, 0.0247103f, 26.495f, 0.707107f);
8926path.conicTo(-0.975093f, 26.5148f, -0.994901f, 25.515f, 0.707107f);
8927path.close();
8928path.moveTo(-0.867571f, 22.3792f);
8929path.quadTo(-0.81506f, 21.8609f, -0.741825f, 21.3451f);
8930path.conicTo(-0.60125f, 20.355f, 0.38882f, 20.4956f, 0.707107f);
8931path.conicTo(1.37889f, 20.6361f, 1.23831f, 21.6262f, 0.707107f);
8932path.quadTo(1.17071f, 22.1023f, 1.12224f, 22.5807f);
8933path.conicTo(1.02144f, 23.5757f, 0.026537f, 23.4749f, 0.707107f);
8934path.conicTo(-0.96837f, 23.3741f, -0.867571f, 22.3792f, 0.707107f);
8935path.close();
8936path.moveTo(-0.369678f, 19.3097f);
8937path.quadTo(-0.249693f, 18.7748f, -0.107265f, 18.2453f);
8938path.conicTo(0.152529f, 17.2797f, 1.11819f, 17.5395f, 0.707107f);
8939path.conicTo(2.08386f, 17.7993f, 1.82406f, 18.7649f, 0.707107f);
8940path.quadTo(1.69259f, 19.2536f, 1.58184f, 19.7474f);
8941path.conicTo(1.36298f, 20.7232f, 0.387221f, 20.5043f, 0.707107f);
8942path.conicTo(-0.588536f, 20.2855f, -0.369678f, 19.3097f, 0.707107f);
8943path.close();
8944path.moveTo(0.539863f, 16.1851f);
8945path.quadTo(0.719962f, 15.6854f, 0.920307f, 15.1934f);
8946path.conicTo(1.29748f, 14.2673f, 2.22362f, 14.6445f, 0.707107f);
8947path.conicTo(3.14976f, 15.0216f, 2.7726f, 15.9478f, 0.707107f);
8948path.quadTo(2.58765f, 16.4019f, 2.42141f, 16.8632f);
8949path.conicTo(2.08237f, 17.804f, 1.1416f, 17.4649f, 0.707107f);
8950path.conicTo(0.200823f, 17.1259f, 0.539863f, 16.1851f, 0.707107f);
8951path.close();
8952path.moveTo(1.78353f, 13.2955f);
8953path.quadTo(2.01364f, 12.8391f, 2.26151f, 12.392f);
8954path.conicTo(2.74643f, 11.5175f, 3.62099f, 12.0024f, 0.707107f);
8955path.conicTo(4.49555f, 12.4873f, 4.01063f, 13.3618f, 0.707107f);
8956path.quadTo(3.78183f, 13.7745f, 3.56941f, 14.1958f);
8957path.conicTo(3.11923f, 15.0888f, 2.22629f, 14.6386f, 0.707107f);
8958path.conicTo(1.33336f, 14.1884f, 1.78353f, 13.2955f, 0.707107f);
8959path.close();
8960path.moveTo(3.30083f, 10.6771f);
8961path.lineTo(3.44218f, 10.4652f);
8962path.quadTo(3.6466f, 10.1621f, 3.85641f, 9.86895f);
8963path.conicTo(4.43837f, 9.05574f, 5.25159f, 9.6377f, 0.707107f);
8964path.conicTo(6.0648f, 10.2197f, 5.48284f, 11.0329f, 0.707107f);
8965path.quadTo(5.28917f, 11.3035f, 5.10592f, 11.5752f);
8966path.lineTo(4.96457f, 11.787f);
8967path.conicTo(4.4096f, 12.6189f, 3.57773f, 12.0639f, 0.707107f);
8968path.conicTo(2.74586f, 11.509f, 3.30083f, 10.6771f, 0.707107f);
8969path.close();
8970path.moveTo(5.0909f, 8.27793f);
8971path.quadTo(5.42174f, 7.88403f, 5.76791f, 7.50353f);
8972path.conicTo(6.44085f, 6.76383f, 7.18054f, 7.43678f, 0.707107f);
8973path.conicTo(7.92024f, 8.10972f, 7.24729f, 8.84942f, 0.707107f);
8974path.quadTo(6.92775f, 9.20065f, 6.62237f, 9.56424f);
8975path.conicTo(5.97921f, 10.33f, 5.21348f, 9.68682f, 0.707107f);
8976path.conicTo(4.44774f, 9.04367f, 5.0909f, 8.27793f, 0.707107f);
8977path.close();
8978path.moveTo(7.24064f, 6.0104f);
8979path.quadTo(7.63069f, 5.64561f, 8.03537f, 5.29717f);
8980path.conicTo(8.79318f, 4.64469f, 9.44566f, 5.40249f, 0.707107f);
8981path.conicTo(10.0981f, 6.16029f, 9.34034f, 6.81278f, 0.707107f);
8982path.quadTo(8.96678f, 7.13442f, 8.60675f, 7.47113f);
8983path.conicTo(7.87638f, 8.15419f, 7.19332f, 7.42382f, 0.707107f);
8984path.conicTo(6.51027f, 6.69345f, 7.24064f, 6.0104f, 0.707107f);
8985path.close();
8986path.moveTo(9.73726f, 3.95128f);
8987path.quadTo(10.1706f, 3.63704f, 10.6165f, 3.34092f);
8988path.conicTo(11.4496f, 2.78771f, 12.0028f, 3.62075f, 0.707107f);
8989path.conicTo(12.556f, 4.4538f, 11.7229f, 5.007f, 0.707107f);
8990path.quadTo(11.3113f, 5.28035f, 10.9113f, 5.57041f);
8991path.conicTo(10.1018f, 6.15744f, 9.51472f, 5.34787f, 0.707107f);
8992path.conicTo(8.92769f, 4.53831f, 9.73726f, 3.95128f, 0.707107f);
8993path.close();
8994path.moveTo(12.374f, 2.27153f);
8995path.quadTo(12.8282f, 2.01921f, 13.2921f, 1.78522f);
8996path.conicTo(14.185f, 1.33492f, 14.6353f, 2.22779f, 0.707107f);
8997path.conicTo(15.0856f, 3.12067f, 14.1927f, 3.57097f, 0.707107f);
8998path.quadTo(13.7645f, 3.78696f, 13.3452f, 4.01988f);
8999path.conicTo(12.471f, 4.5055f, 11.9854f, 3.63132f, 0.707107f);
9000path.conicTo(11.4998f, 2.75715f, 12.374f, 2.27153f, 0.707107f);
9001path.close();
9002path.moveTo(15.1984f, 0.918296f);
9003path.quadTo(15.6866f, 0.719602f, 16.1824f, 0.540851f);
9004path.conicTo(17.1231f, 0.20171f, 17.4623f, 1.14245f, 0.707107f);
9005path.conicTo(17.8014f, 2.08318f, 16.8607f, 2.42232f, 0.707107f);
9006path.quadTo(16.403f, 2.58733f, 15.9524f, 2.77074f);
9007path.conicTo(15.0261f, 3.14772f, 14.6492f, 2.2215f, 0.707107f);
9008path.conicTo(14.2722f, 1.29528f, 15.1984f, 0.918296f, 0.707107f);
9009path.close();
9010path.moveTo(18.201f, -0.0952874f);
9011path.quadTo(18.7132f, -0.234075f, 19.2308f, -0.351842f);
9012path.conicTo(20.2058f, -0.573734f, 20.4277f, 0.401338f, 0.707107f);
9013path.conicTo(20.6496f, 1.37641f, 19.6745f, 1.5983f, 0.707107f);
9014path.quadTo(19.1968f, 1.70701f, 18.724f, 1.83512f);
9015path.conicTo(17.7588f, 2.09662f, 17.4973f, 1.13142f, 0.707107f);
9016path.conicTo(17.2358f, 0.166216f, 18.201f, -0.0952874f, 0.707107f);
9017path.close();
9018path.moveTo(21.2986f, -0.73518f);
9019path.quadTo(21.8155f, -0.809526f, 22.3349f, -0.863052f);
9020path.conicTo(23.3297f, -0.965552f, 23.4322f, 0.029181f, 0.707107f);
9021path.conicTo(23.5347f, 1.02391f, 22.5399f, 1.12641f, 0.707107f);
9022path.quadTo(22.0604f, 1.17582f, 21.5833f, 1.24445f);
9023path.conicTo(20.5935f, 1.38681f, 20.4511f, 0.397f, 0.707107f);
9024path.conicTo(20.3088f, -0.592814f, 21.2986f, -0.73518f, 0.707107f);
9025path.close();
9026path.moveTo(24.4124f, -0.993361f);
9027path.quadTo(24.9312f, -1.00509f, 25.4501f, -0.996107f);
9028path.conicTo(26.4499f, -0.978799f, 26.4326f, 0.0210512f, 0.707107f);
9029path.conicTo(26.4153f, 1.0209f, 25.4155f, 1.00359f, 0.707107f);
9030path.quadTo(24.9365f, 0.995302f, 24.4576f, 1.00613f);
9031path.conicTo(23.4578f, 1.02873f, 23.4352f, 0.0289853f, 0.707107f);
9032path.conicTo(23.4126f, -0.970759f, 24.4124f, -0.993361f, 0.707107f);
9033path.close();
9034path.moveTo(27.5481f, -0.87484f);
9035path.quadTo(28.0668f, -0.823762f, 28.583f, -0.75194f);
9036path.conicTo(29.5734f, -0.614138f, 29.4356f, 0.376322f, 0.707107f);
9037path.conicTo(29.2978f, 1.36678f, 28.3074f, 1.22898f, 0.707107f);
9038path.quadTo(27.8309f, 1.16268f, 27.3521f, 1.11553f);
9039path.conicTo(26.3569f, 1.01753f, 26.4549f, 0.0223428f, 0.707107f);
9040path.conicTo(26.5529f, -0.972843f, 27.5481f, -0.87484f, 0.707107f);
9041path.close();
9042path.moveTo(30.6151f, -0.386432f);
9043path.quadTo(31.1507f, -0.267954f, 31.6809f, -0.126991f);
9044path.conicTo(32.6473f, 0.129965f, 32.3904f, 1.09639f, 0.707107f);
9045path.conicTo(32.1334f, 2.06281f, 31.167f, 1.80585f, 0.707107f);
9046path.quadTo(30.6776f, 1.67574f, 30.1832f, 1.56637f);
9047path.conicTo(29.2068f, 1.35041f, 29.4227f, 0.374005f, 0.707107f);
9048path.conicTo(29.6387f, -0.602396f, 30.6151f, -0.386432f, 0.707107f);
9049path.close();
9050path.moveTo(33.7445f, 0.514616f);
9051path.quadTo(34.2452f, 0.693421f, 34.7381f, 0.892536f);
9052path.conicTo(35.6653f, 1.26708f, 35.2908f, 2.19429f, 0.707107f);
9053path.conicTo(34.9162f, 3.1215f, 33.989f, 2.74696f, 0.707107f);
9054path.quadTo(33.534f, 2.56316f, 33.0718f, 2.3981f);
9055path.conicTo(32.1301f, 2.06177f, 32.4664f, 1.12003f, 0.707107f);
9056path.conicTo(32.8027f, 0.178285f, 33.7445f, 0.514616f, 0.707107f);
9057path.close();
9058path.moveTo(36.6402f, 1.7512f);
9059path.quadTo(37.0977f, 1.98026f, 37.5458f, 2.22715f);
9060path.conicTo(38.4217f, 2.70968f, 37.9392f, 3.58556f, 0.707107f);
9061path.conicTo(37.4566f, 4.46144f, 36.5808f, 3.97891f, 0.707107f);
9062path.quadTo(36.1671f, 3.75102f, 35.7448f, 3.53956f);
9063path.conicTo(34.8506f, 3.09185f, 35.2983f, 2.19767f, 0.707107f);
9064path.conicTo(35.746f, 1.30349f, 36.6402f, 1.7512f, 0.707107f);
9065path.close();
9066path.moveTo(39.2611f, 3.26012f);
9067path.quadTo(39.4005f, 3.35159f, 39.539f, 3.44501f);
9068path.quadTo(39.8091f, 3.62717f, 40.0746f, 3.81611f);
9069path.conicTo(40.8893f, 4.3959f, 40.3096f, 5.21067f, 0.707107f);
9070path.conicTo(39.7298f, 6.02543f, 38.915f, 5.44564f, 0.707107f);
9071path.quadTo(38.67f, 5.2713f, 38.4206f, 5.10309f);
9072path.quadTo(38.293f, 5.017f, 38.164f, 4.9324f);
9073path.conicTo(37.3279f, 4.38388f, 37.8764f, 3.54775f, 0.707107f);
9074path.conicTo(38.4249f, 2.71161f, 39.2611f, 3.26012f, 0.707107f);
9075path.close();
9076path.moveTo(41.6673f, 5.04503f);
9077path.quadTo(42.0618f, 5.37449f, 42.4428f, 5.71927f);
9078path.conicTo(43.1844f, 6.39015f, 42.5135f, 7.13171f, 0.707107f);
9079path.conicTo(41.8426f, 7.87327f, 41.1011f, 7.20239f, 0.707107f);
9080path.quadTo(40.7493f, 6.88414f, 40.3852f, 6.58004f);
9081path.conicTo(39.6177f, 5.93899f, 40.2588f, 5.17149f, 0.707107f);
9082path.conicTo(40.8998f, 4.40399f, 41.6673f, 5.04503f, 0.707107f);
9083path.close();
9084path.moveTo(43.9388f, 7.1865f);
9085path.quadTo(44.3044f, 7.57519f, 44.6538f, 7.97856f);
9086path.conicTo(45.3084f, 8.73448f, 44.5525f, 9.38914f, 0.707107f);
9087path.conicTo(43.7966f, 10.0438f, 43.1419f, 9.28789f, 0.707107f);
9088path.quadTo(42.8195f, 8.91555f, 42.482f, 8.55677f);
9089path.conicTo(41.7969f, 7.82836f, 42.5253f, 7.14322f, 0.707107f);
9090path.conicTo(43.2537f, 6.45808f, 43.9388f, 7.1865f, 0.707107f);
9091path.close();
9092path.moveTo(46.0036f, 9.6753f);
9093path.quadTo(46.3207f, 10.1098f, 46.6195f, 10.5571f);
9094path.conicTo(47.175f, 11.3886f, 46.3435f, 11.9441f, 0.707107f);
9095path.conicTo(45.5119f, 12.4996f, 44.9564f, 11.6681f, 0.707107f);
9096path.quadTo(44.6806f, 11.2552f, 44.388f, 10.8541f);
9097path.conicTo(43.7986f, 10.0463f, 44.6064f, 9.45688f, 0.707107f);
9098path.conicTo(45.4142f, 8.86747f, 46.0036f, 9.6753f, 0.707107f);
9099path.close();
9100path.moveTo(47.6932f, 12.3107f);
9101path.quadTo(47.9467f, 12.764f, 48.1819f, 13.2271f);
9102path.conicTo(48.6347f, 14.1187f, 47.7431f, 14.5715f, 0.707107f);
9103path.conicTo(46.8514f, 15.0243f, 46.3986f, 14.1327f, 0.707107f);
9104path.quadTo(46.1816f, 13.7053f, 45.9476f, 13.2868f);
9105path.conicTo(45.4595f, 12.414f, 46.3323f, 11.9259f, 0.707107f);
9106path.conicTo(47.2051f, 11.4379f, 47.6932f, 12.3107f, 0.707107f);
9107path.close();
9108path.moveTo(49.0539f, 15.1303f);
9109path.quadTo(49.2539f, 15.6178f, 49.434f, 16.113f);
9110path.conicTo(49.7758f, 17.0527f, 48.836f, 17.3946f, 0.707107f);
9111path.conicTo(47.8963f, 17.7364f, 47.5545f, 16.7966f, 0.707107f);
9112path.quadTo(47.3882f, 16.3395f, 47.2036f, 15.8895f);
9113path.conicTo(46.824f, 14.9643f, 47.7491f, 14.5847f, 0.707107f);
9114path.conicTo(48.6743f, 14.2051f, 49.0539f, 15.1303f, 0.707107f);
9115path.close();
9116path.moveTo(50.0758f, 18.1294f);
9117path.quadTo(50.216f, 18.6412f, 50.3352f, 19.1584f);
9118path.conicTo(50.5599f, 20.1328f, 49.5855f, 20.3575f, 0.707107f);
9119path.conicTo(48.6111f, 20.5821f, 48.3864f, 19.6077f, 0.707107f);
9120path.quadTo(48.2763f, 19.1304f, 48.1469f, 18.6579f);
9121path.conicTo(47.8826f, 17.6935f, 48.8471f, 17.4292f, 0.707107f);
9122path.conicTo(49.8115f, 17.165f, 50.0758f, 18.1294f, 0.707107f);
9123path.close();
9124path.moveTo(50.7247f, 21.2262f);
9125path.quadTo(50.8005f, 21.743f, 50.8555f, 22.2623f);
9126path.conicTo(50.9607f, 23.2568f, 49.9663f, 23.3621f, 0.707107f);
9127path.conicTo(48.9719f, 23.4673f, 48.8666f, 22.4729f, 0.707107f);
9128path.quadTo(48.8158f, 21.9935f, 48.7458f, 21.5165f);
9129path.conicTo(48.6007f, 20.5271f, 49.5901f, 20.382f, 0.707107f);
9130path.conicTo(50.5795f, 20.2368f, 50.7247f, 21.2262f, 0.707107f);
9131path.close();
9132path.moveTo(50.9916f, 24.3398f);
9133path.quadTo(51.0048f, 24.858f, 50.9973f, 25.3762f);
9134path.conicTo(50.9828f, 26.3761f, 49.9829f, 26.3616f, 0.707107f);
9135path.conicTo(48.983f, 26.3472f, 48.9975f, 25.3473f, 0.707107f);
9136path.quadTo(49.0044f, 24.8687f, 48.9923f, 24.3906f);
9137path.conicTo(48.9669f, 23.3909f, 49.9665f, 23.3655f, 0.707107f);
9138path.conicTo(50.9662f, 23.3401f, 50.9916f, 24.3398f, 0.707107f);
9139path.close();
9140path.moveTo(50.8819f, 27.4753f);
9141path.quadTo(50.8323f, 27.9943f, 50.7618f, 28.511f);
9142path.conicTo(50.6268f, 29.5018f, 49.636f, 29.3668f, 0.707107f);
9143path.conicTo(48.6451f, 29.2317f, 48.7802f, 28.2409f, 0.707107f);
9144path.quadTo(48.8452f, 27.7641f, 48.891f, 27.2849f);
9145path.conicTo(48.9862f, 26.2894f, 49.9816f, 26.3846f, 0.707107f);
9146path.conicTo(50.9771f, 26.4798f, 50.8819f, 27.4753f, 0.707107f);
9147path.close();
9148path.moveTo(50.4023f, 30.5429f);
9149path.quadTo(50.2856f, 31.0775f, 50.1465f, 31.607f);
9150path.conicTo(49.8924f, 32.5742f, 48.9252f, 32.3201f, 0.707107f);
9151path.conicTo(47.9581f, 32.066f, 48.2122f, 31.0988f, 0.707107f);
9152path.quadTo(48.3405f, 30.6102f, 48.4483f, 30.1165f);
9153path.conicTo(48.6614f, 29.1395f, 49.6385f, 29.3527f, 0.707107f);
9154path.conicTo(50.6155f, 29.5659f, 50.4023f, 30.5429f, 0.707107f);
9155path.close();
9156path.moveTo(49.5104f, 33.674f);
9157path.quadTo(49.3329f, 34.1756f, 49.1351f, 34.6695f);
9158path.conicTo(48.7632f, 35.5977f, 47.8349f, 35.2258f, 0.707107f);
9159path.conicTo(46.9066f, 34.854f, 47.2785f, 33.9257f, 0.707107f);
9160path.quadTo(47.4612f, 33.4697f, 47.625f, 33.0067f);
9161path.conicTo(47.9587f, 32.064f, 48.9014f, 32.3977f, 0.707107f);
9162path.conicTo(49.8441f, 32.7313f, 49.5104f, 33.674f, 0.707107f);
9163path.close();
9164path.moveTo(48.281f, 36.5756f);
9165path.quadTo(48.053f, 37.0342f, 47.8071f, 37.4835f);
9166path.conicTo(47.3269f, 38.3607f, 46.4497f, 37.8805f, 0.707107f);
9167path.conicTo(45.5725f, 37.4004f, 46.0527f, 36.5232f, 0.707107f);
9168path.quadTo(46.2797f, 36.1085f, 46.4901f, 35.6852f);
9169path.conicTo(46.9353f, 34.7898f, 47.8307f, 35.235f, 0.707107f);
9170path.conicTo(48.7262f, 35.6802f, 48.281f, 36.5756f, 0.707107f);
9171path.close();
9172path.moveTo(46.7777f, 39.2033f);
9173path.quadTo(46.6677f, 39.3719f, 46.555f, 39.539f);
9174path.quadTo(46.3865f, 39.7888f, 46.2121f, 40.0349f);
9175path.conicTo(45.6338f, 40.8507f, 44.818f, 40.2724f, 0.707107f);
9176path.conicTo(44.0021f, 39.6942f, 44.5804f, 38.8783f, 0.707107f);
9177path.quadTo(44.7413f, 38.6513f, 44.8969f, 38.4206f);
9178path.quadTo(45.0008f, 38.2665f, 45.1025f, 38.1107f);
9179path.conicTo(45.6488f, 37.2731f, 46.4864f, 37.8194f, 0.707107f);
9180path.conicTo(47.324f, 38.3657f, 46.7777f, 39.2033f, 0.707107f);
9181path.close();
9182path.moveTo(44.9527f, 41.6701f);
9183path.quadTo(44.6177f, 42.0709f, 44.267f, 42.458f);
9184path.conicTo(43.5955f, 43.1991f, 42.8545f, 42.5276f, 0.707107f);
9185path.conicTo(42.1135f, 41.8561f, 42.7849f, 41.1151f, 0.707107f);
9186path.quadTo(43.1087f, 40.7578f, 43.4178f, 40.3878f);
9187path.conicTo(44.059f, 39.6203f, 44.8264f, 40.2615f, 0.707107f);
9188path.conicTo(45.5938f, 40.9027f, 44.9527f, 41.6701f, 0.707107f);
9189path.close();
9190path.moveTo(42.7884f, 43.9624f);
9191path.quadTo(42.4083f, 44.319f, 42.014f, 44.6602f);
9192path.conicTo(41.2578f, 45.3146f, 40.6034f, 44.5585f, 0.707107f);
9193path.conicTo(39.949f, 43.8023f, 40.7052f, 43.1479f, 0.707107f);
9194path.quadTo(41.0691f, 42.833f, 41.4201f, 42.5037f);
9195path.conicTo(42.1494f, 41.8196f, 42.8336f, 42.5489f, 0.707107f);
9196path.conicTo(43.5178f, 43.2782f, 42.7884f, 43.9624f, 0.707107f);
9197path.close();
9198path.moveTo(40.3892f, 45.9564f);
9199path.quadTo(39.9683f, 46.2655f, 39.5354f, 46.5574f);
9200path.conicTo(38.7062f, 47.1165f, 38.1472f, 46.2873f, 0.707107f);
9201path.conicTo(37.5881f, 45.4582f, 38.4173f, 44.8992f, 0.707107f);
9202path.quadTo(38.8169f, 44.6297f, 39.2054f, 44.3444f);
9203path.conicTo(40.0114f, 43.7525f, 40.6033f, 44.5585f, 0.707107f);
9204path.conicTo(41.1952f, 45.3645f, 40.3892f, 45.9564f, 0.707107f);
9205path.close();
9206path.moveTo(37.7543f, 47.6568f);
9207path.quadTo(37.2977f, 47.9138f, 36.8312f, 48.1522f);
9208path.conicTo(35.9407f, 48.6072f, 35.4857f, 47.7167f, 0.707107f);
9209path.conicTo(35.0306f, 46.8263f, 35.9211f, 46.3712f, 0.707107f);
9210path.quadTo(36.3518f, 46.1511f, 36.7732f, 45.9139f);
9211path.conicTo(37.6446f, 45.4234f, 38.1351f, 46.2948f, 0.707107f);
9212path.conicTo(38.6257f, 47.1662f, 37.7543f, 47.6568f, 0.707107f);
9213path.close();
9214path.moveTo(34.9311f, 49.0286f);
9215path.quadTo(34.4488f, 49.2279f, 33.9589f, 49.4077f);
9216path.conicTo(33.0202f, 49.7523f, 32.6756f, 48.8136f, 0.707107f);
9217path.conicTo(32.331f, 47.8748f, 33.2698f, 47.5302f, 0.707107f);
9218path.quadTo(33.722f, 47.3642f, 34.1672f, 47.1802f);
9219path.conicTo(35.0914f, 46.7983f, 35.4733f, 47.7224f, 0.707107f);
9220path.conicTo(35.8553f, 48.6466f, 34.9311f, 49.0286f, 0.707107f);
9221path.close();
9222path.moveTo(31.9824f, 50.0449f);
9223path.quadTo(31.4774f, 50.1857f, 30.9668f, 50.3061f);
9224path.conicTo(29.9935f, 50.5355f, 29.764f, 49.5622f, 0.707107f);
9225path.conicTo(29.5346f, 48.5889f, 30.5079f, 48.3594f, 0.707107f);
9226path.quadTo(30.9789f, 48.2484f, 31.4453f, 48.1184f);
9227path.conicTo(32.4086f, 47.8498f, 32.6771f, 48.8131f, 0.707107f);
9228path.conicTo(32.9457f, 49.7763f, 31.9824f, 50.0449f, 0.707107f);
9229path.close();
9230path.moveTo(28.899f, 50.706f);
9231path.quadTo(28.3834f, 50.7842f, 27.8652f, 50.8416f);
9232path.conicTo(26.8713f, 50.9518f, 26.7611f, 49.9579f, 0.707107f);
9233path.conicTo(26.6509f, 48.964f, 27.6448f, 48.8538f, 0.707107f);
9234path.quadTo(28.1231f, 48.8008f, 28.599f, 48.7286f);
9235path.conicTo(29.5877f, 48.5786f, 29.7377f, 49.5673f, 0.707107f);
9236path.conicTo(29.8877f, 50.556f, 28.899f, 50.706f, 0.707107f);
9237path.close();
9238path.moveTo(25.8106f, 50.9874f);
9239path.quadTo(25.6321f, 50.9929f, 25.4537f, 50.996f);
9240path.conicTo(24.4539f, 51.0135f, 24.4365f, 50.0136f, 0.707115f);
9241path.lineTo(24.4251f, 49.3638f);
9242path.conicTo(24.4077f, 48.364f, 25.4075f, 48.3465f, 0.707107f);
9243path.conicTo(26.4073f, 48.3291f, 26.4248f, 49.3289f, 0.707107f);
9244path.lineTo(26.4361f, 49.9787f);
9245path.lineTo(25.4363f, 49.9962f);
9246path.lineTo(25.4189f, 48.9963f);
9247path.quadTo(25.5836f, 48.9935f, 25.7482f, 48.9883f);
9248path.conicTo(26.7477f, 48.9571f, 26.7789f, 49.9567f, 0.707107f);
9249path.conicTo(26.8101f, 50.9562f, 25.8106f, 50.9874f, 0.707107f);
9250path.close();
9251path.moveTo(24.3902f, 47.3641f);
9252path.lineTo(24.3728f, 46.3643f);
9253path.conicTo(24.3553f, 45.3645f, 25.3551f, 45.347f, 0.707107f);
9254path.conicTo(26.355f, 45.3295f, 26.3724f, 46.3294f, 0.707107f);
9255path.lineTo(26.3899f, 47.3292f);
9256path.conicTo(26.4074f, 48.3291f, 25.4075f, 48.3465f, 0.707107f);
9257path.conicTo(24.4077f, 48.364f, 24.3902f, 47.3641f, 0.707107f);
9258path.close();
9259path.moveTo(24.3378f, 44.3646f);
9260path.lineTo(24.3204f, 43.3648f);
9261path.conicTo(24.3029f, 42.3649f, 25.3028f, 42.3475f, 0.707107f);
9262path.conicTo(26.3026f, 42.33f, 26.3201f, 43.3298f, 0.707107f);
9263path.lineTo(26.3375f, 44.3297f);
9264path.conicTo(26.355f, 45.3295f, 25.3551f, 45.347f, 0.707107f);
9265path.conicTo(24.3553f, 45.3645f, 24.3378f, 44.3646f, 0.707107f);
9266path.close();
9267path.moveTo(24.2855f, 41.3651f);
9268path.lineTo(24.268f, 40.3652f);
9269path.conicTo(24.2506f, 39.3654f, 25.2504f, 39.3479f, 0.707107f);
9270path.conicTo(26.2503f, 39.3305f, 26.2677f, 40.3303f, 0.707107f);
9271path.lineTo(26.2852f, 41.3302f);
9272path.conicTo(26.3026f, 42.33f, 25.3028f, 42.3475f, 0.707107f);
9273path.conicTo(24.3029f, 42.3649f, 24.2855f, 41.3651f, 0.707107f);
9274path.close();
9275path.moveTo(24.2331f, 38.3655f);
9276path.lineTo(24.2157f, 37.3657f);
9277path.conicTo(24.1982f, 36.3658f, 25.1981f, 36.3484f, 0.707107f);
9278path.conicTo(26.1979f, 36.3309f, 26.2154f, 37.3308f, 0.707107f);
9279path.lineTo(26.2328f, 38.3306f);
9280path.conicTo(26.2503f, 39.3305f, 25.2504f, 39.3479f, 0.707107f);
9281path.conicTo(24.2506f, 39.3654f, 24.2331f, 38.3655f, 0.707107f);
9282path.close();
9283path.moveTo(24.1808f, 35.366f);
9284path.lineTo(24.1633f, 34.3661f);
9285path.conicTo(24.1459f, 33.3663f, 25.1457f, 33.3488f, 0.707107f);
9286path.conicTo(26.1456f, 33.3314f, 26.163f, 34.3312f, 0.707107f);
9287path.lineTo(26.1805f, 35.3311f);
9288path.conicTo(26.1979f, 36.3309f, 25.1981f, 36.3484f, 0.707107f);
9289path.conicTo(24.1982f, 36.3658f, 24.1808f, 35.366f, 0.707107f);
9290path.close();
9291path.moveTo(24.1284f, 32.3664f);
9292path.lineTo(24.111f, 31.3666f);
9293path.conicTo(24.0935f, 30.3667f, 25.0934f, 30.3493f, 0.707107f);
9294path.conicTo(26.0932f, 30.3318f, 26.1107f, 31.3317f, 0.707107f);
9295path.lineTo(26.1281f, 32.3315f);
9296path.conicTo(26.1456f, 33.3314f, 25.1457f, 33.3488f, 0.707107f);
9297path.conicTo(24.1459f, 33.3663f, 24.1284f, 32.3664f, 0.707107f);
9298path.close();
9299path.moveTo(24.0761f, 29.3669f);
9300path.lineTo(24.0586f, 28.367f);
9301path.conicTo(24.0412f, 27.3672f, 25.041f, 27.3497f, 0.707107f);
9302path.conicTo(26.0409f, 27.3323f, 26.0583f, 28.3321f, 0.707107f);
9303path.lineTo(26.0758f, 29.332f);
9304path.conicTo(26.0932f, 30.3318f, 25.0934f, 30.3493f, 0.707107f);
9305path.conicTo(24.0935f, 30.3667f, 24.0761f, 29.3669f, 0.707107f);
9306path.close();
9307path.moveTo(24.0237f, 26.3673f);
9308path.lineTo(24.0063f, 25.3675f);
9309path.conicTo(23.9888f, 24.3676f, 24.9887f, 24.3502f, 0.707107f);
9310path.conicTo(25.9885f, 24.3327f, 26.006f, 25.3326f, 0.707107f);
9311path.lineTo(26.0234f, 26.3324f);
9312path.conicTo(26.0409f, 27.3323f, 25.041f, 27.3497f, 0.707107f);
9313path.conicTo(24.0412f, 27.3672f, 24.0237f, 26.3673f, 0.707107f);
9314path.close();
9315testSimplifyFail(reporter, path, filename);
9316}
9317
9318static void bug8249(skiatest::Reporter* reporter, const char* filename) {
9319SkPath path;
9320path.setFillType(SkPathFillType::kWinding);
9321path.moveTo(SkBits2Float(0x43310000), SkBits2Float(0x43810000)); // 177, 258
9322path.lineTo(SkBits2Float(0x43480000), SkBits2Float(0x43868000)); // 200, 269
9323path.cubicTo(SkBits2Float(0x43480000), SkBits2Float(0x43b20000), SkBits2Float(0x437a0000), SkBits2Float(0x43cd0000), SkBits2Float(0x43c80000), SkBits2Float(0x43cd0000)); // 200, 356, 250, 410, 400, 410
9324path.cubicTo(SkBits2Float(0x44098000), SkBits2Float(0x43cd0000), SkBits2Float(0x44160000), SkBits2Float(0x43b20000), SkBits2Float(0x44160000), SkBits2Float(0x43868000)); // 550, 410, 600, 356, 600, 269
9325path.lineTo(SkBits2Float(0x44160000), SkBits2Float(0x43808000)); // 600, 257
9326path.cubicTo(SkBits2Float(0x44160000), SkBits2Float(0x43330000), SkBits2Float(0x44110000), SkBits2Float(0x429c0000), SkBits2Float(0x43cd0000), SkBits2Float(0x429c0000)); // 600, 179, 580, 78, 410, 78
9327path.cubicTo(SkBits2Float(0x43700000), SkBits2Float(0x429c0000), SkBits2Float(0x43480000), SkBits2Float(0x431f0000), SkBits2Float(0x43480000), SkBits2Float(0x438a8000)); // 240, 78, 200, 159, 200, 277
9328path.lineTo(SkBits2Float(0x43480000), SkBits2Float(0x4401c000)); // 200, 519
9329path.cubicTo(SkBits2Float(0x43480000), SkBits2Float(0x441f0000), SkBits2Float(0x43660000), SkBits2Float(0x44340000), SkBits2Float(0x43c80000), SkBits2Float(0x44340000)); // 200, 636, 230, 720, 400, 720
9330path.cubicTo(SkBits2Float(0x4404c000), SkBits2Float(0x44340000), SkBits2Float(0x440d0000), SkBits2Float(0x442b8000), SkBits2Float(0x44118000), SkBits2Float(0x4416c000)); // 531, 720, 564, 686, 582, 603
9331path.lineTo(SkBits2Float(0x442cc000), SkBits2Float(0x441c8000)); // 691, 626
9332path.cubicTo(SkBits2Float(0x44260000), SkBits2Float(0x443d4000), SkBits2Float(0x44114000), SkBits2Float(0x444a8000), SkBits2Float(0x43c88000), SkBits2Float(0x444a8000)); // 664, 757, 581, 810, 401, 810
9333path.cubicTo(SkBits2Float(0x43350000), SkBits2Float(0x444a8000), SkBits2Float(0x42c80000), SkBits2Float(0x442e0000), SkBits2Float(0x42c80000), SkBits2Float(0x4401c000)); // 181, 810, 100, 696, 100, 519
9334path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x438a8000)); // 100, 277
9335path.cubicTo(SkBits2Float(0x42c80000), SkBits2Float(0x42cc0000), SkBits2Float(0x433e0000), SkBits2Float(0xc1200000), SkBits2Float(0x43cd0000), SkBits2Float(0xc1200000)); // 100, 102, 190, -10, 410, -10
9336path.cubicTo(SkBits2Float(0x441d8000), SkBits2Float(0xc1200000), SkBits2Float(0x442f0000), SkBits2Float(0x42e60000), SkBits2Float(0x442f0000), SkBits2Float(0x437a0000)); // 630, -10, 700, 115, 700, 250
9337path.lineTo(SkBits2Float(0x442f0000), SkBits2Float(0x43880000)); // 700, 272
9338path.cubicTo(SkBits2Float(0x442f0000), SkBits2Float(0x43d18000), SkBits2Float(0x44164000), SkBits2Float(0x43fa0000), SkBits2Float(0x43c88000), SkBits2Float(0x43fa0000)); // 700, 419, 601, 500, 401, 500
9339path.cubicTo(SkBits2Float(0x43490000), SkBits2Float(0x43fa0000), SkBits2Float(0x43160000), SkBits2Float(0x43d00000), SkBits2Float(0x43160000), SkBits2Float(0x43868000)); // 201, 500, 150, 416, 150, 269
9340path.lineTo(SkBits2Float(0x43310000), SkBits2Float(0x43810000)); // 177, 258
9341path.close();
9342testSimplify(reporter, path, filename);
9343}
9344
9345static void bug8290(skiatest::Reporter* reporter, const char* filename) {
9346 SkPath path;
9347 path.setFillType(SkPathFillType::kEvenOdd);
9348 path.moveTo(-1e+09, -1e+09);
9349 path.lineTo(1e+09, -1e+09);
9350 path.lineTo(1e+09, 1e+09);
9351 path.lineTo(-1e+09, 1e+09);
9352 path.lineTo(-1e+09, -1e+09);
9353 path.close();
9354 path.moveTo(0, 45);
9355 path.lineTo(270, 45);
9356 path.lineTo(270, 45.381f);
9357 path.lineTo(0, 45.381f);
9358 path.lineTo(0, 45);
9359 path.close();
9360 path.moveTo(0, 90.381f);
9361 path.lineTo(270, 90.381f);
9362 path.lineTo(270, 90.7619f);
9363 path.lineTo(0, 90.7619f);
9364 path.lineTo(0, 90.381f);
9365 path.close();
9366 path.moveTo(0, 135.762f);
9367 path.lineTo(270, 135.762f);
9368 path.lineTo(270, 136.143f);
9369 path.lineTo(0, 136.143f);
9370 path.lineTo(0, 135.762f);
9371 path.close();
9372 path.moveTo(0, 181.143f);
9373 path.lineTo(270, 181.143f);
9374 path.lineTo(270, 181.524f);
9375 path.lineTo(0, 181.524f);
9376 path.lineTo(0, 181.143f);
9377 path.close();
9378 path.moveTo(0, 226.524f);
9379 path.lineTo(270, 226.524f);
9380 path.lineTo(270, 226.905f);
9381 path.lineTo(0, 226.905f);
9382 path.lineTo(0, 226.524f);
9383 path.close();
9384 path.moveTo(0, 271.905f);
9385 path.lineTo(270, 271.905f);
9386 path.lineTo(270, 272.286f);
9387 path.lineTo(0, 272.286f);
9388 path.lineTo(0, 271.905f);
9389 path.close();
9390 path.moveTo(0, 317.286f);
9391 path.lineTo(270, 317.286f);
9392 path.lineTo(270, 317.667f);
9393 path.lineTo(0, 317.667f);
9394 path.lineTo(0, 317.286f);
9395 path.close();
9396 SkMatrix matrix = SkMatrix::MakeAll(
9397 2.625, 0, 186,
9398 0, 2.625, 620,
9399 0, 0, 1);
9400 path.transform(matrix);
9401 testSimplify(reporter, path, filename);
9402}
9403
9404static void bug11958_a(skiatest::Reporter* reporter, const char* filename) {
9405 SkPath path;
9406 path.setFillType(SkPathFillType::kWinding);
9407 path.moveTo(SkBits2Float(0x44099d81), SkBits2Float(0x00000000)); // 550.461f, 0
9408 path.lineTo(SkBits2Float(0x44099d81), SkBits2Float(0x43b7276d)); // 550.461f, 366.308f
9409 path.lineTo(SkBits2Float(0x44324ea8), SkBits2Float(0x43b7276d)); // 713.229f, 366.308f
9410 path.lineTo(SkBits2Float(0x44324ea8), SkBits2Float(0x00000000)); // 713.229f, 0
9411 path.lineTo(SkBits2Float(0x44099d81), SkBits2Float(0x00000000)); // 550.461f, 0
9412 path.close();
9413 path.moveTo(SkBits2Float(0x440f9d71), SkBits2Float(0x00000000)); // 574.46f, 0
9414 path.lineTo(SkBits2Float(0x440f9d71), SkBits2Float(0x438a1d91)); // 574.46f, 276.231f
9415 path.lineTo(SkBits2Float(0x44387127), SkBits2Float(0x438a1d91)); // 737.768f, 276.231f
9416 path.quadTo(SkBits2Float(0x444d04cd), SkBits2Float(0x438a1d91), SkBits2Float(0x4456f396), SkBits2Float(0x4372a76c)); // 820.075f, 276.231f, 859.806f, 242.654f
9417 path.quadTo(SkBits2Float(0x4460e25e), SkBits2Float(0x435113b6), SkBits2Float(0x4460e25e), SkBits2Float(0x4310276d)); // 899.537f, 209.077f, 899.537f, 144.154f
9418 path.quadTo(SkBits2Float(0x4460e25e), SkBits2Float(0x429e0000), SkBits2Float(0x44555d70), SkBits2Float(0x421e0000)); // 899.537f, 79, 853.46f, 39.5f
9419 path.quadTo(SkBits2Float(0x4449d883), SkBits2Float(0x00000000), SkBits2Float(0x44321883), SkBits2Float(0x00000000)); // 807.383f, 0, 712.383f, 0
9420 path.lineTo(SkBits2Float(0x440f9d71), SkBits2Float(0x00000000)); // 574.46f, 0
9421 path.close();
9422
9423 // TODO(skbug:11958) - This should not fail to simplify
9424 testSimplifyFail(reporter, path, filename);
9425}
9426
9427static void bug11958_b(skiatest::Reporter* reporter, const char* filename) {
9428 SkPath path;
9429
9430 path.setFillType(SkPathFillType::kWinding);
9431 path.moveTo(SkBits2Float(0x42240000), SkBits2Float(0x43420000)); // 41, 194
9432 path.quadTo(SkBits2Float(0x42240000), SkBits2Float(0x43928000), SkBits2Float(0x42930000), SkBits2Float(0x43b38000)); // 41, 293, 73.5f, 359
9433 path.quadTo(SkBits2Float(0x42d40000), SkBits2Float(0x43d48000), SkBits2Float(0x43240000), SkBits2Float(0x43e58000)); // 106, 425, 164, 459
9434 path.quadTo(SkBits2Float(0x435e0000), SkBits2Float(0x43f68000), SkBits2Float(0x43958000), SkBits2Float(0x43f68000)); // 222, 493, 299, 493
9435 path.quadTo(SkBits2Float(0x43ab0000), SkBits2Float(0x43f68000), SkBits2Float(0x43bd0000), SkBits2Float(0x43f2c000)); // 342, 493, 378, 485.5f
9436 path.quadTo(SkBits2Float(0x43cf0000), SkBits2Float(0x43ef0000), SkBits2Float(0x43df8000), SkBits2Float(0x43e80000)); // 414, 478, 447, 464
9437 path.quadTo(SkBits2Float(0x43f00000), SkBits2Float(0x43e10000), SkBits2Float(0x43ff8000), SkBits2Float(0x43d70000)); // 480, 450, 511, 430
9438 path.lineTo(SkBits2Float(0x43f78000), SkBits2Float(0x43cc0000)); // 495, 408
9439 path.quadTo(SkBits2Float(0x43e90000), SkBits2Float(0x43d58000), SkBits2Float(0x43d9c000), SkBits2Float(0x43dc4000)); // 466, 427, 435.5f, 440.5f
9440 path.quadTo(SkBits2Float(0x43ca8000), SkBits2Float(0x43e30000), SkBits2Float(0x43b9c000), SkBits2Float(0x43e68000)); // 405, 454, 371.5f, 461
9441 path.quadTo(SkBits2Float(0x43a90000), SkBits2Float(0x43ea0000), SkBits2Float(0x43958000), SkBits2Float(0x43ea0000)); // 338, 468, 299, 468
9442 path.quadTo(SkBits2Float(0x43650000), SkBits2Float(0x43ea0000), SkBits2Float(0x43308000), SkBits2Float(0x43da4000)); // 229, 468, 176.5f, 436.5f
9443 path.quadTo(SkBits2Float(0x42f80000), SkBits2Float(0x43ca8000), SkBits2Float(0x42c00000), SkBits2Float(0x43ac0000)); // 124, 405, 96, 344
9444 path.quadTo(SkBits2Float(0x42880000), SkBits2Float(0x438d8000), SkBits2Float(0x42880000), SkBits2Float(0x43420000)); // 68, 283, 68, 194
9445 path.lineTo(SkBits2Float(0x42240000), SkBits2Float(0x43420000)); // 41, 194
9446 path.close();
9447 path.moveTo(SkBits2Float(0x43ddd958), SkBits2Float(0x440e8000)); // 443.698f, 570
9448 path.quadTo(SkBits2Float(0x43ddd958), SkBits2Float(0x44094000), SkBits2Float(0x43da5958), SkBits2Float(0x4404c000)); // 443.698f, 549, 436.698f, 531
9449 path.quadTo(SkBits2Float(0x43d6d958), SkBits2Float(0x44004000), SkBits2Float(0x43cfd958), SkBits2Float(0x43f98000)); // 429.698f, 513, 415.698f, 499
9450 path.quadTo(SkBits2Float(0x43c75958), SkBits2Float(0x43f18000), SkBits2Float(0x43ba9958), SkBits2Float(0x43ee0000)); // 398.698f, 483, 373.198f, 476
9451 path.quadTo(SkBits2Float(0x43add958), SkBits2Float(0x43ea8000), SkBits2Float(0x4396d958), SkBits2Float(0x43ea8000)); // 347.698f, 469, 301.698f, 469
9452 path.lineTo(SkBits2Float(0x436cb2b0), SkBits2Float(0x43ea8000)); // 236.698f, 469
9453 path.lineTo(SkBits2Float(0x436cb2b0), SkBits2Float(0x43f68000)); // 236.698f, 493
9454 path.lineTo(SkBits2Float(0x43955958), SkBits2Float(0x43f68000)); // 298.698f, 493
9455 path.quadTo(SkBits2Float(0x43a8d958), SkBits2Float(0x43f68000), SkBits2Float(0x43b3d958), SkBits2Float(0x43f90000)); // 337.698f, 493, 359.698f, 498
9456 path.quadTo(SkBits2Float(0x43bed958), SkBits2Float(0x43fb8000), SkBits2Float(0x43c55958), SkBits2Float(0x4400c000)); // 381.698f, 503, 394.698f, 515
9457 path.quadTo(SkBits2Float(0x43cb5958), SkBits2Float(0x44030000), SkBits2Float(0x43cdd958), SkBits2Float(0x4406a000)); // 406.698f, 524, 411.698f, 538.5f
9458 path.quadTo(SkBits2Float(0x43d05958), SkBits2Float(0x440a4000), SkBits2Float(0x43d05958), SkBits2Float(0x440e8000)); // 416.698f, 553, 416.698f, 570
9459 path.lineTo(SkBits2Float(0x43ddd958), SkBits2Float(0x440e8000)); // 443.698f, 570
9460 path.close();
9461
9462 testSimplify(reporter, path, filename);
9463}
9464
9465static void bug11958_c(skiatest::Reporter* reporter, const char* filename) {
9466 SkPath path;
9467
9468 path.setFillType(SkPathFillType::kWinding);
9469 path.moveTo(200.f, 200.f);
9470 path.lineTo(164.f, 459.f);
9471 path.quadTo(222.f, 493.f, 299.f, 493.f);
9472 path.quadTo(342.f, 493.f, 378.f, 485.f);
9473 path.close();
9474
9475 path.moveTo(415.698f, 499.f);
9476 path.lineTo(236.698f, 469.f);
9477 path.lineTo(236.698f, 493.f);
9478 path.lineTo(298.698f, 493.f);
9479 path.quadTo(337.698f, 493.f, 359.698f, 498.f);
9480 path.close();
9481
9482 testSimplify(reporter, path, filename);
9483}
9484
9485static void (*skipTest)(skiatest::Reporter* , const char* filename) = nullptr;
9486static void (*firstTest)(skiatest::Reporter* , const char* filename) = nullptr;
9487static void (*stopTest)(skiatest::Reporter* , const char* filename) = nullptr;
9488
9489static TestDesc tests[] = {
9490 TEST(bug8290),
9491 TEST(bug8249),
9492 TEST(bug11958_a),
9493 TEST(bug11958_b),
9494 TEST(bug11958_c),
9495 TEST(grshapearc),
9496 TEST(coincubics),
9497 TEST(joel_16x),
9498 TEST(joel_16),
9499 TEST(joel_15x),
9500 TEST(joel_15),
9501 TEST(joel_14x),
9502 TEST(joel_14),
9503 TEST(joel_13x),
9504 TEST(joel_13),
9505 TEST(joel_12x),
9506 TEST(joel_12),
9507 TEST(joel_11),
9508 TEST(joel_10),
9509 TEST(joel_9),
9510 TEST(joel_8),
9511 TEST(joel_7),
9512 TEST(joel_6),
9513 TEST(joel_5),
9514 TEST(joel_4),
9515 TEST(joel_3),
9516 TEST(joel_2),
9517 TEST(joel_1),
9518 TEST(simplifyTest_1),
9519 TEST(carsvg_1),
9520 TEST(tiger8_393),
9521 TEST(bug5169),
9522 TEST(testQuads73),
9523 TEST(testQuads72),
9524 TEST(testQuads71),
9525 TEST(testQuads70),
9526 TEST(testQuads69),
9527 TEST(testQuads68),
9528 TEST(testQuads67),
9529 TEST(testQuads66),
9530 TEST(dean4),
9531 TEST(fuzz763_4713_b),
9532 TEST(fuzz_twister2),
9533 TEST(fuzz_twister),
9534 TEST(fuzz994s_3414),
9535 TEST(fuzz994s_11),
9536 TEST(cr514118),
9537 TEST(fuzz864a),
9538 TEST(testQuads65),
9539 TEST(testIssue3838_3),
9540 TEST(testIssue3838),
9541 TEST(testArc),
9542 TEST(testTriangle2),
9543 TEST(testTriangle1),
9544 TEST(testQuads64),
9545 TEST(testQuads63),
9546 TEST(testQuads62),
9547 TEST(testRect4),
9548 TEST(testRect3),
9549 TEST(testQuadralateral10),
9550 TEST(testQuads61),
9551 TEST(testQuads60),
9552 TEST(testQuads59),
9553 TEST(testQuads58),
9554 TEST(testQuads57),
9555 TEST(testQuads56),
9556 TEST(testQuads54),
9557 TEST(testQuads53),
9558 TEST(testQuads52),
9559 TEST(testQuads51),
9560 TEST(testQuads50),
9561 TEST(testQuads49),
9562 TEST(testQuads48),
9563 TEST(testQuads47),
9564 TEST(testQuads46x),
9565 TEST(testQuads45),
9566 TEST(testQuads44),
9567 TEST(testQuads43),
9568 TEST(testQuads42),
9569 TEST(testQuads41),
9570 TEST(testQuads36),
9571 TEST(testQuads37),
9572 TEST(testQuads38),
9573 TEST(testQuads39),
9574 TEST(testQuads40),
9575 TEST(testQuads16),
9576 TEST(testQuads17),
9577 TEST(testQuads18),
9578 TEST(testQuads19),
9579 TEST(testQuads20),
9580 TEST(testQuads21),
9581 TEST(testQuads22),
9582 TEST(testQuads23),
9583 TEST(testQuads24),
9584 TEST(testQuads25),
9585 TEST(testQuads26),
9586 TEST(testQuads27),
9587 TEST(testQuads28),
9588 TEST(testQuads29),
9589 TEST(testQuads30),
9590 TEST(testQuads31),
9591 TEST(testQuads32),
9592 TEST(testQuads33),
9593 TEST(testQuads34),
9594 TEST(testQuads35),
9595 TEST(testDegenerates1),
9596 TEST(testQuad13),
9597 TEST(testQuad14),
9598 TEST(testQuad15),
9599 TEST(testQuadratic56),
9600 TEST(testQuadralateral4),
9601 TEST(testQuadralateral3),
9602 TEST(testDegenerate5),
9603 TEST(testQuad12),
9604 TEST(testQuadratic51),
9605 TEST(testQuad8),
9606 TEST(testQuad11),
9607 TEST(testQuad10),
9608 TEST(testQuad9),
9609 TEST(testTriangles4x),
9610 TEST(testTriangles3x),
9611 TEST(testRect2s),
9612 TEST(testRect1s),
9613 TEST(tooCloseTest),
9614 TEST(skphealth_com76s),
9615 TEST(testQuadLineIntersect1),
9616 TEST(testQuadLineIntersect2),
9617 TEST(testQuadLineIntersect3),
9618 TEST(testQuad7),
9619 TEST(testQuad6),
9620 TEST(testQuad5),
9621 TEST(testQuad4),
9622 TEST(testQuad3),
9623 TEST(testQuad2),
9624 TEST(testAddTCoincident2),
9625 TEST(testAddTCoincident1),
9626 TEST(testTriangles2),
9627 TEST(testTriangles1),
9628 TEST(testQuadratic97),
9629 TEST(testQuadratic96),
9630 TEST(testQuadratic95),
9631 TEST(testQuadratic94),
9632 TEST(testQuadralateral2),
9633 TEST(testQuad1),
9634 TEST(testCubic2),
9635 TEST(testCubic1),
9636 TEST(testQuadralateral1),
9637 TEST(testLine85),
9638 TEST(testLine84),
9639 TEST(testLine84x),
9640 TEST(testLine83),
9641 TEST(testLine82h),
9642 TEST(testLine82g),
9643 TEST(testLine82f),
9644 TEST(testLine82e),
9645 TEST(testLine82d),
9646 TEST(testLine82c),
9647 TEST(testLine82b),
9648 TEST(testLine82a),
9649 TEST(testLine82),
9650 TEST(testQuadratic93),
9651 TEST(testQuadratic92x),
9652 TEST(testQuadratic91),
9653 TEST(testQuadratic90x),
9654 TEST(testQuadratic89x),
9655 TEST(testQuadratic88),
9656 TEST(testQuadratic87),
9657 TEST(testQuadratic86),
9658 TEST(testQuadratic85),
9659 TEST(testQuadratic84),
9660 TEST(testQuadratic83),
9661 TEST(testQuadratic82),
9662 TEST(testQuadratic81),
9663 TEST(testQuadratic80),
9664 TEST(testEight1),
9665 TEST(testEight2),
9666 TEST(testEight3),
9667 TEST(testEight4),
9668 TEST(testEight5),
9669 TEST(testEight6),
9670 TEST(testEight7),
9671 TEST(testEight8),
9672 TEST(testEight9),
9673 TEST(testEight10),
9674 TEST(testQuadratic79),
9675 TEST(testQuadratic78),
9676 TEST(testQuadratic77),
9677 TEST(testQuadratic76),
9678 TEST(testQuadratic75),
9679 TEST(testQuadratic74),
9680 TEST(testQuadratic73),
9681 TEST(testQuadratic72),
9682 TEST(testQuadratic71),
9683 TEST(testQuadratic70x),
9684 TEST(testQuadratic69),
9685 TEST(testQuadratic68),
9686 TEST(testQuadratic67x),
9687 TEST(testQuadratic65),
9688 TEST(testQuadratic64),
9689 TEST(testQuadratic63),
9690 TEST(testLine1a),
9691 TEST(testQuadratic59),
9692 TEST(testQuadratic59x),
9693 TEST(testQuadratic58),
9694 TEST(testQuadratic55),
9695 TEST(testQuadratic53),
9696 TEST(testQuadratic38),
9697 TEST(testQuadratic37),
9698 TEST(testQuadratic36),
9699 TEST(testQuadratic35),
9700 TEST(testQuadratic34),
9701 TEST(testQuadratic33),
9702 TEST(testQuadratic32),
9703 TEST(testQuadratic31),
9704 TEST(testQuadratic30),
9705 TEST(testQuadratic29),
9706 TEST(testQuadratic28),
9707 TEST(testQuadratic27),
9708 TEST(testQuadratic26),
9709 TEST(testQuadratic25),
9710 TEST(testQuadratic24),
9711 TEST(testQuadratic23),
9712 TEST(testQuadratic22),
9713 TEST(testQuadratic21),
9714 TEST(testQuadratic20),
9715 TEST(testQuadratic19),
9716 TEST(testQuadratic18),
9717 TEST(testQuadratic17x),
9718 TEST(testQuadratic15),
9719 TEST(testQuadratic14),
9720 TEST(testQuadratic9),
9721 TEST(testQuadratic8),
9722 TEST(testQuadratic7),
9723 TEST(testQuadratic6),
9724 TEST(testQuadratic5),
9725 TEST(testQuadratic4x),
9726 TEST(testQuadratic3x),
9727 TEST(testQuadratic2x),
9728 TEST(testQuadratic1x),
9729 TEST(testQuadratic4),
9730 TEST(testQuadratic3),
9731 TEST(testQuadratic2),
9732 TEST(testQuadratic1),
9733 TEST(testLine4ax),
9734 TEST(testLine3aax),
9735 TEST(testLine2ax),
9736 TEST(testLine1ax),
9737 TEST(testQuadralateral9x),
9738 TEST(testQuadralateral8x),
9739 TEST(testQuadralateral7x),
9740 TEST(testQuadralateral6x),
9741 TEST(testQuadralateral6ax),
9742 TEST(testQuadralateral9),
9743 TEST(testQuadralateral8),
9744 TEST(testQuadralateral7),
9745 TEST(testQuadralateral6),
9746 TEST(testQuadralateral6a),
9747 TEST(testFauxQuadralateral6dx),
9748 TEST(testFauxQuadralateral6cx),
9749 TEST(testFauxQuadralateral6bx),
9750 TEST(testFauxQuadralateral6ax),
9751 TEST(testFauxQuadralateral6x),
9752 TEST(testFauxQuadralateral6d),
9753 TEST(testFauxQuadralateral6c),
9754 TEST(testFauxQuadralateral6b),
9755 TEST(testFauxQuadralateral6a),
9756 TEST(testFauxQuadralateral6),
9757 TEST(testQuadralateral5x),
9758 TEST(testQuadralateral5),
9759 TEST(testNondegenerate4x),
9760 TEST(testNondegenerate3x),
9761 TEST(testNondegenerate2x),
9762 TEST(testNondegenerate1x),
9763 TEST(testNondegenerate4),
9764 TEST(testNondegenerate3),
9765 TEST(testNondegenerate2),
9766 TEST(testNondegenerate1),
9767 TEST(testDegenerate4x),
9768 TEST(testDegenerate3x),
9769 TEST(testDegenerate2x),
9770 TEST(testDegenerate1x),
9771 TEST(testDegenerate4),
9772 TEST(testDegenerate3),
9773 TEST(testDegenerate2),
9774 TEST(testDegenerate1),
9775 TEST(testLine79x),
9776 TEST(testLine78x),
9777 TEST(testLine77x),
9778 TEST(testLine76x),
9779 TEST(testLine75x),
9780 TEST(testLine74x),
9781 TEST(testLine73x),
9782 TEST(testLine72x),
9783 TEST(testLine71x),
9784 TEST(testLine70x),
9785 TEST(testLine69x),
9786 TEST(testLine68hx),
9787 TEST(testLine68gx),
9788 TEST(testLine68fx),
9789 TEST(testLine68ex),
9790 TEST(testLine68dx),
9791 TEST(testLine68cx),
9792 TEST(testLine68bx),
9793 TEST(testLine68ax),
9794 TEST(testLine67x),
9795 TEST(testLine66x),
9796 TEST(testLine65x),
9797 TEST(testLine64x),
9798 TEST(testLine63x),
9799 TEST(testLine62x),
9800 TEST(testLine61x),
9801 TEST(testLine60x),
9802 TEST(testLine59x),
9803 TEST(testLine58x),
9804 TEST(testLine57x),
9805 TEST(testLine56x),
9806 TEST(testLine55x),
9807 TEST(testLine54x),
9808 TEST(testLine53x),
9809 TEST(testLine52x),
9810 TEST(testLine51x),
9811 TEST(testLine50x),
9812 TEST(testLine49x),
9813 TEST(testLine48x),
9814 TEST(testLine47x),
9815 TEST(testLine46x),
9816 TEST(testLine45x),
9817 TEST(testLine44x),
9818 TEST(testLine43x),
9819 TEST(testLine42x),
9820 TEST(testLine41x),
9821 TEST(testLine40x),
9822 TEST(testLine38x),
9823 TEST(testLine37x),
9824 TEST(testLine36x),
9825 TEST(testLine35x),
9826 TEST(testLine34x),
9827 TEST(testLine33x),
9828 TEST(testLine32x),
9829 TEST(testLine31x),
9830 TEST(testLine30x),
9831 TEST(testLine29x),
9832 TEST(testLine28x),
9833 TEST(testLine27x),
9834 TEST(testLine26x),
9835 TEST(testLine25x),
9836 TEST(testLine24ax),
9837 TEST(testLine24x),
9838 TEST(testLine23x),
9839 TEST(testLine22x),
9840 TEST(testLine21x),
9841 TEST(testLine20x),
9842 TEST(testLine19x),
9843 TEST(testLine18x),
9844 TEST(testLine17x),
9845 TEST(testLine16x),
9846 TEST(testLine15x),
9847 TEST(testLine14x),
9848 TEST(testLine13x),
9849 TEST(testLine12x),
9850 TEST(testLine11x),
9851 TEST(testLine10ax),
9852 TEST(testLine10x),
9853 TEST(testLine9x),
9854 TEST(testLine8x),
9855 TEST(testLine7bx),
9856 TEST(testLine7ax),
9857 TEST(testLine7x),
9858 TEST(testLine6x),
9859 TEST(testLine5x),
9860 TEST(testLine4x),
9861 TEST(testLine3bx),
9862 TEST(testLine3ax),
9863 TEST(testLine3x),
9864 TEST(testLine2x),
9865 TEST(testLine1x),
9866 TEST(testLine81),
9867 TEST(testLine80),
9868 TEST(testLine79),
9869 TEST(testLine78),
9870 TEST(testLine77),
9871 TEST(testLine76),
9872 TEST(testLine75),
9873 TEST(testLine74),
9874 TEST(testLine73),
9875 TEST(testLine72),
9876 TEST(testLine71),
9877 TEST(testLine70),
9878 TEST(testLine69),
9879 TEST(testLine68h),
9880 TEST(testLine68g),
9881 TEST(testLine68f),
9882 TEST(testLine68e),
9883 TEST(testLine68d),
9884 TEST(testLine68c),
9885 TEST(testLine68b),
9886 TEST(testLine68a),
9887 TEST(testLine67),
9888 TEST(testLine66),
9889 TEST(testLine65),
9890 TEST(testLine64),
9891 TEST(testLine63),
9892 TEST(testLine62),
9893 TEST(testLine61),
9894 TEST(testLine60),
9895 TEST(testLine59),
9896 TEST(testLine58),
9897 TEST(testLine57),
9898 TEST(testLine56),
9899 TEST(testLine55),
9900 TEST(testLine54),
9901 TEST(testLine53),
9902 TEST(testLine52),
9903 TEST(testLine51),
9904 TEST(testLine50),
9905 TEST(testLine49),
9906 TEST(testLine48),
9907 TEST(testLine47),
9908 TEST(testLine46),
9909 TEST(testLine45),
9910 TEST(testLine44),
9911 TEST(testLine43),
9912 TEST(testLine42),
9913 TEST(testLine41),
9914 TEST(testLine40),
9915 TEST(testLine38),
9916 TEST(testLine37),
9917 TEST(testLine36),
9918 TEST(testLine35),
9919 TEST(testLine34),
9920 TEST(testLine33),
9921 TEST(testLine32),
9922 TEST(testLine31),
9923 TEST(testLine30),
9924 TEST(testLine29),
9925 TEST(testLine28),
9926 TEST(testLine27),
9927 TEST(testLine26),
9928 TEST(testLine25),
9929 TEST(testLine24a),
9930 TEST(testLine24),
9931 TEST(testLine23),
9932 TEST(testLine22),
9933 TEST(testLine21),
9934 TEST(testLine20),
9935 TEST(testLine19),
9936 TEST(testLine18),
9937 TEST(testLine17),
9938 TEST(testLine16),
9939 TEST(testLine15),
9940 TEST(testLine14),
9941 TEST(testLine13),
9942 TEST(testLine12),
9943 TEST(testLine11),
9944 TEST(testLine10a),
9945 TEST(testLine10),
9946 TEST(testLine9),
9947 TEST(testLine8),
9948 TEST(testLine7b),
9949 TEST(testLine7a),
9950 TEST(testLine7),
9951 TEST(testLine6),
9952 TEST(testLine5),
9953 TEST(testLine4),
9954 TEST(testLine3b),
9955 TEST(testLine3a),
9956 TEST(testLine3),
9957 TEST(testLine2),
9958 TEST(testLine1),
9959 TEST(testDegenerates),
9960};
9961
9962static const size_t testCount = std::size(tests);
9963
9964static TestDesc subTests[] = {
9965 TEST(fuzz994s_3414),
9966 TEST(fuzz994s_11),
9967};
9968
9969static const size_t subTestCount = std::size(subTests);
9970
9971static void (*firstSubTest)(skiatest::Reporter* , const char* filename) = nullptr;
9972
9973static bool runSubTests = false;
9974static bool runSubTestsFirst = false;
9975static bool runReverse = false;
9976
9977DEF_TEST(PathOpsSimplify, reporter) {
9978 if (runSubTests && runSubTestsFirst) {
9979 RunTestSet(reporter, subTests, subTestCount, firstSubTest, nullptr, stopTest, runReverse);
9980 }
9981 RunTestSet(reporter, tests, testCount, firstTest, skipTest, stopTest, runReverse);
9982 if (runSubTests && !runSubTestsFirst) {
9983 RunTestSet(reporter, subTests, subTestCount, firstSubTest, nullptr, stopTest, runReverse);
9984 }
9985}
reporter
reporter
Definition: FontMgrTest.cpp:39
markTestFlakyForPathKit
void markTestFlakyForPathKit()
Definition: PathOpsExtendedTest.cpp:369
testSimplify
bool testSimplify(SkPath &path, bool useXor, SkPath &out, PathOpsThreadState &state, const char *pathStr)
Definition: PathOpsExtendedTest.cpp:376
RunTestSet
void RunTestSet(skiatest::Reporter *reporter, TestDesc tests[], size_t count, void(*firstTest)(skiatest::Reporter *, const char *filename), void(*skipTest)(skiatest::Reporter *, const char *filename), void(*stopTest)(skiatest::Reporter *, const char *filename), bool reverse)
Definition: PathOpsExtendedTest.cpp:691
testSimplifyFail
bool testSimplifyFail(skiatest::Reporter *reporter, const SkPath &path, const char *filename)
Definition: PathOpsExtendedTest.cpp:542
testQuads26
static void testQuads26(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4249
testQuadralateral3
static void testQuadralateral3(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4021
fuzz994s_11
static void fuzz994s_11(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4942
testQuadratic97
static void testQuadratic97(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3664
make_joel_13
static void make_joel_13(SkPath &path)
Definition: PathOpsSimplifyTest.cpp:7215
joel_4
static void joel_4(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5829
fuzz_twister2
static void fuzz_twister2(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5075
testDegenerate2x
static void testDegenerate2x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1766
testLine35x
static void testLine35x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:829
testLine68fx
static void testLine68fx(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1467
testQuads49
static void testQuads49(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4520
testQuadratic72
static void testQuadratic72(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3072
testLine3bx
static void testLine3bx(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:154
testQuads27
static void testQuads27(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4262
DEF_TEST
DEF_TEST(PathOpsSimplify, reporter)
Definition: PathOpsSimplifyTest.cpp:9977
testQuadratic63
static void testQuadratic63(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2965
testEight6
static void testEight6(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3226
testLine46x
static void testLine46x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:999
testLine26
static void testLine26(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:676
testLine82g
static void testLine82g(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3504
testQuadratic3x
static void testQuadratic3x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2413
testLine68f
static void testLine68f(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1458
testLine24a
static void testLine24a(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:619
testLine25
static void testLine25(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:661
testLine15
static void testLine15(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:486
testQuadralateral4
static void testQuadralateral4(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4051
testQuads20
static void testQuads20(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4171
testLine43x
static void testLine43x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:948
testLine51x
static void testLine51x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1082
testLine2x
static void testLine2x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:109
testLine1a
static void testLine1a(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2303
testQuads32
static void testQuads32(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4329
testLine50x
static void testLine50x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1066
testQuads58
static void testQuads58(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4649
testQuadratic58
static void testQuadratic58(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2905
testQuadratic73
static void testQuadratic73(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3085
testLine12
static void testLine12(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:441
testLine23
static void testLine23(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:604
testQuads52
static void testQuads52(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4484
testQuads33
static void testQuads33(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4342
testQuadratic7
static void testQuadratic7(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2480
testQuadralateral7
static void testQuadralateral7(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2210
testLine77
static void testLine77(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1661
joel_5
static void joel_5(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:6583
testQuads72
static void testQuads72(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5563
testLine24x
static void testLine24x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:653
testLine9x
static void testLine9x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:330
bug8249
static void bug8249(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:9318
testQuadratic2x
static void testQuadratic2x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2386
testLine29x
static void testLine29x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:728
testLine82h
static void testLine82h(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3512
testQuads36
static void testQuads36(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4381
testLine85
static void testLine85(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3547
testLine71
static void testLine71(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1553
testQuads28
static void testQuads28(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4275
testQuadratic96
static void testQuadratic96(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3654
testQuadratic20
static void testQuadratic20(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2586
testLine40
static void testLine40(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:889
testQuadratic19
static void testQuadratic19(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2573
testLine19x
static void testLine19x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:551
testLine78x
static void testLine78x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1687
testQuadralateral6x
static void testQuadralateral6x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1988
testLine51
static void testLine51(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1074
testLine36x
static void testLine36x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:846
testLine53
static void testLine53(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1108
testLine25x
static void testLine25x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:668
testQuad2
static void testQuad2(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3743
testLine52x
static void testLine52x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1099
testLine68ex
static void testLine68ex(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1448
fuzz994s_3414
static void fuzz994s_3414(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5008
testQuads31
static void testQuads31(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4315
testQuads48
static void testQuads48(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4532
testLine62
static void testLine62(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1261
testQuads41
static void testQuads41(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4446
testLine17
static void testLine17(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:514
testLine55
static void testLine55(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1142
testLine44
static void testLine44(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:957
testLine53x
static void testLine53x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1116
testQuads71
static void testQuads71(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5550
testQuadratic78
static void testQuadratic78(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3150
testQuadratic64
static void testQuadratic64(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2978
testLine34
static void testLine34(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:804
testLine82c
static void testLine82c(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3472
testQuads22
static void testQuads22(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4197
testQuadralateral5x
static void testQuadralateral5x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1957
testLine80
static void testLine80(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2891
bug5169
static void bug5169(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5589
bug11958_a
static void bug11958_a(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:9404
testLine29
static void testLine29(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:721
testQuad13
static void testQuad13(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4079
testQuadratic31
static void testQuadratic31(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2729
testQuads17
static void testQuads17(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4132
testLine38
static void testLine38(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:872
testQuadratic18
static void testQuadratic18(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2560
testQuad14
static void testQuad14(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4092
carsvg_1
static void carsvg_1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5610
testQuadralateral9x
static void testQuadralateral9x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2287
testLine22
static void testLine22(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:589
testLine63x
static void testLine63x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1289
testLine37x
static void testLine37x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:863
testLine33x
static void testLine33x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:795
testLine54
static void testLine54(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1125
testLine44x
static void testLine44x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:965
testLine4ax
static void testLine4ax(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2337
testLine42x
static void testLine42x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:931
testLine32x
static void testLine32x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:778
testQuads39
static void testQuads39(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4421
testEight2
static void testEight2(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3186
testQuads24
static void testQuads24(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4223
testLine7bx
static void testLine7bx(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:277
testLine68b
static void testLine68b(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1388
testQuadralateral8
static void testQuadralateral8(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2241
testLine16x
static void testLine16x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:506
testLine7
static void testLine7(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:219
addInnerCWTriangle
static void addInnerCWTriangle(SkPath &path)
Definition: PathOpsSimplifyTest.cpp:74
testQuadratic4
static void testQuadratic4(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2427
testQuads53
static void testQuads53(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4472
testDegenerate3x
static void testDegenerate3x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1793
joel_9
static void joel_9(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:6969
joel_12
static void joel_12(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:7202
testQuad3
static void testQuad3(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3755
testQuad8
static void testQuad8(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3941
joel_16x
static void joel_16x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:7723
testLine31x
static void testLine31x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:761
testLine3
static void testLine3(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:117
testQuadratic75
static void testQuadratic75(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3111
testQuadratic84
static void testQuadratic84(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3328
testLine28x
static void testLine28x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:713
testLine26x
static void testLine26x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:683
simplifyTest_1
static void simplifyTest_1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5629
testQuadralateral7x
static void testQuadralateral7x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2225
testQuadratic65
static void testQuadratic65(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2991
testIssue3838_3
static void testIssue3838_3(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4833
testDegenerate3
static void testDegenerate3(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1780
testQuadratic74
static void testQuadratic74(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3098
testLine82b
static void testLine82b(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3464
testAddTCoincident1
static void testAddTCoincident1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3706
TEST
#define TEST(name)
Definition: PathOpsSimplifyTest.cpp:22
testQuadralateral2
static void testQuadralateral2(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3618
testQuadratic59
static void testQuadratic59(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2951
testDegenerates
static void testDegenerates(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:24
testTriangles1
static void testTriangles1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3674
testQuads19
static void testQuads19(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4158
testQuadratic68
static void testQuadratic68(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3018
testEight7
static void testEight7(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3236
testLine68g
static void testLine68g(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1477
testLine43
static void testLine43(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:940
testRect2s
static void testRect2s(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3901
testLine37
static void testLine37(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:855
addCWContainer
static void addCWContainer(SkPath &path)
Definition: PathOpsSimplifyTest.cpp:398
testLine60
static void testLine60(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1227
joel_6
static void joel_6(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:6834
testQuadratic51
static void testQuadratic51(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2834
testQuadratic33
static void testQuadratic33(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2755
testLine68bx
static void testLine68bx(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1396
testFauxQuadralateral6b
static void testFauxQuadralateral6b(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2074
testFauxQuadralateral6
static void testFauxQuadralateral6(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2004
testLine69
static void testLine69(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1519
testQuads25
static void testQuads25(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4236
testQuadratic81
static void testQuadratic81(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3289
testQuadratic70x
static void testQuadratic70x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3045
testTriangles2
static void testTriangles2(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3687
testQuads35
static void testQuads35(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4368
testQuad4
static void testQuad4(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3768
testLine5x
static void testLine5x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:184
testLine56
static void testLine56(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1159
testQuadralateral8x
static void testQuadralateral8x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2256
testLine58
static void testLine58(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1193
testQuad12
static void testQuad12(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4008
joel_14
static void joel_14(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:7423
testLine17x
static void testLine17x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:521
testQuadralateral5
static void testQuadralateral5(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1942
testLine46
static void testLine46(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:991
testNondegenerate2x
static void testNondegenerate2x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1874
testIssue3838
static void testIssue3838(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4810
testQuad9
static void testQuad9(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3968
testQuads68
static void testQuads68(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5511
testLine77x
static void testLine77x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1669
addCWContents
static void addCWContents(SkPath &path)
Definition: PathOpsSimplifyTest.cpp:412
testLine47x
static void testLine47x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1016
testRect3
static void testRect3(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4718
testLine68cx
static void testLine68cx(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1413
testNondegenerate3
static void testNondegenerate3(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1888
testLine68d
static void testLine68d(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1422
testQuadratic91
static void testQuadratic91(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3421
testQuadratic4x
static void testQuadratic4x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2440
testLine82f
static void testLine82f(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3496
testQuads46x
static void testQuads46x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4557
testLine18x
static void testLine18x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:536
testLine74
static void testLine74(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1606
testQuads45
static void testQuads45(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4571
fuzz763_4713_b
static void fuzz763_4713_b(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5106
testLine49x
static void testLine49x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1050
testQuadratic29
static void testQuadratic29(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2703
testLine27
static void testLine27(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:691
testLine78
static void testLine78(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1678
testQuadratic9
static void testQuadratic9(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2507
testRect1s
static void testRect1s(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3892
testQuads60
static void testQuads60(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4675
testQuads51
static void testQuads51(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4496
testLine14x
static void testLine14x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:478
testQuadratic82
static void testQuadratic82(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3302
testLine1
static void testLine1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:55
testLine3b
static void testLine3b(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:147
testLine7x
static void testLine7x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:232
testQuads61
static void testQuads61(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4688
testEight8
static void testEight8(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3246
testDegenerate5
static void testDegenerate5(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4038
testQuads64
static void testQuads64(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4764
testLine50
static void testLine50(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1059
testLine74x
static void testLine74x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1614
testLine64
static void testLine64(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1299
testLine68e
static void testLine68e(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1439
testLine52
static void testLine52(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1091
testQuadratic69
static void testQuadratic69(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3031
testLine68hx
static void testLine68hx(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1508
testLine8
static void testLine8(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:290
testLine54x
static void testLine54x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1133
testLine67x
static void testLine67x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1361
testQuadratic3
static void testQuadratic3(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2400
testLine57
static void testLine57(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1176
coincubics
static void coincubics(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:7730
testCount
static const size_t testCount
Definition: PathOpsSimplifyTest.cpp:9962
make_joel_15
static void make_joel_15(SkPath &path)
Definition: PathOpsSimplifyTest.cpp:7436
testArc
static void testArc(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4803
testLine10ax
static void testLine10ax(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:384
testLine48x
static void testLine48x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1033
testQuadratic34
static void testQuadratic34(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2768
testQuads43
static void testQuads43(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4597
testQuads47
static void testQuads47(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4544
testQuadLineIntersect2
static void testQuadLineIntersect2(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3833
testDegenerates1
static void testDegenerates1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4066
testQuadratic90x
static void testQuadratic90x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3407
testFauxQuadralateral6dx
static void testFauxQuadralateral6dx(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2161
testQuadratic53
static void testQuadratic53(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2847
testLine66x
static void testLine66x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1343
addCCWContents
static void addCCWContents(SkPath &path)
Definition: PathOpsSimplifyTest.cpp:419
addOuterCCWTriangle
static void addOuterCCWTriangle(SkPath &path)
Definition: PathOpsSimplifyTest.cpp:95
testDegenerate4x
static void testDegenerate4x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1820
testQuads42
static void testQuads42(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4610
testLine67
static void testLine67(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1352
tests
static TestDesc tests[]
Definition: PathOpsSimplifyTest.cpp:9489
testLine12x
static void testLine12x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:448
testLine14
static void testLine14(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:471
testQuads70
static void testQuads70(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5537
testTriangle1
static void testTriangle1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4777
joel_7
static void joel_7(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:6896
testQuads38
static void testQuads38(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4408
testQuad5
static void testQuad5(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3781
testNondegenerate1x
static void testNondegenerate1x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1847
testLine38x
static void testLine38x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:880
testLine7b
static void testLine7b(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:265
testLine20
static void testLine20(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:559
testQuads34
static void testQuads34(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4355
testLine82a
static void testLine82a(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3456
testEight9
static void testEight9(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3256
testLine36
static void testLine36(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:838
testLine34x
static void testLine34x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:812
make_joel_12
static void make_joel_12(SkPath &path)
Definition: PathOpsSimplifyTest.cpp:7147
testQuadratic76
static void testQuadratic76(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3124
testLine47
static void testLine47(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1008
testLine40x
static void testLine40x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:897
testQuadralateral10
static void testQuadralateral10(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4702
fuzz_twister
static void fuzz_twister(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5045
testFauxQuadralateral6cx
static void testFauxQuadralateral6cx(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2126
testFauxQuadralateral6a
static void testFauxQuadralateral6a(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2039
testQuads30
static void testQuads30(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4301
testLine76x
static void testLine76x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1651
testLine4
static void testLine4(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:162
testLine68c
static void testLine68c(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1405
testQuads37
static void testQuads37(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4394
testLine5
static void testLine5(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:177
testLine48
static void testLine48(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1025
testQuadratic38
static void testQuadratic38(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2821
testLine75x
static void testLine75x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1632
testQuadLineIntersect3
static void testQuadLineIntersect3(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3846
testQuadratic92x
static void testQuadratic92x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3434
testLine68h
static void testLine68h(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1498
testQuads69
static void testQuads69(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5524
testQuadratic80
static void testQuadratic80(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3276
testLine1ax
static void testLine1ax(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2311
testLine65x
static void testLine65x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1325
testNondegenerate2
static void testNondegenerate2(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1861
joel_8
static void joel_8(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:6951
testQuadratic88
static void testQuadratic88(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3380
testCubic1
static void testCubic1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3571
testLine66
static void testLine66(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1335
testQuadratic6
static void testQuadratic6(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2467
skphealth_com76s
static void skphealth_com76s(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3859
testLine72
static void testLine72(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1570
testLine63
static void testLine63(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1280
runSubTests
static bool runSubTests
Definition: PathOpsSimplifyTest.cpp:9973
testLine21
static void testLine21(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:574
testQuads18
static void testQuads18(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4145
dean4
static void dean4(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5141
testNondegenerate3x
static void testNondegenerate3x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1901
make_joel_16
static void make_joel_16(SkPath &path)
Definition: PathOpsSimplifyTest.cpp:7592
testQuadratic21
static void testQuadratic21(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2599
testQuadratic30
static void testQuadratic30(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2716
testQuadratic23
static void testQuadratic23(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2625
testQuadratic37
static void testQuadratic37(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2808
testQuadratic93
static void testQuadratic93(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3582
testLine31
static void testLine31(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:753
testNondegenerate4
static void testNondegenerate4(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1915
testLine59
static void testLine59(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1210
testLine6x
static void testLine6x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:205
testLine35
static void testLine35(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:821
testLine59x
static void testLine59x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1218
testLine3aax
static void testLine3aax(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2328
testLine73x
static void testLine73x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1596
fuzz864a
static void fuzz864a(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4861
testQuadratic71
static void testQuadratic71(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3059
testQuads56
static void testQuads56(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4623
testDegenerate4
static void testDegenerate4(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1807
testLine16
static void testLine16(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:499
testLine11x
static void testLine11x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:433
stopTest
static void(* stopTest)(skiatest::Reporter *, const char *filename)
Definition: PathOpsSimplifyTest.cpp:9487
testQuadralateral1
static void testQuadralateral1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3556
testDegenerate1
static void testDegenerate1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1726
testLine1x
static void testLine1x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:64
testQuadratic77
static void testQuadratic77(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3137
testQuadratic55
static void testQuadratic55(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2861
testDegenerate1x
static void testDegenerate1x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1739
testQuadratic83
static void testQuadratic83(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3315
testLine3x
static void testLine3x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:124
testLine70x
static void testLine70x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1544
bug11958_b
static void bug11958_b(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:9427
testQuads50
static void testQuads50(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4508
testQuadratic86
static void testQuadratic86(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3354
testQuadratic85
static void testQuadratic85(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3341
testLine72x
static void testLine72x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1578
tooCloseTest
static void tooCloseTest(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3878
testFauxQuadralateral6ax
static void testFauxQuadralateral6ax(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2056
testQuads23
static void testQuads23(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4210
testLine76
static void testLine76(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1642
testLine4x
static void testLine4x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:169
testLine21x
static void testLine21x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:581
testLine68dx
static void testLine68dx(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1430
testLine28
static void testLine28(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:706
testLine45x
static void testLine45x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:982
testLine2
static void testLine2(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:102
runSubTestsFirst
static bool runSubTestsFirst
Definition: PathOpsSimplifyTest.cpp:9974
testQuadratic2
static void testQuadratic2(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2373
testQuadratic67x
static void testQuadratic67x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3004
testQuadratic5
static void testQuadratic5(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2454
cr514118
static void cr514118(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4925
testLine15x
static void testLine15x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:492
testLine3ax
static void testLine3ax(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:139
joel_13
static void joel_13(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:7224
testQuad10
static void testQuad10(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3982
testQuadralateral6a
static void testQuadralateral6a(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2179
testTriangles4x
static void testTriangles4x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3954
testQuadratic26
static void testQuadratic26(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2664
testTriangle2
static void testTriangle2(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4790
bug11958_c
static void bug11958_c(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:9465
testLine10
static void testLine10(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:344
testQuadratic22
static void testQuadratic22(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2612
testLine73
static void testLine73(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1587
testLine30x
static void testLine30x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:744
testQuadralateral9
static void testQuadralateral9(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2272
tiger8_393
static void tiger8_393(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5598
grshapearc
static void grshapearc(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:7743
testLine60x
static void testLine60x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1235
testLine65
static void testLine65(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1316
testQuadratic24
static void testQuadratic24(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2638
testLine7ax
static void testLine7ax(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:255
testQuads63
static void testQuads63(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4751
testLine49
static void testLine49(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1042
testLine81
static void testLine81(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1716
testLine10a
static void testLine10a(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:371
testEight1
static void testEight1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3176
testDegenerate2
static void testDegenerate2(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1753
testQuadratic32
static void testQuadratic32(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2742
testCubic2
static void testCubic2(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3595
testQuadratic59x
static void testQuadratic59x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2937
testQuads57
static void testQuads57(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4636
testLine18
static void testLine18(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:529
testLine57x
static void testLine57x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1184
testLine8x
static void testLine8x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:303
testLine7a
static void testLine7a(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:246
testFauxQuadralateral6d
static void testFauxQuadralateral6d(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2144
testQuadratic8
static void testQuadratic8(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2494
joel_14x
static void joel_14x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:7429
testLine30
static void testLine30(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:736
testLine27x
static void testLine27x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:698
addOuterCWTriangle
static void addOuterCWTriangle(SkPath &path)
Definition: PathOpsSimplifyTest.cpp:88
testQuads40
static void testQuads40(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4433
testQuadratic87
static void testQuadratic87(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3367
joel_2
static void joel_2(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5731
testQuadratic14
static void testQuadratic14(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2520
testLine84x
static void testLine84x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3537
joel_12x
static void joel_12x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:7208
testLine41
static void testLine41(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:906
testLine68a
static void testLine68a(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1371
testLine10x
static void testLine10x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:357
testLine6
static void testLine6(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:192
testLine23x
static void testLine23x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:611
testLine2ax
static void testLine2ax(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2319
testEight10
static void testEight10(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3266
testLine82e
static void testLine82e(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3488
testQuadratic56
static void testQuadratic56(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2875
testQuadratic1x
static void testQuadratic1x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2359
subTestCount
static const size_t subTestCount
Definition: PathOpsSimplifyTest.cpp:9969
testLine41x
static void testLine41x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:914
testLine79x
static void testLine79x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1706
testNondegenerate4x
static void testNondegenerate4x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1928
make_joel_14
static void make_joel_14(SkPath &path)
Definition: PathOpsSimplifyTest.cpp:7238
testQuads73
static void testQuads73(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5576
testQuadratic94
static void testQuadratic94(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3634
testLine24ax
static void testLine24ax(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:632
testQuads67
static void testQuads67(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5498
testLine64x
static void testLine64x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1307
testQuadratic79
static void testQuadratic79(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3163
testLine84
static void testLine84(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3528
testQuadralateral6ax
static void testQuadralateral6ax(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2194
joel_10
static void joel_10(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:7028
testLine19
static void testLine19(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:544
testQuadLineIntersect1
static void testQuadLineIntersect1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3820
joel_13x
static void joel_13x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:7231
testQuadratic25
static void testQuadratic25(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2651
testQuads29
static void testQuads29(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4288
testQuads21
static void testQuads21(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4184
addCCWContainer
static void addCCWContainer(SkPath &path)
Definition: PathOpsSimplifyTest.cpp:405
testQuadratic35
static void testQuadratic35(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2782
testLine22x
static void testLine22x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:596
testEight3
static void testEight3(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3196
testQuadratic28
static void testQuadratic28(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2690
testQuads54
static void testQuads54(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4460
testQuadralateral6
static void testQuadralateral6(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1973
firstTest
static void(* firstTest)(skiatest::Reporter *, const char *filename)
Definition: PathOpsSimplifyTest.cpp:9486
testFauxQuadralateral6x
static void testFauxQuadralateral6x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2021
testLine82
static void testLine82(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3448
testQuad15
static void testQuad15(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4106
testQuads44
static void testQuads44(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4584
testLine83
static void testLine83(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3520
testEight4
static void testEight4(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3206
subTests
static TestDesc subTests[]
Definition: PathOpsSimplifyTest.cpp:9964
testLine69x
static void testLine69x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1527
testLine13
static void testLine13(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:456
testLine32
static void testLine32(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:770
testQuad7
static void testQuad7(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3807
testQuadratic17x
static void testQuadratic17x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2546
testQuads16
static void testQuads16(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4119
testQuad6
static void testQuad6(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3794
testLine71x
static void testLine71x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1561
testLine45
static void testLine45(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:974
joel_1
static void joel_1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5674
testLine68gx
static void testLine68gx(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1487
testLine61
static void testLine61(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1244
joel_15x
static void joel_15x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:7585
joel_16
static void joel_16(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:7717
firstSubTest
static void(* firstSubTest)(skiatest::Reporter *, const char *filename)
Definition: PathOpsSimplifyTest.cpp:9971
testLine33
static void testLine33(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:787
testLine62x
static void testLine62x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1270
testQuads62
static void testQuads62(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4738
testLine82d
static void testLine82d(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3480
joel_3
static void joel_3(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5766
testAddTCoincident2
static void testAddTCoincident2(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3726
skipTest
static void(* skipTest)(skiatest::Reporter *, const char *filename)
Definition: PathOpsSimplifyTest.cpp:9485
testLine58x
static void testLine58x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1201
testLine61x
static void testLine61x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1252
testLine20x
static void testLine20x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:566
testFauxQuadralateral6bx
static void testFauxQuadralateral6bx(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2091
testLine9
static void testLine9(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:317
joel_15
static void joel_15(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:7579
testQuadratic27
static void testQuadratic27(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2677
testLine55x
static void testLine55x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1150
runReverse
static bool runReverse
Definition: PathOpsSimplifyTest.cpp:9975
testQuadratic15
static void testQuadratic15(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2533
testQuad11
static void testQuad11(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3995
testEight5
static void testEight5(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3216
testTriangles3x
static void testTriangles3x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3927
testLine56x
static void testLine56x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1167
testQuadratic89x
static void testQuadratic89x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3393
testQuads65
static void testQuads65(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4848
testQuads66
static void testQuads66(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:5485
testLine24
static void testLine24(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:646
testQuadratic95
static void testQuadratic95(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3644
testNondegenerate1
static void testNondegenerate1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1834
testQuadratic36
static void testQuadratic36(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2795
testLine11
static void testLine11(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:426
testLine70
static void testLine70(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1536
testQuadratic1
static void testQuadratic1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2346
joel_11
static void joel_11(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:7087
bug8290
static void bug8290(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:9345
testLine68ax
static void testLine68ax(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1379
addInnerCCWTriangle
static void addInnerCCWTriangle(SkPath &path)
Definition: PathOpsSimplifyTest.cpp:81
testLine75
static void testLine75(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1623
testQuad1
static void testQuad1(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:3606
testLine13x
static void testLine13x(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:463
testLine3a
static void testLine3a(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:132
testQuads59
static void testQuads59(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4662
testLine42
static void testLine42(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:923
testFauxQuadralateral6c
static void testFauxQuadralateral6c(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:2109
testLine79
static void testLine79(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:1697
testRect4
static void testRect4(skiatest::Reporter *reporter, const char *filename)
Definition: PathOpsSimplifyTest.cpp:4728
SkBits2Float
static float SkBits2Float(uint32_t bits)
Definition: SkFloatBits.h:48
Simplify
bool SK_API Simplify(const SkPath &path, SkPath *result)
Definition: SkPathOpsSimplify.cpp:283
SkPathFillType
SkPathFillType
Definition: SkPathTypes.h:11
SkDoubleToScalar
#define SkDoubleToScalar(x)
Definition: SkScalar.h:64
REPORTER_ASSERT
#define REPORTER_ASSERT(r, cond,...)
Definition: Test.h:286
SkMatrix::MakeAll
static SkMatrix MakeAll(SkScalar scaleX, SkScalar skewX, SkScalar transX, SkScalar skewY, SkScalar scaleY, SkScalar transY, SkScalar pers0, SkScalar pers1, SkScalar pers2)
Definition: SkMatrix.h:179
SkPath
Definition: SkPath.h:59
SkPath::isEmpty
bool isEmpty() const
Definition: SkPath.cpp:416
SkPath::lineTo
SkPath & lineTo(SkScalar x, SkScalar y)
Definition: SkPath.cpp:728
SkPath::reset
SkPath & reset()
Definition: SkPath.cpp:370
SkRecords::matrix
unsigned useCenter Optional< SkMatrix > matrix
Definition: SkRecords.h:258
flutter::path
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir path
Definition: switches.h:57
flutter::size
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap size
Definition: switches.h:259
protoc_wrapper.e
e
Definition: protoc_wrapper.py:226
SkRect::MakeWH
static constexpr SkRect MakeWH(float w, float h)
Definition: SkRect.h:609
Generated on Sun Jun 23 2024 21:56:45 for Flutter Engine by doxygen 1.9.4