Lines Matching full:path
12 PathTest_Private(SkPath* path)
13 : fPath(path) {}
22 static void path_edit(const SkPoint& from, const SkPoint& to, SkPath* path) {
23 PathTest_Private testPath(path);
24 for (int index = 0; index < path->countPoints(); ++index) {
25 if (SkDPoint::ApproximatelyEqual(path->getPoint(index), from)) {
33 SkPath path, pathB;
34 path.setFillType(SkPath::kWinding_FillType);
35 path.moveTo(0,1);
36 path.cubicTo(0,2, 1,0, 1,0);
37 path.close();
42 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
46 SkPath path, pathB;
47 path.setFillType(SkPath::kWinding_FillType);
48 path.moveTo(0,2);
49 path.cubicTo(0,1, 1,0, 1,0);
50 path.close();
55 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
59 SkPath path, pathB;
60 path.setFillType(SkPath::kWinding_FillType);
61 path.moveTo(0,1);
62 path.cubicTo(2,3, 1,0, 1,0);
63 path.close();
68 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
72 SkPath path, pathB;
73 path.setFillType(SkPath::kWinding_FillType);
74 path.moveTo(0,1);
75 path.cubicTo(0,2, 1,0, 2,0);
76 path.close();
81 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
85 SkPath path, pathB;
86 path.setFillType(SkPath::kWinding_FillType);
87 path.moveTo(0,1);
88 path.cubicTo(0,6, 1,0, 3,0);
89 path.close();
94 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
98 SkPath path, pathB;
99 path.setFillType(SkPath::kWinding_FillType);
100 path.moveTo(0,1);
101 path.cubicTo(3,4, 1,0, 3,0);
102 path.close();
107 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
111 SkPath path, pathB;
112 path.setFillType(SkPath::kWinding_FillType);
113 path.moveTo(0,1);
114 path.cubicTo(0,5, 1,0, 4,0);
115 path.close();
120 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
124 SkPath path, pathB;
125 path.setFillType(SkPath::kWinding_FillType);
126 path.moveTo(0,1);
127 path.cubicTo(1,6, 1,0, 2,1);
128 path.close();
133 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
137 SkPath path, pathB;
138 path.setFillType(SkPath::kWinding_FillType);
139 path.moveTo(0,1);
140 path.quadTo(1,6, 1.5f,1);
141 path.quadTo(1.5f,0.5f, 2,1);
142 path.close();
148 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
152 SkPath path, pathB;
153 path.setFillType(SkPath::kWinding_FillType);
154 path.moveTo(0,1);
155 path.lineTo(1,6);
156 path.lineTo(1.5f,1);
157 path.lineTo(1.8f,0.8f);
158 path.lineTo(2,1);
159 path.close();
167 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
171 SkPath path, pathB;
172 path.setFillType(SkPath::kWinding_FillType);
173 path.moveTo(0,1);
174 path.cubicTo(1,2, 1,0, 2,1);
175 path.close();
180 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
184 SkPath path, pathB;
185 path.setFillType(SkPath::kWinding_FillType);
186 path.moveTo(0,1);
187 path.cubicTo(1,3, 1,0, 4,1);
188 path.close();
193 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
197 SkPath path, pathB;
198 path.setFillType(SkPath::kWinding_FillType);
199 path.moveTo(0,1);
200 path.cubicTo(3,4, 1,0, 5,1);
201 path.close();
206 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
210 SkPath path, pathB;
211 path.setFillType(SkPath::kWinding_FillType);
212 path.moveTo(0,1);
213 path.cubicTo(1,6, 1,0, 1,0);
214 path.close();
219 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
223 SkPath path, pathB;
224 path.setFillType(SkPath::kWinding_FillType);
225 path.moveTo(0,1);
226 path.cubicTo(4,5, 1,0, 5,3);
227 path.close();
232 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
236 SkPath path, pathB;
237 path.setFillType(SkPath::kWinding_FillType);
238 path.moveTo(0,1);
239 path.cubicTo(0,2, 2,0, 2,1);
240 path.close();
245 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
249 SkPath path, pathB;
250 path.setFillType(SkPath::kWinding_FillType);
251 path.moveTo(0,1);
252 path.cubicTo(3,6, 2,0, 2,1);
253 path.close();
258 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
262 SkPath path, pathB;
263 path.setFillType(SkPath::kWinding_FillType);
264 path.moveTo(0,2);
265 path.cubicTo(0,1, 3,0, 1,0);
266 path.close();
271 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
275 SkPath path, pathB;
276 path.setFillType(SkPath::kWinding_FillType);
277 path.moveTo(0,2);
278 path.cubicTo(0,2, 4,0, 2,1);
279 path.close();
284 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
288 SkPath path, pathB;
289 path.setFillType(SkPath::kWinding_FillType);
290 path.moveTo(0,1);
291 path.cubicTo(3,5, 2,0, 2,1);
292 path.close();
297 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
301 SkPath path, pathB;
302 path.setFillType(SkPath::kWinding_FillType);
303 path.moveTo(0,2);
304 path.cubicTo(0,1, 2,1, 6,2);
305 path.close();
310 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
314 SkPath path, pathB;
315 path.setFillType(SkPath::kWinding_FillType);
316 path.moveTo(0,1);
317 path.cubicTo(0,1, 6,0, 2,1);
318 path.close();
323 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
327 SkPath path, pathB;
328 path.setFillType(SkPath::kWinding_FillType);
329 path.moveTo(0,1);
330 path.cubicTo(0,1, 2,1, 6,5);
331 path.close();
336 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
340 SkPath path, pathB;
341 path.setFillType(SkPath::kWinding_FillType);
342 path.moveTo(0,1);
343 path.cubicTo(2,3, 3,0, 2,1);
344 path.close();
349 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
353 SkPath path, pathB;
354 path.setFillType(SkPath::kWinding_FillType);
355 path.moveTo(0,1);
356 path.cubicTo(1,2, 4,0, 2,1);
357 path.close();
362 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
366 SkPath path, pathB;
367 path.setFillType(SkPath::kWinding_FillType);
368 path.moveTo(0,1);
369 path.cubicTo(1,2, 2,0, 3,2);
370 path.close();
375 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
435 SkPath path, pathB;
436 path.setFillType(SkPath::kWinding_FillType);
437 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
438 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
442 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
446 SkPath path, pathB;
447 path.setFillType(SkPath::kWinding_FillType);
448 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
449 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
453 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
457 SkPath path, pathB;
458 path.setFillType(SkPath::kWinding_FillType);
459 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
460 path.addRect(1, 1, 2, 2, SkPath::kCW_Direction);
464 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
468 SkPath path, pathB;
469 path.setFillType(SkPath::kWinding_FillType);
470 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
471 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
475 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
479 SkPath path, pathB;
480 path.setFillType(SkPath::kWinding_FillType);
481 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
482 path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
486 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
490 SkPath path, pathB;
491 path.setFillType(SkPath::kEvenOdd_FillType);
492 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
493 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
497 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
501 SkPath path, pathB;
502 path.setFillType(SkPath::kEvenOdd_FillType);
503 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
504 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
508 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
512 SkPath path, pathB;
513 path.setFillType(SkPath::kEvenOdd_FillType);
514 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
515 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
519 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
523 SkPath path, pathB;
524 path.setFillType(SkPath::kEvenOdd_FillType);
525 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
526 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
530 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
534 SkPath path, pathB;
535 path.addRect(0, 0, 640, 480);
539 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
542 SkPath path, pathB;
543 path.setFillType(SkPath::kWinding_FillType);
544 path.moveTo(0,1);
545 path.cubicTo(2,4, 5,0, 3,2);
546 path.close();
551 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
555 SkPath path, pathB;
556 path.setFillType(SkPath::kWinding_FillType);
557 path.moveTo(0,1);
558 path.cubicTo(3,4, 4,0, 3,2);
559 path.close();
564 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
568 SkPath path, pathB;
569 path.setFillType(SkPath::kWinding_FillType);
570 path.moveTo(0,1);
571 path.cubicTo(3,6, 1,0, 5,2);
572 path.close();
577 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
581 SkPath path, pathB;
582 path.setFillType(SkPath::kWinding_FillType);
583 path.moveTo(0,1);
584 path.cubicTo(1,4, 6,0, 3,2);
585 path.close();
590 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
594 SkPath path, pathB;
595 path.setFillType(SkPath::kWinding_FillType);
596 path.moveTo(0,1);
597 path.cubicTo(2,5, 6,0, 4,2);
598 path.close();
603 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
607 SkPath path, pathB;
608 path.setFillType(SkPath::kWinding_FillType);
609 path.moveTo(0,1);
610 path.cubicTo(2,5, 6,0, 5,3);
611 path.close();
616 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
620 SkPath path, pathB;
621 path.setFillType(SkPath::kWinding_FillType);
622 path.moveTo(0,2);
623 path.cubicTo(0,3, 2,1, 4,0);
624 path.close();
629 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
633 SkPath path, pathB;
634 path.setFillType(SkPath::kWinding_FillType);
635 path.moveTo(0,2);
636 path.cubicTo(0,3, 2,1, 4,0);
637 path.close();
642 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
646 SkPath path, pathB;
647 path.setFillType(SkPath::kWinding_FillType);
648 path.moveTo(0,2);
649 path.cubicTo(0,3, 2,1, 4,0);
650 path.close();
655 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
659 SkPath path, pathB;
660 path.setFillType(SkPath::kWinding_FillType);
661 path.moveTo(0,1);
662 path.cubicTo(1,2, 6,0, 3,1);
663 path.close();
668 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
672 SkPath path, pathB;
673 path.setFillType(SkPath::kWinding_FillType);
674 path.moveTo(0,1);
675 path.cubicTo(1,2, 6,0, 3,1);
676 path.close();
681 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
685 SkPath path, pathB;
686 path.setFillType(SkPath::kWinding_FillType);
687 path.moveTo(0,1);
688 path.cubicTo(3,5, 2,1, 3,1);
689 path.close();
694 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
698 SkPath path, pathB;
699 path.setFillType(SkPath::kWinding_FillType);
700 path.moveTo(0,1);
701 path.cubicTo(1,5, 2,1, 4,0);
702 path.close();
707 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
711 SkPath path, pathB;
712 path.setFillType(SkPath::kWinding_FillType);
713 path.moveTo(0,1);
714 path.cubicTo(1,6, 2,0, 5,1);
715 path.close();
720 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
724 SkPath path, pathB;
725 path.setFillType(SkPath::kWinding_FillType);
726 path.moveTo(0,1);
727 path.cubicTo(2,6, 6,1, 4,3);
728 path.close();
733 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
737 SkPath path, pathB;
738 path.setFillType(SkPath::kWinding_FillType);
739 path.moveTo(0,1);
740 path.cubicTo(0,6, 3,2, 4,1);
741 path.close();
746 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
750 SkPath path, pathB;
751 path.setFillType(SkPath::kWinding_FillType);
752 path.moveTo(0,1);
753 path.cubicTo(2,3, 5,1, 4,3);
754 path.close();
759 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
763 SkPath path, pathB;
764 path.setFillType(SkPath::kWinding_FillType);
765 path.moveTo(0,1);
766 path.cubicTo(1,5, 3,2, 4,2);
767 path.close();
772 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
776 SkPath path, pathB;
777 path.setFillType(SkPath::kWinding_FillType);
778 path.moveTo(0,1);
779 path.cubicTo(2,6, 4,3, 6,4);
780 path.close();
785 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
789 SkPath path, pathB;
790 path.setFillType(SkPath::kWinding_FillType);
791 path.moveTo(0,1);
792 path.cubicTo(1,2, 6,5, 5,4);
793 path.close();
798 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
802 SkPath path, pathB;
803 path.setFillType(SkPath::kWinding_FillType);
804 path.moveTo(0,2);
805 path.cubicTo(1,2, 4,0, 3,1);
806 path.close();
811 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
815 SkPath path, pathB;
816 path.setFillType(SkPath::kWinding_FillType);
817 path.moveTo(0,2);
818 path.cubicTo(3,6, 4,0, 3,2);
819 path.close();
824 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
828 SkPath path, pathB;
829 path.setFillType(SkPath::kWinding_FillType);
830 path.moveTo(0,2);
831 path.cubicTo(2,4, 4,0, 3,2);
832 path.close();
837 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
841 SkPath path, pathB;
842 path.setFillType(SkPath::kWinding_FillType);
843 path.moveTo(0,2);
844 path.cubicTo(3,5, 5,0, 4,2);
845 path.close();
850 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
854 SkPath path, pathB;
855 path.setFillType(SkPath::kWinding_FillType);
856 path.moveTo(0,1);
857 path.cubicTo(1,6, 6,2, 5,4);
858 path.close();
863 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
867 SkPath path, pathB;
868 path.setFillType(SkPath::kWinding_FillType);
869 path.moveTo(0,2);
870 path.cubicTo(2,3, 5,1, 3,2);
871 path.close();
876 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
880 SkPath path, pathB;
881 path.setFillType(SkPath::kWinding_FillType);
882 path.moveTo(0,2);
883 path.cubicTo(1,5, 3,2, 4,1);
884 path.close();
889 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
893 SkPath path, pathB;
894 path.setFillType(SkPath::kWinding_FillType);
895 path.moveTo(0,3);
896 path.cubicTo(1,6, 5,0, 5,1);
897 path.close();
902 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
906 SkPath path, pathB;
907 path.setFillType(SkPath::kWinding_FillType);
908 path.moveTo(0,3);
909 path.cubicTo(1,2, 4,1, 6,0);
910 path.close();
915 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
919 SkPath path, pathB;
920 path.setFillType(SkPath::kWinding_FillType);
921 path.moveTo(0,2);
922 path.cubicTo(1,2, 5,4, 4,3);
923 path.close();
928 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
932 SkPath path, pathB;
933 path.setFillType(SkPath::kWinding_FillType);
934 path.moveTo(0,3);
935 path.cubicTo(1,2, 5,3, 2,1);
936 path.close();
941 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
945 SkPath path, pathB;
946 path.setFillType(SkPath::kWinding_FillType);
947 path.moveTo(0,4);
948 path.cubicTo(1,3, 5,4, 4,2);
949 path.close();
954 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
958 SkPath path, pathB;
959 path.setFillType(SkPath::kWinding_FillType);
960 path.moveTo(0,5);
961 path.cubicTo(1,3, 3,2, 5,0);
962 path.close();
967 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
971 SkPath path, pathB;
972 path.setFillType(SkPath::kWinding_FillType);
973 path.moveTo(0,1);
974 path.cubicTo(2,6, 5,0, 2,1);
975 path.close();
980 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
984 SkPath path, pathB;
985 path.setFillType(SkPath::kWinding_FillType);
986 path.moveTo(0,5);
987 path.cubicTo(0,5, 5,4, 6,4);
988 path.close();
993 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
997 SkPath path, pathB;
998 path.setFillType(SkPath::kWinding_FillType);
999 path.moveTo(0,5);
1000 path.cubicTo(3,4, 6,5, 5,3);
1001 path.close();
1006 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1010 SkPath path, pathB;
1011 path.setFillType(SkPath::kWinding_FillType);
1012 path.moveTo(0,1);
1013 path.cubicTo(5,6, 4,0, 4,1);
1014 path.close();
1019 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1023 SkPath path, pathB;
1024 path.setFillType(SkPath::kWinding_FillType);
1025 path.moveTo(0,2);
1026 path.cubicTo(4,6, 6,0, 5,2);
1027 path.close();
1032 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1036 SkPath path, pathB;
1037 path.setFillType(SkPath::kWinding_FillType);
1038 path.moveTo(1,2);
1039 path.cubicTo(0,5, 3,2, 6,1);
1040 path.close();
1045 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1049 SkPath path, pathB;
1050 path.setFillType(SkPath::kWinding_FillType);
1051 path.moveTo(1,3);
1052 path.cubicTo(5,6, 5,3, 5,4);
1053 path.close();
1058 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1062 SkPath path, pathB;
1063 path.setFillType(SkPath::kWinding_FillType);
1064 path.moveTo(2,3);
1065 path.cubicTo(0,4, 3,2, 5,3);
1066 path.close();
1071 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1075 SkPath path, pathB;
1076 path.moveTo(0,1);
1077 path.cubicTo(0,1, 1,0, 3,0);
1078 path.lineTo(0,1);
1079 path.close();
1084 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1088 SkPath path, pathB;
1089 path.moveTo(0,1);
1090 path.cubicTo(1,5, 1,0, 1,0);
1091 path.lineTo(0,1);
1092 path.close();
1097 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1101 SkPath path, pathB;
1102 path.moveTo(0,1);
1103 path.cubicTo(0,1, 1,0, 3,0);
1104 path.lineTo(0,1);
1105 path.close();
1110 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1114 SkPath path, pathB;
1115 path.setFillType(SkPath::kWinding_FillType);
1116 path.moveTo(0,1);
1117 path.cubicTo(2,6, 4,2, 5,3);
1118 path.close();
1123 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1127 SkPath path, pathB;
1128 path.moveTo(3,5);
1129 path.cubicTo(1,6, 5,0, 3,1);
1130 path.lineTo(3,5);
1131 path.close();
1136 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1140 SkPath path, pathB;
1141 path.moveTo(0,5);
1142 path.cubicTo(4,5, 4,1, 5,0);
1143 path.close();
1147 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1151 SkPath path, pathB;
1152 path.moveTo(1,3);
1153 path.cubicTo(0,1, 3,1, 2,0);
1154 path.close();
1158 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1195 SkPath path;
1196 path.setFillType(SkPath::kInverseEvenOdd_FillType);
1198 testPathOp(reporter, path, paths[index], ops[index], filename);
1199 REPORTER_ASSERT(reporter, Op(path, paths[index], ops[index], &path));
1204 SkPath path;
1205 path.setFillType(SkPath::kEvenOdd_FillType);
1206 path.moveTo(189,7);
1207 path.cubicTo(189,5.34314585f, 190.34314f,4, 192,4);
1208 path.lineTo(243,4);
1209 path.cubicTo(244.65686f,4, 246,5.34314585f, 246,7);
1210 path.lineTo(246,21);
1211 path.cubicTo(246,22.6568546f, 244.65686f,24, 243,24);
1212 path.lineTo(192,24);
1213 path.cubicTo(190.34314f,24, 189,22.6568546f, 189,21);
1214 path.lineTo(189,7);
1215 path.close();
1216 path.moveTo(191,8);
1217 path.cubicTo(191,6.89543009f, 191.895432f,6, 193,6);
1218 path.lineTo(242,6);
1219 path.cubicTo(243.104568f,6, 244,6.89543009f, 244,8);
1220 path.lineTo(244,20);
1221 path.cubicTo(244,21.1045704f, 243.104568f,22, 242,22);
1222 path.lineTo(193,22);
1223 path.cubicTo(191.895432f,22, 191,21.1045704f, 191,20);
1224 path.lineTo(191,8);
1225 path.close();
1234 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1238 SkPath path;
1239 path.setFillType(SkPath::kEvenOdd_FillType);
1240 path.moveTo(253.000000f, 11757.0000f);
1241 path.lineTo(253.000000f, 222.000000f);
1242 path.lineTo(823.000000f, 222.000000f);
1243 path.lineTo(823.000000f, 11757.0000f);
1244 path.lineTo(253.000000f, 11757.0000f);
1245 path.close();
1254 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1258 SkPath path;
1259 path.setFillType(SkPath::kEvenOdd_FillType);
1260 path.moveTo(717.000000f, 507.000000f);
1261 path.lineTo(717.000000f, 425.000000f);
1262 path.lineTo(973.000000f, 425.000000f);
1263 path.lineTo(973.000000f, 507.000000f);
1264 path.quadTo(973.000000f, 508.242645f, 972.121582f, 509.121613f);
1265 path.quadTo(971.242615f, 510.000000f, 970.000000f, 510.000000f);
1266 path.lineTo(720.000000f, 510.000000f);
1267 path.quadTo(718.757385f, 510.000000f, 717.878418f, 509.121613f);
1268 path.quadTo(717.000000f, 508.242645f, 717.000000f, 507.000000f);
1269 path.close();
1270 path.moveTo(719.000000f, 426.000000f);
1271 path.lineTo(971.000000f, 426.000000f);
1272 path.lineTo(971.000000f, 506.000000f);
1273 path.cubicTo(971.000000f, 507.104584f, 970.104553f, 508.000000f, 969.000000f, 508.000000f);
1274 path.lineTo(721.000000f, 508.000000f);
1275 path.cubicTo(719.895447f, 508.000000f, 719.000000f, 507.104584f, 719.000000f, 506.000000f);
1276 path.lineTo(719.000000f, 426.000000f);
1277 path.close();
1286 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1290 SkPath path;
1291 path.setFillType(SkPath::kEvenOdd_FillType);
1292 path.moveTo(230.756805f, 591.756775f);
1293 path.quadTo(232.514725f, 590.000000f, 235.000000f, 590.000000f);
1294 path.lineTo(300.000000f, 590.000000f);
1295 path.quadTo(302.485291f, 590.000000f, 304.243195f, 591.756775f);
1296 path.quadTo(306.000000f, 593.514709f, 306.000000f, 596.000000f);
1297 path.lineTo(306.000000f, 617.000000f);
1298 path.lineTo(229.000000f, 617.000000f);
1299 path.lineTo(229.000000f, 596.000000f);
1300 path.quadTo(229.000000f, 593.514709f, 230.756805f, 591.756775f);
1301 path.close();
1302 path.moveTo(231.000000f, 597.000000f);
1303 path.cubicTo(231.000000f, 594.238586f, 233.238571f, 592.000000f, 236.000000f, 592.000000f);
1304 path.lineTo(299.000000f, 592.000000f);
1305 path.cubicTo(301.761414f, 592.000000f, 304.000000f, 594.238586f, 304.000000f, 597.000000f);
1306 path.lineTo(304.000000f, 616.000000f);
1307 path.lineTo(231.000000f, 616.000000f);
1308 path.lineTo(231.000000f, 597.000000f);
1309 path.close();
1318 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1322 SkPath path;
1323 path.setFillType(SkPath::kEvenOdd_FillType);
1324 path.moveTo(18.0000000f, 226.000000f);
1325 path.quadTo(14.6862917f, 226.000000f, 12.3423996f, 228.342407f);
1326 path.quadTo(10.0000000f, 230.686295f, 10.0000000f, 234.000000f);
1327 path.lineTo(10.0000000f, 253.000000f);
1328 path.lineTo(1247.00000f, 253.000000f);
1329 path.lineTo(1247.00000f, 234.000000f);
1330 path.quadTo(1247.00000f, 230.686295f, 1244.65759f, 228.342407f);
1331 path.quadTo(1242.31372f, 226.000000f, 1239.00000f, 226.000000f);
1332 path.lineTo(18.0000000f, 226.000000f);
1333 path.close();
1344 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1348 SkPath path, pathB;
1349 path.setFillType(SkPath::kWinding_FillType);
1350 path.moveTo(0,1);
1351 path.cubicTo(0,5, 4,0, 5,0);
1352 path.close();
1357 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1361 SkPath path, pathB;
1362 path.setFillType(SkPath::kWinding_FillType);
1363 path.moveTo(0,1);
1364 path.cubicTo(0,5, 4,1, 6,4);
1365 path.close();
1370 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1374 SkPath path, pathB;
1375 path.setFillType(SkPath::kWinding_FillType);
1376 path.moveTo(0,1);
1377 path.cubicTo(0,5, 5,2, 5,4);
1378 path.close();
1383 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1387 SkPath path, pathB;
1388 path.setFillType(SkPath::kWinding_FillType);
1389 path.moveTo(0,1);
1390 path.cubicTo(3,4, 4,0, 6,4);
1391 path.lineTo(0,1);
1392 path.close();
1398 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1402 SkPath path, pathB;
1403 path.setFillType(SkPath::kWinding_FillType);
1404 path.moveTo(0,1);
1405 path.cubicTo(1,5, 5,1, 5,1);
1406 path.lineTo(0,1);
1407 path.close();
1413 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1417 SkPath path, pathB;
1418 path.setFillType(SkPath::kWinding_FillType);
1419 path.moveTo(0,1);
1420 path.cubicTo(0,4, 5,1, 6,4);
1421 path.lineTo(0,1);
1422 path.close();
1428 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1432 SkPath path, pathB;
1433 path.setFillType(SkPath::kWinding_FillType);
1434 path.moveTo(0,1);
1435 path.cubicTo(0,2, 2,0, 5,3);
1436 path.close();
1441 path, pathB, kUnion_SkPathOp, filename);
1445 SkPath path, pathB;
1446 path.setFillType(SkPath::kEvenOdd_FillType);
1447 path.moveTo(0,1);
1448 path.cubicTo(1,3, 2,0, 3,2);
1449 path.lineTo(0,1);
1450 path.close();
1456 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1460 SkPath path, pathB;
1461 path.setFillType(SkPath::kEvenOdd_FillType);
1462 path.moveTo(1,6);
1463 path.cubicTo(1,6, 5,0, 6,1);
1464 path.lineTo(1,6);
1465 path.close();
1471 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1475 SkPath path, pathB;
1476 path.setFillType(SkPath::kWinding_FillType);
1477 path.moveTo(0,1);
1478 path.cubicTo(1,3, 1,0, 6,4);
1479 path.close();
1484 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1488 SkPath path, pathB;
1489 path.setFillType(SkPath::kWinding_FillType);
1490 path.moveTo(0,1);
1491 path.cubicTo(2,3, 2,1, 4,3);
1492 path.lineTo(0,1);
1493 path.close();
1499 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1503 SkPath path, pathB;
1504 path.setFillType(SkPath::kWinding_FillType);
1505 path.moveTo(0,1);
1506 path.cubicTo(4,6, 4,3, 5,4);
1507 path.close();
1512 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1516 SkPath path, pathB;
1517 path.setFillType(SkPath::kEvenOdd_FillType);
1518 path.moveTo(0,1);
1519 path.cubicTo(2,3, 5,2, 3,0);
1520 path.lineTo(0,1);
1521 path.close();
1527 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1531 SkPath path, pathB;
1532 path.setFillType(SkPath::kWinding_FillType);
1533 path.moveTo(0,1);
1534 path.cubicTo(0,3, 2,1, 4,1);
1535 path.lineTo(0,1);
1536 path.close();
1542 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1546 SkPath path, pathB;
1547 path.setFillType(SkPath::kWinding_FillType);
1548 path.moveTo(0,4);
1549 path.cubicTo(2,3, 6,3, 3,2);
1550 path.close();
1555 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1559 SkPath path;
1560 path.setFillType(SkPath::kEvenOdd_FillType);
1561 path.moveTo(1126.17114f, 877.171204f);
1562 path.quadTo(1127.34314f, 876.000000f, 1129.00000f, 876.000000f);
1563 path.lineTo(1243.00000f, 876.000000f);
1564 path.quadTo(1244.65686f, 876.000000f, 1245.82886f, 877.171204f);
1565 path.quadTo(1247.00000f, 878.343140f, 1247.00000f, 880.000000f);
1566 path.lineTo(1247.00000f, 907.000000f);
1567 path.lineTo(1246.00000f, 907.000000f);
1568 path.lineTo(1246.00000f, 880.000000f);
1569 path.cubicTo(1246.00000f, 878.343140f, 1244.65686f, 877.000000f, 1243.00000f, 877.000000f);
1570 path.lineTo(1129.00000f, 877.000000f);
1571 path.cubicTo(1127.34314f, 877.000000f, 1126.00000f, 878.343140f, 1126.00000f, 880.000000f);
1572 path.lineTo(1126.00000f, 907.000000f);
1573 path.lineTo(1125.00000f, 907.000000f);
1574 path.lineTo(1125.00000f, 880.000000f);
1575 path.quadTo(1125.00000f, 878.343140f, 1126.17114f, 877.171204f);
1576 path.close();
1585 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1589 SkPath path;
1590 path.setFillType(SkPath::kEvenOdd_FillType);
1591 path.moveTo(134.000000f, 11414.0000f);
1592 path.cubicTo(131.990234f, 11414.0000f, 130.326660f, 11415.4824f, 130.042755f, 11417.4131f);
1593 path.cubicTo(130.233124f, 11418.3193f, 131.037079f, 11419.0000f, 132.000000f, 11419.0000f);
1594 path.lineTo(806.000000f, 11419.0000f);
1595 path.cubicTo(806.962891f, 11419.0000f, 807.766907f, 11418.3193f, 807.957275f, 11417.4131f);
1596 path.cubicTo(807.673401f, 11415.4824f, 806.009766f, 11414.0000f, 804.000000f, 11414.0000f);
1597 path.lineTo(134.000000f, 11414.0000f);
1598 path.close();
1611 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1615 SkPath path;
1616 path.setFillType(SkPath::kEvenOdd_FillType);
1617 path.moveTo(157.464005f, 670.463989f);
1618 path.quadTo(158.928925f, 669.000000f, 161.000000f, 669.000000f);
1619 path.lineTo(248.000000f, 669.000000f);
1620 path.quadTo(250.071075f, 669.000000f, 251.535995f, 670.463989f);
1621 path.quadTo(253.000000f, 671.928955f, 253.000000f, 674.000000f);
1622 path.lineTo(253.000000f, 706.000000f);
1623 path.lineTo(251.000000f, 706.000000f);
1624 path.lineTo(251.000000f, 675.000000f);
1625 path.cubicTo(251.000000f, 672.790833f, 249.209137f, 671.000000f, 247.000000f, 671.000000f);
1626 path.lineTo(162.000000f, 671.000000f);
1627 path.cubicTo(159.790863f, 671.000000f, 158.000000f, 672.790833f, 158.000000f, 675.000000f);
1628 path.lineTo(158.000000f, 706.000000f);
1629 path.lineTo(156.000000f, 706.000000f);
1630 path.lineTo(156.000000f, 674.000000f);
1631 path.quadTo(156.000000f, 671.928955f, 157.464005f, 670.463989f);
1632 path.close();
1641 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1645 SkPath path;
1646 path.setFillType(SkPath::kEvenOdd_FillType);
1647 path.moveTo(161.000000f, 925.000000f);
1648 path.cubicTo(159.874390f, 925.000000f, 158.835663f, 925.371948f, 158.000000f, 925.999634f);
1649 path.lineTo(158.000000f, 926.000000f);
1650 path.lineTo(1108.00000f, 926.000000f);
1651 path.lineTo(1108.00000f, 925.999634f);
1652 path.cubicTo(1107.16443f, 925.371948f, 1106.12561f, 925.000000f, 1105.00000f, 925.000000f);
1653 path.lineTo(161.000000f, 925.000000f);
1654 path.close();
1667 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1671 SkPath path;
1672 path.setFillType(SkPath::kEvenOdd_FillType);
1673 path.moveTo(286.695129f, 291.000000f);
1674 path.lineTo(229.304855f, 561.000000f);
1675 path.lineTo(979.304871f, 561.000000f);
1676 path.lineTo(1036.69507f, 291.000000f);
1677 path.lineTo(286.695129f, 291.000000f);
1678 path.close();
1691 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1695 SkPath path;
1696 path.setFillType(SkPath::kEvenOdd_FillType);
1697 path.moveTo(968.000000f, 14.0000000f);
1698 path.cubicTo(965.238586f, 14.0000000f, 963.000000f, 16.2385769f, 963.000000f, 19.0000000f);
1699 path.lineTo(963.000000f, 32.0000000f);
1700 path.cubicTo(963.000000f, 34.7614250f, 965.238586f, 37.0000000f, 968.000000f, 37.0000000f);
1701 path.lineTo(1034.00000f, 37.0000000f);
1702 path.cubicTo(1036.76147f, 37.0000000f, 1039.00000f, 34.7614250f, 1039.00000f, 32.0000000f);
1703 path.lineTo(1039.00000f, 19.0000000f);
1704 path.cubicTo(1039.00000f, 16.2385769f, 1036.76147f, 14.0000000f, 1034.00000f, 14.0000000f);
1705 path.lineTo(968.000000f, 14.0000000f);
1706 path.close();
1719 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1723 SkPath path;
1724 path.setFillType(SkPath::kEvenOdd_FillType);
1725 path.moveTo(708.099182f, 7.09919119f);
1726 path.lineTo(708.099182f, 7.09920025f);
1727 path.quadTo(704.000000f, 11.2010098f, 704.000000f, 17.0000000f);
1728 path.lineTo(704.000000f, 33.0000000f);
1729 path.lineTo(705.000000f, 33.0000000f);
1730 path.lineTo(705.000000f, 17.0000000f);
1731 path.cubicTo(705.000000f, 13.4101496f, 706.455078f, 10.1601505f, 708.807617f, 7.80761385f);
1732 path.lineTo(708.099182f, 7.09919119f);
1733 path.close();
1740 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1744 SkPath path;
1745 path.setFillType(SkPath::kEvenOdd_FillType);
1746 path.moveTo(1099.82886f, 7.17117119f);
1747 path.lineTo(1099.12134f, 7.87867832f);
1748 path.cubicTo(1099.66418f, 8.42157173f, 1100.00000f, 9.17157173f, 1100.00000f, 10.0000000f);
1749 path.lineTo(1100.00000f, 28.0000000f);
1750 path.cubicTo(1100.00000f, 29.6568546f, 1098.65686f, 31.0000000f, 1097.00000f, 31.0000000f);
1751 path.lineTo(1088.00000f, 31.0000000f);
1752 path.lineTo(1088.00000f, 32.0000000f);
1753 path.lineTo(1097.00000f, 32.0000000f);
1754 path.quadTo(1098.65686f, 32.0000000f, 1099.82886f, 30.8288002f);
1755 path.quadTo(1101.00000f, 29.6568546f, 1101.00000f, 28.0000000f);
1756 path.lineTo(1101.00000f, 10.0000000f);
1757 path.quadTo(1101.00000f, 8.34314537f, 1099.82886f, 7.17119980f);
1758 path.lineTo(1099.82886f, 7.17117119f);
1759 path.close();
1766 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1770 SkPath path;
1771 path.setFillType(SkPath::kEvenOdd_FillType);
1772 path.moveTo(1037.17114f, 7.17119980f);
1773 path.quadTo(1038.34314f, 6.00000000f, 1040.00000f, 6.00000000f);
1774 path.lineTo(1074.00000f, 6.00000000f);
1775 path.lineTo(1074.00000f, 32.0000000f);
1776 path.lineTo(1040.00000f, 32.0000000f);
1777 path.quadTo(1038.34314f, 32.0000000f, 1037.17114f, 30.8288002f);
1778 path.quadTo(1036.00000f, 29.6568546f, 1036.00000f, 28.0000000f);
1779 path.lineTo(1036.00000f, 10.0000000f);
1780 path.quadTo(1036.00000f, 8.34314537f, 1037.17114f, 7.17119980f);
1781 path.close();
1782 path.moveTo(1037.00000f, 10.0000000f);
1783 path.cubicTo(1037.00000f, 8.34314537f, 1038.34314f, 7.00000000f, 1040.00000f, 7.00000000f);
1784 path.lineTo(1073.00000f, 7.00000000f);
1785 path.lineTo(1073.00000f, 31.0000000f);
1786 path.lineTo(1040.00000f, 31.0000000f);
1787 path.cubicTo(1038.34314f, 31.0000000f, 1037.00000f, 29.6568546f, 1037.00000f, 28.0000000f);
1788 path.lineTo(1037.00000f, 10.0000000f);
1789 path.close();
1796 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1800 SkPath path;
1801 path.setFillType(SkPath::kWinding_FillType);
1802 path.moveTo(0,1);
1803 path.cubicTo(1,6, 1,0, 6,2);
1804 path.close();
1810 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1814 SkPath path;
1815 path.setFillType(SkPath::kEvenOdd_FillType);
1816 path.moveTo(96, 122);
1817 path.cubicTo(94.6192932f, 122, 93.3692932f, 122.559647f, 92.4644699f, 123.46447f);
1818 path.lineTo(94.1715698f, 125.17157f);
1819 path.cubicTo(94.8954315f, 124.447708f, 95.8954315f, 124, 97, 124);
1820 path.lineTo(257, 124);
1821 path
1822 path.lineTo(261.535522f, 123.46447f);
1823 path.cubicTo(260.630707f, 122.559647f, 259.380707f, 122, 258, 122);
1824 path.lineTo(96, 122);
1825 path.close();
1838 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1980 SkPath path, pathB;
1981 path.setFillType(SkPath::kWinding_FillType);
1982 path.moveTo(3, 4);
1983 path.cubicTo(1, 5, 4, 3, 6, 4);
1984 path.close();
1989 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2023 SkPath path, pathB;
2024 path.setFillType(SkPath::kWinding_FillType);
2025 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
2026 path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
2030 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2034 SkPath path, pathB;
2035 path.setFillType(SkPath::kEvenOdd_FillType);
2036 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
2037 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
2041 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2045 SkPath path, pathB;
2046 path.setFillType(SkPath::kEvenOdd_FillType);
2047 path.moveTo(0, 0);
2048 path.lineTo(3, 0);
2049 path.lineTo(3, 3);
2050 path.lineTo(0, 3);
2051 path.close();
2052 path.moveTo(2, 2);
2053 path.lineTo(3, 2);
2054 path.lineTo(3, 3);
2055 path.lineTo(2, 3);
2056 path.close();
2068 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
2123 SkPath path;
2124 path.setFillType(SkPath::kEvenOdd_FillType);
2125 path.moveTo(1173, 284);
2126 path.cubicTo(1173, 285.125824f, 1173.37207f, 286.164734f, 1174, 287.000488f);
2127 path.lineTo(1174, 123.999496f);
2128 path.cubicTo(1173.37207f, 124.835243f, 1173, 125.874168f, 1173, 127);
2129 path.lineTo(1173, 284);
2130 path.close();
2143 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2147 SkPath path;
2148 path.setFillType(SkPath::kEvenOdd_FillType);
2149 path.moveTo(0,0);
2150 path.lineTo(3,0);
2151 path.lineTo(3,2);
2152 path.lineTo(1,2);
2153 path.lineTo(1,1);
2154 path.lineTo(2,1);
2155 path.lineTo(2,3);
2156 path.lineTo(0,3);
2157 path.close();
2165 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2169 SkPath path;
2170 path.setFillType(SkPath::kEvenOdd_FillType);
2171 path.moveTo(0,0);
2172 path.lineTo(3,0);
2173 path.lineTo(3,2);
2174 path.lineTo(1,2);
2175 path.lineTo(1,1);
2176 path.lineTo(2,1);
2177 path.lineTo(2,3);
2178 path.lineTo(0,3);
2179 path.close();
2187 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2191 SkPath path, pathB;
2192 path.setFillType(SkPath::kWinding_FillType);
2193 path.moveTo(0, 4);
2194 path.cubicTo(3, 4, 6, 2, 5, 2);
2195 path.close();
2200 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2204 path, pathB;
2205 path.setFillType(SkPath::kWinding_FillType);
2206 path.moveTo(0,1);
2207 path.cubicTo(0,2, 2,0, 6,4);
2208 path.close();
2213 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2217 SkPath path, pathB;
2218 path.setFillType(SkPath::kWinding_FillType);
2219 path.moveTo(0,1);
2220 path.cubicTo(2,5, 5,0, 6,4);
2221 path.close();
2226 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2230 SkPath path, pathB;
2231 path.setFillType(SkPath::kWinding_FillType);
2232 path.moveTo(0, 3);
2233 path.cubicTo(1, 6, 5, 0, 6, 3);
2234 path.close();
2239 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2243 SkPath path, pathB;
2244 path.setFillType(SkPath::kEvenOdd_FillType);
2245 path.moveTo(0, 5);
2246 path.cubicTo(1, 2, 5, 2, 4, 1);
2247 path.close();
2252 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2256 SkPath path, pathB;
2257 path.setFillType(SkPath::kWinding_FillType);
2258 path.moveTo(1, 6);
2259 path.cubicTo(0, 3, 6, 3, 5, 0);
2260 path.close();
2265 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2269 SkPath path;
2270 path.setFillType(SkPath::kEvenOdd_FillType);
2271 path.moveTo(-1.24344979e-014f, 348);
2272 path.lineTo(258, 348);
2273 path.lineTo(258, 322);
2274 path.quadTo(258, 317.857849f, 255.072006f, 314.928009f);
2275 path.quadTo(252.142136f, 312, 248, 312);
2276 path.lineTo(1.77635684e-015f, 312);
2277 path.lineTo(-1.24344979e-014f, 348);
2278 path.close();
2286 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2290 SkPath path;
2291 path.setFillType(SkPath::kEvenOdd_FillType);
2292 path.moveTo(1.99840144e-015f, 494);
2293 path.lineTo(97, 494);
2294 path.quadTo(100.313705f, 494, 102.6576f, 491.657593f);
2295 path.quadTo(105, 489.313721f, 105, 486);
2296 path.lineTo(105, 425);
2297 path.quadTo(105, 421.686279f, 102.6576f, 419.342407f);
2298 path.quadTo(100.313705f, 417, 97, 417);
2299 path.lineTo(2.22044605e-016f, 417);
2300 path.lineTo(1.99840144e-015f, 494);
2301 path.close();
2309 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2313 SkPath path;
2314 path.setFillType(SkPath::kEvenOdd_FillType);
2315 path.moveTo(670.537415f, 285);
2316 path.lineTo(670.387451f, 285);
2317 path.lineTo(596.315186f, 314.850708f);
2318 path.lineTo(626.19696f, 389);
2319 path.lineTo(626.346863f, 389);
2320 path.lineTo(700.419189f, 359.149261f);
2321 path.lineTo(670.537415f, 285);
2322 path.close();
2335 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2339 SkPath path;
2340 path.setFillType(SkPath::kEvenOdd_FillType);
2341 path.moveTo(1.45716772e-016f, 924.336121f);
2342 path.lineTo(-1.11022302e-016f, 920);
2343 path.lineTo(6, 920);
2344 path.lineTo(6, 926);
2345 path.lineTo(1.66389287f, 926);
2346 path.quadTo(1.18842196f, 925.674561f, 0.756800175f, 925.243225f);
2347 path.quadTo(0.325406998f, 924.811523f, 1.45716772e-016f, 924.336121f);
2348 path.close();
2349 path.moveTo(1, 921);
2350 path.lineTo(5, 921);
2351 path.lineTo(5, 925);
2352 path.cubicTo(2.79086018f, 925, 1, 923.209167f, 1, 921);
2353 path.close();
2360 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2364 SkPath path;
2365 path.setFillType(SkPath::kEvenOdd_FillType);
2366 path.moveTo(320.097229f, 628.573669f);
2367 path.lineTo(610.227173f, 85.7786865f);
2368 path.lineTo(946.652588f, 265.601807f);
2369 path.lineTo(656.522644f, 808.39679f);
2370 path.lineTo(320.097229f, 628.573669f);
2371 path.close();
2384 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2388 SkPath path;
2389 path.setFillType(SkPath::kEvenOdd_FillType);
2390 path.moveTo(0, 926);
2391 path.lineTo(0, 0);
2392 path.lineTo(1280, 0);
2393 path.lineTo(1280, 926);
2394 path.lineTo(0, 926);
2395 path.close();
2403 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2407 SkPath path;
2408 path.setFillType(SkPath::kEvenOdd_FillType);
2409 path.moveTo(205.605804f, 142.334625f);
2410 path.lineTo(254.665359f, 85.6058044f);
2411 path.lineTo(311.394196f, 134.665359f);
2412 path.lineTo(262.334625f, 191.39418f);
2413 path.lineTo(205.605804f, 142.334625f);
2414 path.close();
2427 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2431 SkPath path;
2432 path.setFillType(SkPath::kEvenOdd_FillType);
2433 path.moveTo(-4.4408921e-016f, 682.5f);
2434 path.lineTo(30.5f, 682.5f);
2435 path.cubicTo(32.709137f, 682.5f, 34.5f, 680.709167f, 34.5f, 678.5f);
2436 path.lineTo(34.5f, 486.5f);
2437 path.cubicTo(34.5f, 484.290863f, 32.709137f, 482.5f, 30.5f, 482.5f);
2438 path.lineTo(0, 482.5f);
2439 path.lineTo(-4.4408921e-016f, 682.5f);
2440 path.close();
2448 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2452 SkPath path;
2453 path.setFillType(SkPath::kEvenOdd_FillType);
2454 path.moveTo(324.071075f, 845.071045f);
2455 path.cubicTo(324.405151f, 844.737f, 324.715668f, 844.379395f, 325, 844.000977f);
2456 path.lineTo(325, 842.127197f);
2457 path.cubicTo(324.571411f, 842.956238f, 324.017761f, 843.710144f, 323.363953f, 844.363953f);
2458 path.lineTo(324.071075f, 845.071045f);
2459 path.close();
2460 path.moveTo(323.363953f, 714.636047f);
2461 path.lineTo(324.071075f, 713.928955f);
2462 path.cubicTo(324.405151f, 714.263f, 324.715668f, 714.620605f, 325, 714.999023f);
2463 path.lineTo(325, 716.872803f);
2464 path.cubicTo(324.571411f, 716.043762f, 324.017761f, 715.289856f, 323.363953f, 714.636047f);
2465 path.close();
2478 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2482 SkPath path, pathB;
2483 path.setFillType(SkPath::kWinding_FillType);
2484 path.moveTo(0, 1);
2485 path.cubicTo(2, 6, 4, 1, 5, 4);
2486 path.close();
2491 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2495 SkPath path, pathB;
2496 path.setFillType(SkPath::kWinding_FillType);
2497 path.moveTo(0, 1);
2498 path.cubicTo(1, 6, 4, 1, 4, 3);
2499 path.close();
2504 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2508 SkPath path, pathB;
2509 path.setFillType(SkPath::kEvenOdd_FillType);
2510 path.moveTo(0, 3);
2511 path.cubicTo(2, 3, 5, 0, 5, 3);
2512 path.close();
2517 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2521 SkPath path;
2522 path.setFillType(SkPath::kEvenOdd_FillType);
2523 path.moveTo(333.292084f, 624.570984f);
2524 path.lineTo(614.229797f, 98.9735107f);
2525 path.lineTo(933.457764f, 269.604431f);
2526 path.lineTo(652.52002f, 795.201904f);
2527 path.lineTo(333.292084f, 624.570984f);
2528 path.close();
2541 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2545 SkPath path;
2546 path.setFillType(SkPath::kEvenOdd_FillType);
2547 path.moveTo(802, 367);
2548 path.lineTo(802, 324);
2549 path.lineTo(956, 324);
2550 path.lineTo(956, 371);
2551 path.quadTo(956, 373.071075f, 954.536011f, 374.536011f);
2552 path.quadTo(953.071045f, 376, 951, 376);
2553 path.lineTo(811, 376);
2554 path.cubicTo(806.029419f, 376, 802, 371.970551f, 802, 367);
2555 path.close();
2566 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2570 SkPath path;
2571 path.setFillType(SkPath::kEvenOdd_FillType);
2572 path.moveTo(-2.220446e-018f, 483.5f);
2573 path.lineTo(0, 482.5f);
2574 path.lineTo(30.5f, 482.5f);
2575 path.cubicTo(32.709137f, 482.5f, 34.5f, 484.290863f, 34.5f, 486.5f);
2576 path.lineTo(34.5f, 678.5f);
2577 path.cubicTo(34.5f, 680.709167f, 32.709137f, 682.5f, 30.5f, 682.5f);
2578 path.lineTo(-4.4408921e-016f, 682.5f);
2579 path.lineTo(-4.41868766e-016f, 681.5f);
2580 path.lineTo(30.5f, 681.5f);
2581 path.cubicTo(32.1568565f, 681.5f, 33.5f, 680.15686f, 33.5f, 678.5f);
2582 path.lineTo(33.5f, 486.5f);
2583 path.cubicTo(33.5f, 484.84314f, 32.1568565f, 483.5f, 30.5f, 483.5f);
2584 path.lineTo(-2.220446e-018f, 483.5f);
2585 path.close();
2593 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2597 SkPath path;
2598 path.setFillType(SkPath::kEvenOdd_FillType);
2599 path.moveTo(1182.00037f, 926);
2600 path.cubicTo(1181.08813f, 924.785583f, 1179.63586f, 924, 1178, 924);
2601 path.lineTo(938, 924);
2602 path.cubicTo(936.364197f, 924, 934.911865f, 924.785583f, 933.999634f, 926);
2603 path.lineTo(1182.00037f, 926);
2604 path.close();
2612 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2616 SkPath path;
2617 path.setFillType(SkPath::kEvenOdd_FillType);
2618 path.moveTo(925, 27);
2619 path.cubicTo(924.447693f, 27, 924, 27.4477158f, 924, 28);
2620 path.lineTo(924, 55);
2621 path.cubicTo(924, 55.5522842f, 924.447693f, 56, 925, 56);
2622 path.lineTo(1103, 56);
2623 path.cubicTo(1103.55225f, 56, 1104, 55.5522842f, 1104, 55);
2624 path.lineTo(1104, 28);
2625 path.cubicTo(1104, 27.4477158f, 1103.55225f, 27, 1103, 27);
2626 path.lineTo(925, 27);
2627 path.close();
2640 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2644 SkPath path;
2645 path.setFillType(SkPath::kEvenOdd_FillType);
2646 path.moveTo(190, 170);
2647 path.cubicTo(178.9543f, 170, 170, 178.9543f, 170, 190);
2648 path.cubicTo(170, 201.0457f, 178.9543f, 210, 190, 210);
2649 path.lineTo(370, 210);
2650 path.cubicTo(381.045685f, 210, 390, 201.0457f, 390, 190);
2651 path.cubicTo(390, 178.9543f, 381.045685f, 170, 370, 170);
2652 path.lineTo(190, 170);
2653 path.close();
2666 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2670 SkPath path;
2671 path.setFillType(SkPath::kEvenOdd_FillType);
2672 path.moveTo(47.8780937f, 58);
2673 path.lineTo(0, 58);
2674 path.lineTo(-8.65973959e-015f, 96.9914017f);
2675 path.quadTo(20.0654926f, 96.6451874f, 34.3553391f, 82.3553391f);
2676 path.quadTo(44.9466133f, 71.764061f, 47.8780937f, 58);
2677 path.close();
2690 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2694 SkPath path;
2695 path.setFillType(SkPath::kEvenOdd_FillType);
2696 path.moveTo(693.000488f, 926);
2697 path.cubicTo(692.164734f, 925.37207f, 691.125793f, 925, 690, 925);
2698 path.lineTo(578, 925);
2699 path.cubicTo(576.874207f, 925, 575.835266f, 925.37207f, 574.999512f, 926);
2700 path.lineTo(693.000488f, 926);
2701 path.close();
2709 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2713 SkPath path;
2714 path.setFillType(SkPath::kEvenOdd_FillType);
2715 path.moveTo(195, 785);
2716 path.cubicTo(124.307556f, 785, 67, 841.859863f, 67, 912);
2717 path.lineTo(67, 913);
2718 path.cubicTo(67, 917.388916f, 67.2243805f, 921.725769f, 67.662384f, 926);
2719 path.lineTo(322, 926);
2720 path.lineTo(322, 896.048035f);
2721 path.cubicTo(314.09201f, 833.437622f, 260.247131f, 785, 195, 785);
2722 path.close();
2733 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2737 SkPath path;
2738 path.setFillType(SkPath::kEvenOdd_FillType);
2739 path.moveTo(945, 597);
2740 path.quadTo(913.93396f, 597, 891.96698f, 618.96698f);
2741 path.quadTo(870, 640.93396f, 870, 672);
2742 path.quadTo(870, 703.06604f, 891.96698f, 725.03302f);
2743 path.quadTo(913.93396f, 747, 945, 747);
2744 path.quadTo(976.06604f, 747, 998.03302f, 725.03302f);
2745 path.quadTo(1020, 703.06604f, 1020, 672);
2746 path.quadTo(1020, 640.93396f, 998.03302f, 618.96698f);
2747 path.quadTo(976.06604f, 597, 945, 597);
2748 path.close();
2759 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2763 SkPath path;
2764 path.setFillType(SkPath::kEvenOdd_FillType);
2765 path.moveTo(0, 926);
2766 path.lineTo(0, 0);
2767 path.lineTo(1265, 0);
2768 path.lineTo(1265, 926);
2769 path.lineTo(0, 926);
2770 path.close();
2778 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2782 SkPath path;
2783 path.setFillType(SkPath::kEvenOdd_FillType);
2784 path.moveTo(883, 23);
2785 path.lineTo(883, 0);
2786 path.lineTo(1122.5f, 0);
2787 path.lineTo(1122.5f, 25.2136822f);
2788 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2789 path.quadTo(1120.07104f, 28, 1118, 28);
2790 path.lineTo(888, 28);
2791 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2792 path.quadTo(883, 25.0710678f, 883, 23);
2793 path.close();
2805 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2809 SkPath path;
2810 path.setFillType(SkPath::kEvenOdd_FillType);
2811 path.moveTo(883, 23);
2812 path.lineTo(883, 0);
2813 path.lineTo(1122.5f, 0);
2814 path.lineTo(1122.5f, 25.2136822f);
2815 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2816 path.quadTo(1120.07104f, 28, 1118, 28);
2817 path.lineTo(888, 28);
2818 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2819 path.quadTo(883, 25.0710678f, 883, 23);
2820 path.close();
2832 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2836 SkPath path;
2837 path.setFillType(SkPath::kEvenOdd_FillType);
2838 path.moveTo(896, 745.38678f);
2839 path.lineTo(896, 873.38678f);
2840 path.lineTo(922.567993f, 876.683716f);
2841 path.lineTo(922.567993f, 748.683716f);
2842 path.lineTo(896, 745.38678f);
2843 path.close();
2856 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2860 SkPath path;
2861 path.setFillType(SkPath::kEvenOdd_FillType);
2862 path.moveTo(1104, 453);
2863 path.lineTo(399, 453);
2864 path.lineTo(399, 657);
2865 path.cubicTo(399, 661.970581f, 403.029449f, 666, 408, 666);
2866 path.lineTo(1095, 666);
2867 path.cubicTo(1099.97058f, 666, 1104, 661.970581f, 1104, 657);
2868 path.lineTo(1104, 453);
2869 path.close();
2879 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2883 SkPath path;
2884 path.setFillType(SkPath::kEvenOdd_FillType);
2885 path.moveTo(883, 23);
2886 path.lineTo(883, 0);
2887 path.lineTo(1122.5f, 0);
2888 path.lineTo(1122.5f, 25.2136822f);
2889 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2890 path.quadTo(1120.07104f, 28, 1118, 28);
2891 path.lineTo(888, 28);
2892 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2893 path.quadTo(883, 25.0710678f, 883, 23);
2894 path.close();
2906 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2910 SkPath path;
2911 path.setFillType(SkPath::kEvenOdd_FillType);
2912 path.moveTo(883, 23);
2913 path.lineTo(883, 0);
2914 path.lineTo(1122.5f, 0);
2915 path.lineTo(1122.5f, 25.2136822f);
2916 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2917 path.quadTo(1120.07104f, 28, 1118, 28);
2918 path.lineTo(888, 28);
2919 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2920 path.quadTo(883, 25.0710678f, 883, 23);
2921 path.close();
2933 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2937 SkPath path;
2938 path.setFillType(SkPath::kEvenOdd_FillType);
2939 path.moveTo(160.000488f, 918);
2940 path.cubicTo(159.164749f, 917.37207f, 158.125824f, 917, 157, 917);
2941 path.lineTo(94, 917);
2942 path.cubicTo(92.874176f, 917, 91.8352661f, 917.37207f, 90.9995193f, 918);
2943 path.lineTo(160.000488f, 918);
2944 path.close();
2952 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2956 SkPath path;
2957 path.setFillType(SkPath::kEvenOdd_FillType);
2958 path.moveTo(1138, 231);
2959 path.lineTo(1137, 243.625748f);
2960 path.lineTo(1137, 926);
2961 path.lineTo(1139, 926);
2962 path.lineTo(1139, 231);
2963 path.lineTo(1138, 231);
2964 path.close();
2971 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2975 SkPath path, pathB;
2976 path.setFillType(SkPath::kEvenOdd_FillType);
2977 path.moveTo(0, 2);
2978 path.cubicTo(2, 3, 5, 1, 3, 2);
2979 path.close();
2984 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2988 SkPath path, pathB;
2989 path.setFillType(SkPath::kEvenOdd_FillType);
2990 path.moveTo(1, 6);
2991 path.cubicTo(0, 3, 6, 3, 5, 0);
2992 path.close();
2997 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3001 SkPath path, pathB;
3002 path.setFillType(SkPath::kEvenOdd_FillType);
3003 path.moveTo(0, 2);
3004 path.cubicTo(0, 6, 2, 1, 2, 1);
3005 path.close();
3010 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
3014 SkPath path, pathB;
3015 path.setFillType(SkPath::kEvenOdd_FillType);
3016 path.moveTo(0, 3);
3017 path.cubicTo(3, 6, 4, 1, 6, 3);
3018 path.close();
3023 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
3027 SkPath path, pathB;
3028 path.setFillType(SkPath::kWinding_FillType);
3029 path.moveTo(3,6);
3030 path.cubicTo(0,3, 6,5, 5,4);
3031 path.close();
3036 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3040 SkPath path, pathB;
3041 path.setFillType(SkPath::kWinding_FillType);
3042 path.moveTo(0,1);
3043 path.cubicTo(0,2, 2,1, 4,2);
3044 path.close();
3049 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3053 SkPath path, pathB;
3054 path.setFillType(SkPath::kWinding_FillType);
3055 path.moveTo(0, 1);
3056 path.cubicTo(2, 3, 2, 1, 5, 3);
3057 path.close();
3062 path, pathB, kIntersect_SkPathOp, filename);
3066 SkPath path, pathB;
3067 path.setFillType(SkPath::kWinding_FillType);
3068 path.moveTo(0,1);
3069 path.cubicTo(1,2, 1,0, 3,0);
3070 path.close();
3075 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3079 SkPath path, pathB;
3080 path.setFillType(SkPath::kWinding_FillType);
3081 path.moveTo(0,1);
3082 path.cubicTo(1,5, 2,0, 2,1);
3083 path.close();
3088 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3092 SkPath path, pathB;
3093 path.setFillType(SkPath::kWinding_FillType);
3094 path.moveTo(0,1);
3095 path.cubicTo(0,6, 4,0, 6,1);
3096 path.close();
3101 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3105 SkPath path, pathB;
3106 path.setFillType(SkPath::kWinding_FillType);
3107 path.moveTo(0,1);
3108 path.cubicTo(0,4, 6,5, 2,0);
3109 path.close();
3114 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3118 SkPath path, pathB;
3119 path.setFillType(SkPath::kWinding_FillType);
3120 path.moveTo(0, 1);
3121 path.cubicTo(4, 6, 2, 1, 2, 0);
3122 path.close();
3127 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3131 SkPath path, pathB;
3132 path.setFillType(SkPath::kWinding_FillType);
3133 path.moveTo(0, 1);
3134 path.cubicTo(4, 6, 2, 1, 2, 0);
3135 path.close();
3140 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3144 SkPath path, pathB;
3145 path.setFillType(SkPath::kWinding_FillType);
3146 path.moveTo(0, 1);
3147 path.cubicTo(4, 6, 2, 1, 2, 0);
3148 path.close();
3153 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3157 SkPath path, pathB;
3158 path.setFillType(SkPath::kWinding_FillType);
3159 path.moveTo(0,1);
3160 path.cubicTo(4,5, 6,3, 5,4);
3161 path.close();
3166 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3170 SkPath path, pathB;
3171 path.setFillType(SkPath::kEvenOdd_FillType);
3172 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3173 path.addRect(0, 0, 4, 4, SkPath::kCW_Direction);
3177 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3181 SkPath path, pathB;
3182 path.setFillType(SkPath::kWinding_FillType);
3183 path.moveTo(1,4);
3184 path.cubicTo(0,5, 4,1, 3,1);
3185 path.close();
3190 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3194 SkPath path, pathB;
3195 path.setFillType(SkPath::kEvenOdd_FillType);
3196 path.moveTo(1, 4);
3197 path.cubicTo(4, 5, 3, 2, 6, 3);
3198 path.close();
3203 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3207 SkPath path, pathB;
3208 path.setFillType(SkPath::kEvenOdd_FillType);
3209 path.moveTo(1, 4);
3210 path.cubicTo(1, 5, 6, 0, 5, 1);
3211 path.close();
3216 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3220 SkPath path, pathB;
3221 path.setFillType(SkPath::kEvenOdd_FillType);
3222 path.moveTo(1, 5);
3223 path.cubicTo(0, 4, 3, 2, 6, 1);
3224 path.close();
3229 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3233 SkPath path, pathB;
3234 path.setFillType(SkPath::kWinding_FillType);
3235 path.moveTo(1,4);
3236 path.cubicTo(0,5, 4,1, 3,1);
3237 path.close();
3242 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3246 SkPath path, pathB;
3247 path.setFillType(SkPath::kWinding_FillType);
3248 path.moveTo(0,1);
3249 path.cubicTo(1,6, 5,0, 2,1);
3250 path.close();
3255 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3259 SkPath path, pathB;
3260 path.setFillType(SkPath::kWinding_FillType);
3261 path.moveTo(2,4);
3262 path.cubicTo(2,3, 6,4, 1,0);
3263 path.close();
3268 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3272 SkPath path, pathB;
3273 path.moveTo(2,4);
3274 path.cubicTo(3,5, 2.33333325f,4.33333349f, 3.83333325f,3.83333349f);
3275 path.close();
3279 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3283 SkPath path, pathB;
3284 path.setFillType(SkPath::kWinding_FillType);
3285 path.moveTo(0, 1);
3286 path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
3287 path.close();
3292 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3296 SkPath path, pathB;
3297 path.setFillType(SkPath::kWinding_FillType);
3298 path.moveTo(0, 1);
3299 path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
3300 path.close();
3306 CubicPathToQuads(path, &qPath);
3312 SkPath path, pathB;
3313 path.moveTo(0, 0);
3314 path.quadTo(1, 8, 3, 5);
3315 path.lineTo(8, 1);
3316 path.close();
3320 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3382 SkPath path, pathB;
3383 path.setFillType(SkPath::kEvenOdd_FillType);
3384 path.moveTo(0, 0);
3385 path.lineTo(1, 0);
3386 path.lineTo(1, 1);
3387 path.lineTo(0, 1);
3388 path.close();
3389 path.moveTo(0, 0);
3390 path.lineTo(6, 0);
3391 path.lineTo(6, 6);
3392 path.lineTo(0, 6);
3393 path.close();
3405 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3409 SkPath path, pathB;
3410 path.setFillType(SkPath::kEvenOdd_FillType);
3411 path.moveTo(0, 0);
3412 path.lineTo(4, 0);
3413 path.lineTo(4, 4);
3414 path.lineTo(0, 4);
3415 path.close();
3416 path.moveTo(3, 3);
3417 path.lineTo(4, 3);
3418 path.lineTo(4, 4);
3419 path.lineTo(3, 4);
3420 path.close();
3432 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3436 SkPath path, pathB;
3437 path.setFillType(SkPath::kEvenOdd_FillType);
3438 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3439 path.addRect(0, 0, 4, 4, SkPath::kCW_Direction);
3443 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3447 SkPath path, pathB;
3448 path.setFillType(SkPath::kEvenOdd_FillType);
3449 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3450 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3454 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3506 SkPath path, pathB;
3507 path.setFillType(SkPath::kWinding_FillType);
3508 path.moveTo(0,1);
3509 path.cubicTo(3,4, 2,1, 5,3);
3510 path.close();
3515 SkPath path2(path);
3516 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3520 SkPath path, path2;
3521 path.addRect(0, 0, 60, 60, SkPath::kCCW_Direction);
3522 path.addRect(30, 20, 50, 50, SkPath::kCCW_Direction);
3523 path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
3524 // path.addRect(32, 24, 36, 41, SkPath::kCCW_Direction);
3525 testPathOp(reporter, path, path2, kUnion_SkPathOp, filename);
3529 SkPath path, pathB;
3530 path.setFillType(SkPath::kWinding_FillType);
3531 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3532 path.addRect(4, 4, 5, 5, SkPath::kCW_Direction);
3536 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3540 SkPath path, pathB;
3541 path.setFillType(SkPath::kWinding_FillType);
3542 path.moveTo(0,1);
3543 path.cubicTo(4,6, 2,0, 2,0);
3544 path.close();
3549 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3553 SkPath path, pathB;
3554 path.setFillType(SkPath::kWinding_FillType);
3555 path.moveTo(0,1);
3556 path.cubicTo(4,5, 6,0, 1,0);
3557 path.close();
3562 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3566 SkPath path, pathB;
3567 path.setFillType(SkPath::kWinding_FillType);
3568 path.moveTo(0,1);
3569 path.cubicTo(4,6, 5,1, 6,2);
3570 path.close();
3575 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3579 SkPath path, pathB;
3580 path.moveTo(0,1);
3581 path.cubicTo(1,5, -5.66666651f,3.33333349f, 8.83333302f,2.33333349f);
3582 path.close();
3586 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3609 SkPath path, pathB;
3610 path.moveTo(q1a[0].fPts[0].asSkPoint());
3611 path.quadTo(q1a[0].fPts[1].asSkPoint(), q1a[0].fPts[2].asSkPoint());
3612 path.quadTo(q1a[1].fPts[1].asSkPoint(), q1a[1].fPts[2].asSkPoint());
3613 path.quadTo(q1[1].fPts[1].asSkPoint(), q1[1].fPts[2].asSkPoint());
3614 path.close();
3619 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3623 SkPath path, pathB;
3624 path.moveTo(0,1);
3625 path.cubicTo(3,4, 3.f,4.f, 4.5f,1.5f);
3626 path.close();
3630 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3634 SkPath path, pathB;
3635 path.moveTo(0,1);
3636 path.cubicTo(3,5, -3.66666651f,0, 10.5f,-1.66666651f);
3637 path.close();
3641 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3645 SkPath path, pathB;
3646 path.moveTo(0,5);
3647 path.cubicTo(1,5, 1,4, 0.833333313f,3);
3648 path.close();
3652 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3658 SkPath path, pathB;
3661 SkParsePath::FromSVGString(str, &path);
3665 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3669 SkPath path, pathB;
3670 path.setFillType(SkPath::kWinding_FillType);
3671 path.moveTo(0,1);
3672 path.cubicTo(3,5, 2,1, 3,1);
3673 path.close();
3678 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3682 SkPath path, pathB;
3683 path.setFillType(SkPath::kWinding_FillType);
3684 path.moveTo(0,1);
3685 path.cubicTo(2,4, 2,1, 4,0);
3686 path.close();
3691 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3695 SkPath path, pathB;
3696 path.setFillType(SkPath::kWinding_FillType);
3697 path.moveTo(0,1);
3698 path.cubicTo(3,4, 3,2, 4,3);
3699 path.close();
3704 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3709 SkPath path, pathB;
3710 path.setFillType(SkPath::kWinding_FillType);
3711 path.moveTo(0,1);
3712 path.cubicTo(3,5, 4,1, 4,0);
3713 path.close();
3718 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3722 SkPath path, pathB;
3723 path.setFillType(SkPath::kWinding_FillType);
3724 path.moveTo(0,1);
3725 path.cubicTo(1,5, 2,0, 6,0);
3726 path.close();
3731 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3735 SkPath path, pathB;
3736 path.moveTo(0,2);
3737 path.cubicTo(1,2, 1,1.66666663f, 0.833333313f,1.33333325f);
3738 path.close();
3742 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3746 SkPath path, pathB;
3747 path.moveTo(0,1);
3748 path.cubicTo(1,3, -1.66666675f,1.66666663f, 4.16666651f,1.00000012f);
3749 path.close();
3753 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3757 SkPath path, pathB;
3758 path.setFillType(SkPath::kWinding_FillType);
3759 path.moveTo(0,1);
3760 path.cubicTo(1,5, 6,0, 3,0);
3761 path.close();
3766 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3770 SkPath path, pathB;
3771 path.setFillType(SkPath::kWinding_FillType);
3772 path.moveTo(0,1);
3773 path.cubicTo(3,6, 3,1, 6,2);
3774 path.close();
3779 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3783 SkPath path, pathB;
3784 path.setFillType(SkPath::kWinding_FillType);
3785 path.moveTo(0,1);
3786 path.cubicTo(0,3, 6,0, 2,1);
3787 path.close();
3792 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3796 SkPath path, pathB;
3797 path.setFillType(SkPath::kWinding_FillType);
3798 path.moveTo(0,1);
3799 path.cubicTo(1,5, 6,0, 3,0);
3800 path.close();
3805 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3809 SkPath path, pathB;
3810 path.setFillType(SkPath::kWinding_FillType);
3811 path.moveTo(0,1);
3812 path.cubicTo(0,3, 3,2, 5,2);
3813 path.close();
3818 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3822 SkPath path, pathB;
3823 path.setFillType(SkPath::kWinding_FillType);
3824 path.moveTo(5,6);
3825 path.cubicTo(3,4, 2,0, 2,1);
3826 path.close();
3831 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3835 SkPath path, pathB;
3836 path.setFillType(SkPath::kWinding_FillType);
3837 path.moveTo(5,6);
3838 path.cubicTo(4,6, 3,0, 2,1);
3839 path.close();
3844 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3849 static void complex_to_quads(const SkPoint pts[], SkPath* path) {
3859 path->quadTo(q1[1].asSkPoint(), q1[2].asSkPoint());
3860 path->quadTo(q2[1].asSkPoint(), q2[2].asSkPoint());
3862 path->cubicTo(pts[1], pts[2], pts[3]);
3867 SkPath path, pathB;
3868 path.setFillType(SkPath::kWinding_FillType);
3869 path.moveTo(5,6);
3871 complex_to_quads(pts, &path);
3872 path.close();
3876 complex_to_quads(pts2, &path);
3878 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3882 SkPath path, pathB;
3883 path.setFillType(SkPath::kWinding_FillType);
3884 path.moveTo(0,1);
3885 path.cubicTo(3,4, 3,0, 6,2);
3886 path.close();
3891 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3895 SkPath path, pathB;
3896 path.setFillType(SkPath::kWinding_FillType);
3897 path.addCircle(0, 1, 2, SkPath::kCCW_Direction);
3900 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3904 SkPath path, pathB;
3905 path.setFillType(SkPath::kWinding_FillType);
3906 path.addCircle(0, 1, 4, SkPath::kCCW_Direction);
3909 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3913 SkPath path, pathB;
3914 path.setFillType(SkPath::kEvenOdd_FillType);
3915 path.moveTo(20.65f, 5.65f);
3916 path.conicTo(20.65f, 1.13612f, 25.1404f, 0.65f, 0.888488f);
3917 path.lineTo(25.65f, 0.65f);
3918 path.lineTo(26.1596f, 0.67604f);
3919 path.conicTo(30.65f, 1.13612f, 30.65f, 5.65f, 0.888488f);
3920 path.lineTo(30.65f, 25.65f);
3921 path.conicTo(30.65f, 20.65f, 25.65f, 20.65f, 0.707107f);
3922 path.lineTo(20.65f, 20.65f);
3923 path.lineTo(20.65f, 5.65f);
3924 path.close();
3925 path.moveTo(20.65f, 20.65f);
3926 path.lineTo(5.65f, 20.65f);
3927 path.conicTo(0.65f, 20.65f, 0.65f, 25.65f, 0.707107f);
3928 path.lineTo(0.65f, 45.65f);
3929 path.conicTo(0.65f, 50.65f, 5.65f, 50.65f, 0.707107f);
3930 path.lineTo(25.65f, 50.65f);
3931 path.conicTo(30.65f, 50.65f, 30.65f, 45.65f, 0.707107f);
3932 path.lineTo(30.65f, 25.65f);
3933 path.conicTo(30.65f, 30.65f, 25.65f, 30.65f, 0.707107f);
3934 path.conicTo(20.65f, 30.65f, 20.65f, 25.65f, 0.707107f);
3935 path.lineTo(20.65f, 20.65f);
3936 path.close();
3937 SkPath path1(path);
3939 path.reset();
3940 path.setFillType(SkPath::kWinding_FillType);
3941 path.moveTo(20.65f, 45.65f);
3942 path.lineTo(20.65f, 25.65f);
3943 path.conicTo(20.65f, 20.65f, 25.65f, 20.65f, 0.707107f);
3944 path.lineTo(45.65f, 20.65f);
3945 path.conicTo(50.65f, 20.65f, 50.65f, 25.65f, 0.707107f);
3946 path.lineTo(50.65f, 45.65f);
3947 path.conicTo(50.65f, 50.65f, 45.65f, 50.65f, 0.707107f);
3948 path.lineTo(25.65f, 50.65f);
3949 path.conicTo(20.65f, 50.65f, 20.65f, 45.65f, 0.707107f);
3950 path.close();
3951 SkPath path2(path);
3957 SkPath path, pathB;
3958 path.moveTo(0,1);
3959 path.cubicTo(3,4, -1,0, 8.5f,-2.5f);
3960 path.close();
3964 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3968 SkPath path, pathB;
3969 path.setFillType(SkPath::kWinding_FillType);
3970 path.addRect(5, 5, 6, 6, SkPath::kCW_Direction);
3971 path.addRect(5, 5, 6, 6, SkPath::kCW_Direction);
3975 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3979 SkPath path, pathB;
3980 path.moveTo(0,1);
3981 path.cubicTo(1,4, -3.83333325f,0.166666627f, 6,-1);
3982 path.close();
3986 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3990 SkPath path, pathB;
3991 path.moveTo(0,1);
3992 path.cubicTo(1,3, -2.5f,0, 3.33333325f,-0.666666627f);
3993 path.close();
3997 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4001 SkPath path, pathB;
4002 path.setFillType(SkPath::kWinding_FillType);
4003 path.addCircle(0, 1, 2, SkPath::kCCW_Direction);
4006 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4010 SkPath path, pathB;
4011 path.moveTo(5,6);
4012 path.cubicTo(1,2, 1,2, -3.66666651f,13.333334f);
4013 path.close();
4017 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4021 SkPath path, pathB;
4022 path.moveTo(0,1);
4023 path.cubicTo(1,3, -1.83333349f,1.33333337f, 4,-1);
4024 path.close();
4028 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4032 SkPath path, pathB;
4033 path.setFillType(SkPath::kWinding_FillType);
4034 path.moveTo(5,6);
4035 path.cubicTo(3,4, 3,0, 3,2);
4036 path.close();
4041 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4045 SkPath path, pathB;
4046 path.moveTo(1,2);
4047 path.cubicTo(0,6, -3.16666675f,3.66666675f, 6.33333349f,3.33333349f);
4048 path.close();
4052 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4056 SkPath path, pathB;
4057 path.setFillType(SkPath::kWinding_FillType);
4058 path.moveTo(5,6);
4059 path.cubicTo(5,6, 5,0, 4,1);
4060 path.close();
4065 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4069 SkPath path, pathB;
4070 path.setFillType(SkPath::kWinding_FillType);
4071 path.moveTo(5,6);
4072 path.cubicTo(5,6, 6,0, 3,1);
4073 path.close();
4078 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4082 SkPath path, pathB;
4083 path.setFillType(SkPath::kWinding_FillType);
4084 path.moveTo(5,6);
4085 path.cubicTo(5,6, 6,0, 4,1);
4086 path.close();
4091 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4095 SkPath path, pathB;
4096 path.setFillType(SkPath::kWinding_FillType);
4097 path.moveTo(5,6);
4098 path.cubicTo(5,6, 5,0, 3,1);
4099 path.close();
4104 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4108 SkPath path, pathB;
4109 path.setFillType(SkPath::kWinding_FillType);
4110 path.moveTo(5,6);
4111 path.quadTo(5,0, 3,1);
4112 path.close();
4117 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4121 SkPath path, pathB;
4122 path.setFillType(SkPath::kWinding_FillType);
4123 path.moveTo(0, 5);
4124 path.cubicTo(3, 6, 1, 0, 3, 2);
4125 path.close();
4130 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4134 SkPath path, pathB;
4135 path.setFillType(SkPath::kWinding_FillType);
4136 path.moveTo(0, 5);
4137 path.cubicTo(3, 6, 1, 0, 4, 2);
4138 path.close();
4143 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4148 SkPath path, pathB;
4149 path.setFillType(SkPath::kWinding_FillType);
4150 path.moveTo(0,2);
4151 path.cubicTo(0,4, 3,1, 5,1);
4152 path.close();
4157 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4161 SkPath path, pathB;
4162 path.setFillType(SkPath::kWinding_FillType);
4163 path.moveTo(0,2);
4164 path.cubicTo(1,2, 5,4, 3,2);
4165 path.close();
4170 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4174 SkPath path, pathB;
4175 path.setFillType(SkPath::kWinding_FillType);
4176 path.moveTo(0,2);
4177 path.cubicTo(1,2, 6,4, 3,2);
4178 path.close();
4183 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4187 SkPath path, pathB;
4188 path.moveTo(6,15);
4189 path.quadTo(16,0, 8,4);
4190 path.quadTo(2,7, 12,12);
4191 path.close();
4193 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4197 SkPath path, pathB;
4198 path.moveTo(5,12);
4199 path.quadTo(15,7, 9,4);
4200 path.quadTo(1,0, 11,15);
4201 path.close();
4203 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4207 SkPath path, pathB;
4208 path.moveTo(12,12);
4209 path.quadTo(2,7, 8,4);
4210 path.quadTo(16,0, 6,15);
4211 path.close();
4213 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4217 SkPath path, pathB;
4218 path.moveTo(11,15);
4219 path.quadTo(1,0, 9,4);
4220 path.quadTo(15,7, 5,12);
4221 path.close();
4223 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4227 SkPath path, pathB;
4228 path.moveTo(11,13);
4229 path.quadTo(4,4, 8,4);
4230 path.quadTo(12,4, 5,13);
4231 path.close();
4233 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4237 SkPath path, pathB;
4238 path.moveTo(5,13);
4239 path.quadTo(12,4, 8,4);
4240 path.quadTo(4,4, 11,13);
4241 path.close();
4243 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4247 SkPath path, pathB;
4248 path.setFillType(SkPath::kWinding_FillType);
4249 path.moveTo(0, 3);
4250 path.cubicTo(0, 2, 0, 2, -1.66666663f, 2.16666675f);
4251 path.close();
4256 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4260 SkPath path, pathB;
4261 path.setFillType(SkPath::kWinding_FillType);
4262 path.moveTo(1, 2);
4263 path.cubicTo(0, 2, 0, 2, 0.166666672f, 2.66666675f);
4264 path.close();
4269 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4273 SkPath path, pathB;
4274 path.setFillType(SkPath::kWinding_FillType);
4275 path.moveTo(5,6);
4276 path.cubicTo(2,5, 2,1, 1,0);
4277 path.close();
4282 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4286 SkPath path, pathB;
4287 path.setFillType(SkPath::kWinding_FillType);
4288 path.moveTo(3, 5);
4289 path.cubicTo(1, 5, 4, 2, 4, 0);
4290 path.close();
4295 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4299 SkPath path, pathB;
4300 path.setFillType(SkPath::kWinding_FillType);
4301 path.moveTo(2, 6);
4302 path.cubicTo(2, 4, 5, 1, 3, 1);
4303 path.close();
4308 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4312 SkPath path, pathB;
4313 path.setFillType(SkPath::kWinding_FillType);
4314 path.moveTo(2, 5);
4315 path.cubicTo(2, 4, 5, 1, 3, 2);
4316 path.close();
4321 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4325 SkPath path, pathB;
4326 path.setFillType(SkPath::kWinding_FillType);
4327 path.moveTo(2, 4);
4328 path.cubicTo(2, 6, 3, 1, 5, 1);
4329 path.close();
4334 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4338 SkPath path, pathB;
4339 path.setFillType(SkPath::kWinding_FillType);
4340 path.moveTo(2, 4);
4341 path.cubicTo(1, 6, 4, 1, 5, 1);
4342 path.close();
4347 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
4351 SkPath path, pathB;
4352 path.setFillType(SkPath::kWinding_FillType);
4353 path.moveTo(2, 4);
4354 path
4355 path.close();
4360 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4364 SkPath path, pathB;
4365 path.setFillType(SkPath::kWinding_FillType);
4366 path.moveTo(2, 4);
4367 path.cubicTo(0, 4, 5, 3, 5, 1);
4368 path.close();
4373 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4377 SkPath path, pathB;
4378 path.setFillType(SkPath::kWinding_FillType);
4379 path.moveTo(2, 3);
4380 path.cubicTo(1, 5, 4, 2, 5, 2);
4381 path.close();
4386 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4390 SkPath path, pathB;
4391 path.setFillType(SkPath::kWinding_FillType);
4392 path.moveTo(2, 3);
4393 path.cubicTo(0, 4, 3, 1, 3, 0);
4394 path.close();
4399 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4403 SkPath path, pathB;
4404 path.setFillType(SkPath::kWinding_FillType);
4405 path.moveTo(1, 5);
4406 path.cubicTo(3, 5, 4, 0, 4, 2);
4407 path.close();
4412 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4416 SkPath path, pathB;
4417 path.setFillType(SkPath::kWinding_FillType);
4418 path.moveTo(1, 5);
4419 path.cubicTo(2, 5, 5, 0, 4, 2);
4420 path.close();
4425 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4429 SkPath path, pathB;
4430 path.setFillType(SkPath::kWinding_FillType);
4431 path.moveTo(1, 5);
4432 path.cubicTo(3, 4, 4, 1, 4, 2);
4433 path.close();
4438 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4442 SkPath path, pathB;
4443 path.setFillType(SkPath::kWinding_FillType);
4444 path.moveTo(1, 5);
4445 path.cubicTo(1, 3, 4, 0, 2, 0);
4446 path.close();
4451 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4455 SkPath path, pathB;
4456 path.setFillType(SkPath::kWinding_FillType);
4457 path.moveTo(1, 5);
4458 path.cubicTo(2, 3, 5, 2, 4, 2);
4459 path.close();
4464 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4468 SkPath path, pathB;
4469 path.setFillType(SkPath::kWinding_FillType);
4470 path.moveTo(1,5);
4471 path.cubicTo(1,3, 6,2, 4,2);
4472 path.close();
4477 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4481 SkPath path, pathB;
4482 path.setFillType(SkPath::kWinding_FillType);
4483 path.moveTo(1, 2);
4484 path.cubicTo(0, 3, 6, 0, 3, 2);
4485 path.close();
4490 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4494 SkPath path, pathB;
4495 path.setFillType(SkPath::kWinding_FillType);
4496 path.moveTo(1, 2);
4497 path.cubicTo(0, 2, 0.833333313f, 2, 1, 3.66666651f);
4498 path.close();
4503 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4507 SkPath path, pathB;
4508 path.setFillType(SkPath::kWinding_FillType);
4509 path.moveTo(1, 2);
4510 path.cubicTo(0, 2, 0.833333313f, 2, 1, 4);
4511 path.close();
4516 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4520 SkPath path, pathB;
4521 path.setFillType(SkPath::kWinding_FillType);
4522 path.moveTo(1, 3);
4523 path.cubicTo(0, 3, 0.833333313f, 3, 1, 4.66666651f);
4524 path.close();
4529 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4533 SkPath path, pathB;
4534 path.setFillType(SkPath::kWinding_FillType);
4535 path.moveTo(1, 5);
4536 path.cubicTo(0, 1, 6.16666698f, 5.66666698f, -5.66666651f, 6.66666651f);
4537 path.close();
4542 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4546 SkPath path, pathB;
4547 path.setFillType(SkPath::kWinding_FillType);
4548 path.moveTo(1, 2);
4549 path.cubicTo(0, 2, 0.833333313f, 2, 1, 3);
4550 path.close();
4555 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4559 SkPath path, pathB;
4560 path.setFillType(SkPath::kWinding_FillType);
4561 path.moveTo(1, 5);
4562 path.cubicTo(0, 5, 0.833333313f, 5, 1, 7);
4563 path.close();
4568 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4572 SkPath path, pathB;
4573 path.setFillType(SkPath::kWinding_FillType);
4574 path.moveTo(1, 6);
4575 path.cubicTo(0, 2, 6.16666698f, 6.66666698f, -5.66666651f, 7.66666651f);
4576 path.close();
4581 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4585 SkPath path, pathB;
4586 path.setFillType(SkPath::kWinding_FillType);
4587 path.moveTo(1, 3);
4588 path.cubicTo(0, 3, 0.833333313f, 3, 1, 4.33333349f);
4589 path.close();
4594 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4598 SkPath path, pathB;
4599 path.setFillType(SkPath::kWinding_FillType);
4600 path.moveTo(2, 3);
4601 path.cubicTo(1, 3, 1.83333337f, 3, 2, 4.66666651f);
4602 path.close();
4607 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4611 SkPath path, pathB;
4612 path.setFillType(SkPath::kWinding_FillType);
4613 path.moveTo(2, 4);
4614 path.cubicTo(0, 4, 1.66666663f, 4, 2, 7.33333302f);
4615 path.close();
4620 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4624 SkPath path, pathB;
4625 path.setFillType(SkPath::kWinding_FillType);
4626 path.moveTo(2, 4);
4627 path.cubicTo(0, 4, 1.66666663f, 4, 2, 8);
4628 path.close();
4633 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4637 SkPath path, pathB;
4638 path.setFillType(SkPath::kWinding_FillType);
4639 path.moveTo(2, 5);
4640 path.cubicTo(1, 5, 1.83333337f, 5, 2, 6.66666651f);
4641 path.close();
4646 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4650 SkPath path, pathB;
4651 path.setFillType(SkPath::kWinding_FillType);
4652 path.moveTo(2, 6);
4653 path.cubicTo(1, 6, 1.83333337f, 6, 2, 8);
4654 path.close();
4659 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4663 SkPath path, pathB;
4664 path.setFillType(SkPath::kWinding_FillType);
4665 path.moveTo(2, 6);
4666 path.cubicTo(1, 2, 7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f);
4667 path.close();
4672 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4689 SkPath path, pathB;
4690 path.setFillType(SkPath::kWinding_FillType);
4691 path.moveTo(pts[0]);
4692 path.cubicTo(pts[1], pts[2], pts[3]);
4693 path.close();
4698 bool result = testPathOp(reporter, path, pathB, kIntersect_SkPathOp, name.c_str());
4710 SkPath path, pathB;
4711 path.setFillType(SkPath::kWinding_FillType);
4712 path.moveTo(2, 6);
4713 path.cubicTo(1, 2, 7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f);
4714 path.close();
4720 CubicPathToQuads(path, &qPath);
4726 SkPath path, pathB;
4727 path.setFillType(SkPath::kWinding_FillType);
4728 path.moveTo(3, 4);
4729 path.cubicTo(0, 4, 2.5f, 4, 3, 9);
4730 path.close();
4735 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4739 SkPath path, pathB;
4740 path.setFillType(SkPath::kWinding_FillType);
4741 path.moveTo(3, 4);
4742 path.cubicTo(0, 4, 2.5f, 4, 3, 10);
4743 path.close();
4748 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4752 SkPath path, pathB;
4753 path.setFillType(SkPath::kWinding_FillType);
4754 path.moveTo(3, 4);
4755 path.cubicTo(1, 4, 2.66666675f, 4, 3, 8);
4756 path.close();
4761 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4765 SkPath path, pathB;
4766 path.setFillType(SkPath::kWinding_FillType);
4767 path.moveTo(2, 4);
4768 path.cubicTo(1, 4, 1.83333337f, 4, 2, 5.33333349f);
4769 path.close();
4774 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4778 SkPath path, pathB;
4779 path.setFillType(SkPath::kWinding_FillType);
4780 path.moveTo(3, 4);
4781 path.cubicTo(2, 4, 2.83333325f, 4, 3, 6);
4782 path.close();
4787 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4791 SkPath path, pathB;
4792 path.setFillType(SkPath::kWinding_FillType);
4793 path.moveTo(3, 5);
4794 path.cubicTo(0, 5, 2.5f, 5, 3, 10);
4795 path.close();
4800 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4804 SkPath path, pathB;
4805 path.setFillType(SkPath::kWinding_FillType);
4806 path.moveTo(3, 5);
4807 path.cubicTo(0, 5, 2.5f, 5, 3, 11);
4808 path.close();
4813 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4817 SkPath path, pathB;
4818 path.setFillType(SkPath::kWinding_FillType);
4819 path.moveTo(3, 5);
4820 path.cubicTo(0, 5, 2.5f, 5, 3, 11);
4821 path.close();
4827 CubicPathToQuads(path, &qPath);
4833 SkPath path, pathB;
4834 path.setFillType(SkPath::kWinding_FillType);
4835 path.moveTo(1, 5);
4836 path.cubicTo(0, 1, 7.33333302f, 5.33333349f, -7, 7);
4837 path.close();
4842 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4846 SkPath path, pathB;
4847 path.setFillType(SkPath::kWinding_FillType);
4848 path.moveTo(1, 6);
4849 path.cubicTo(0, 2, 7.33333302f, 6.33333302f, -7, 8);
4850 path.close();
4855 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4859 SkPath path, pathB;
4860 path.setFillType(SkPath::kWinding_FillType);
4861 path.moveTo(2, 6);
4862 path.cubicTo(1, 2, 8.33333302f, 6.33333302f, -6, 8);
4863 path.close();
4868 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4874 SkPath path, pathB;
4875 path.setFillType(SkPath::kWinding_FillType);
4876 path.moveTo(2, 4);
4877 path.cubicTo(0, 1, 6, 5.83333302f, -4, 8);
4878 path.close();
4883 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4887 SkPath path, pathB;
4888 path.setFillType(SkPath::kWinding_FillType);
4889 path.moveTo(2, 6);
4890 path.cubicTo(0, 1, 9.33333302f, 6.83333302f, -8.33333302f, 9.16666603f);
4891 path.close();
4896 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4900 SkPath path, pathB;
4901 path.setFillType(SkPath::kWinding_FillType);
4902 path.moveTo(0, 2);
4903 path.cubicTo(1, 4, -0.166666687f, 2.66666675f, 1.66666675f, 2);
4904 path.close();
4909 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4913 SkPath path, pathB;
4914 path.setFillType(SkPath::kWinding_FillType);
4915 path.moveTo(0, 3);
4916 path.cubicTo(1, 5, -0.166666687f, 3.66666675f, 1.66666675f, 3);
4917 path.close();
4922 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4926 SkPath path, pathB;
4927 path.setFillType(SkPath::kWinding_FillType);
4928 path.moveTo(1, 2);
4929 path.cubicTo(2, 4, 0.833333313f, 2.66666675f, 2.66666675f, 2);
4930 path.close();
4935 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4939 SkPath path, pathB;
4940 path.setFillType(SkPath::kWinding_FillType);
4941 path.moveTo(1, 3);
4942 path.cubicTo(2, 5, 0.833333313f, 3.66666675f, 2.66666675f, 3);
4943 path.close();
4948 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4952 SkPath path, pathB;
4953 path.setFillType(SkPath::kWinding_FillType);
4954 path.moveTo(2, 3);
4955 path.cubicTo(3, 5, 1.83333325f, 3.66666675f, 3.66666651f, 3);
4956 path.close();
4961 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4965 SkPath path, pathB;
4966 path.setFillType(SkPath::kWinding_FillType);
4967 path.moveTo(0, 2);
4968 path.cubicTo(1, 4, 0, 3, 1.66666675f, 2);
4969 path.close();
4974 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4978 SkPath path, pathB;
4979 path.setFillType(SkPath::kWinding_FillType);
4980 path.moveTo(0, 3);
4981 path.cubicTo(1, 5, 0, 4, 1.66666675f, 3);
4982 path.close();
4987 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4991 SkPath path, pathB;
4992 path.setFillType(SkPath::kWinding_FillType);
4993 path.moveTo(1, 2);
4994 path.cubicTo(2, 4, 0.99999994f, 3, 2.66666675f, 2);
4995 path.close();
5000 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5004 SkPath path, pathB;
5005 path.setFillType(SkPath::kWinding_FillType);
5006 path.moveTo(1, 3);
5007 path.cubicTo(2, 5, 0.99999994f, 4, 2.66666675f, 3);
5008 path.close();
5013 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5017 SkPath path, pathB;
5018 path.setFillType(SkPath::kWinding_FillType);
5019 path.moveTo(2, 3);
5020 path.cubicTo(3, 5, 2, 4, 3.66666651f, 3);
5021 path.close();
5026 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5030 SkPath path, pathB;
5031 path.setFillType(SkPath::kWinding_FillType);
5032 path.moveTo(2, 3);
5033 path.cubicTo(3, 5, 2, 4, 3.66666651f, 3);
5034 path.close();
5040 CubicPathToQuads(path, &qPath);
5049 SkPath path, pathB;
5050 path.setFillType(SkPath::kWinding_FillType);
5051 path.moveTo(0, 6);
5052 path.cubicTo(1, 2, 7.33333302f, 1.66666663f, -7.5f, 2);
5053 path.close();
5058 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5062 SkPath path, pathB;
5063 path.setFillType(SkPath::kWinding_FillType);
5064 path.moveTo(0, 6);
5065 path.cubicTo(1, 2, 7.33333302f, 1.66666663f, -7.5f, 2);
5066 path.close();
5072 CubicPathToQuads(path, &qPath);
5081 SkPath path, pathB;
5082 path.setFillType(SkPath::kWinding_FillType);
5083 path.moveTo(0, 1);
5084 path.cubicTo(1, 4, 3, 0, 3, 1);
5085 path.close();
5090 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5094 SkPath path, pathB;
5095 path.setFillType(SkPath::kWinding_FillType);
5096 path.moveTo(0, 1);
5097 path.cubicTo(1, 5, -6.33333302f, 0.666666627f, 8, -1);
5098 path.close();
5103 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5107 SkPath path, pathB;
5108 path.setFillType(SkPath::kWinding_FillType);
5109 path.moveTo(0, 2);
5110 path.cubicTo(1, 6, -6.33333302f, 1.66666663f, 8, 0);
5111 path.close();
5116 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5120 SkPath path, pathB;
5121 path.setFillType(SkPath::kWinding_FillType);
5122 path.moveTo(0, 1);
5123 path.cubicTo(2, 4, -4, -0.833333254f, 6, -3);
5124 path.close();
5129 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5133 SkPath path, pathB;
5134 path.setFillType(SkPath::kWinding_FillType);
5135 path.moveTo(3, 4);
5136 path.cubicTo(2, 5, 3, 1, 6, 2);
5137 path.close();
5142 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5146 SkPath path, pathB;
5147 path.setFillType(SkPath::kWinding_FillType);
5148 path.moveTo(1, 3);
5149 path.cubicTo(2, 6, 4, 3, 5, 2);
5150 path.close();
5155 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
5159 SkPath path, pathB;
5160 path.moveTo(100.34f, 303.312f);
5161 path.lineTo(-1e+08, 303.312f);
5162 path.lineTo(102, 310.156f);
5163 path.lineTo(100.34f, 310.156f);
5164 path.lineTo(100.34f, 303.312f);
5165 path.close();
5166 testPathOpCheck(reporter, path, pathB, kUnion_SkPathOp, filename, true);
5170 SkPath path;
5171 path.setFillType((SkPath::FillType) 1);
5172 path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0xcf000000)); // 360, -2.14748e+09f
5173 path.cubicTo(SkBits2Float(0x4e0d628f), SkBits2Float(0xceffffff), SkBits2Float(0x4e800003), SkBits2Float(0xcec6b143), SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffc)); // 5.93012e+08f, -2.14748e+09f, 1.07374e+09f, -1.66675e+09f, 1.07374e+09f, -1.07374e+09f
5174 path.cubicTo(SkBits2Float(0x4e800002), SkBits2Float(0xcde53aee), SkBits2Float(0x4e0d6292), SkBits2Float(0xc307820e), SkBits2Float(0x44627d00), SkBits2Float(0x437ffff2)); // 1.07374e+09f, -4.80731e+08f, 5.93012e+08f, -135.508f, 905.953f, 256
5175 path.lineTo(SkBits2Float(0x444bf3bc), SkBits2Float(0x4460537e)); // 815.808f, 897.305f
5176 path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f
5177 path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000)); // 32, 16
5178 path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000)); // 100, 512
5179 path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f
5180 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000)); // 360, 1024
5181 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140
5183 SkPath path1(path);
5184 path.reset();
5185 path.setFillType((SkPath::FillType) 0);
5186 path.moveTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321
5187 path.lineTo(SkBits2Float(0x45d5c000), SkBits2Float(0x43870000)); // 6840, 270
5188 path.lineTo(SkBits2Float(0xd0a00000), SkBits2Float(0x4cbebc20)); // -2.14748e+10f, 1e+08
5189 path.lineTo(SkBits2Float(0x451f7000), SkBits2Float(0x42800000)); // 2551, 64
5190 path.lineTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321
5191 path.close();
5193 SkPath path2(path);
5198 SkPath path;
5199 path.setFillType(SkPath::kEvenOdd_FillType);
5200 path.moveTo(SkBits2Float(0x41e80000), SkBits2Float(0x43bde212)); // 29, 379.766f
5201 path.lineTo(SkBits2Float(0x41e80000), SkBits2Float(0x43bdc7ef)); // 29, 379.562f
5202 path.conicTo(SkBits2Float(0x42a5861e), SkBits2Float(0x43c61f86), SkBits2Float(0x430b0610), SkBits2Float(0x43c61f86), SkBits2Float(0x3f7d23f3)); // 82.7619f, 396.246f, 139.024f, 396.246f, 0.98883f
5203 path.conicTo(SkBits2Float(0x42a58e20), SkBits2Float(0x43c61f86), SkBits2Float(0x41e80000), SkBits2Float(0x43bde212), SkBits2Float(0x3f7d2cf5)); // 82.7776f, 396.246f, 29, 379.766f, 0.988967f
5204 path.close();
5206 SkPath path1(path);
5207 path.setFillType(SkPath::kWinding_FillType);
5208 path.moveTo(SkBits2Float(0xc36c7bd8), SkBits2Float(0xc3a31d72)); // -236.484f, -326.23f
5209 path.lineTo(SkBits2Float(0xc367a4ae), SkBits2Float(0xc3a31d72)); // -231.643f, -326.23f
5210 path.lineTo(SkBits2Float(0x430b0610), SkBits2Float(0x43c61f86)); // 139.024f, 396.246f
5211 path.lineTo(SkBits2Float(0xc36c7bd8), SkBits2Float(0x43c61f86)); // -236.484f, 396.246f
5213 SkPath path2(path);
5218 SkPath path;
5219 path.setFillType((SkPath::FillType) 0);
5220 path.moveTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5221 path.cubicTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b), SkBits2Float(0x41531912), SkBits2Float(0x3f130322), SkBits2Float(0x4154a02b), SkBits2Float(0x3f2b74b3)); // 0.669749f, 13.2891f, 13.1936f, 0.574267f, 13.2891f, 0.669749f
5222 path.cubicTo(SkBits2Float(0x414a835a), SkBits2Float(0x3ec07ba6), SkBits2Float(0x413fcc0d), SkBits2Float(0x3e193319), SkBits2Float(0x4134a02b), SkBits2Float(0x00000000)); // 12.6571f, 0.375943f, 11.9873f, 0.149609f, 11.2891f, 0
5223 path.lineTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5224 path.close();
5225 SkPath path1(path);
5227 path.reset();
5228 path.setFillType((SkPath::FillType) 0);
5229 path
5230 path.cubicTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b), SkBits2Float(0x41531912), SkBits2Float(0x3f130322), SkBits2Float(0x4154a02b), SkBits2Float(0x3f2b74b3)); // 0.669749f, 13.2891f, 13.1936f, 0.574267f, 13.2891f, 0.669749f
5231 path.lineTo(SkBits2Float(0x417ab74b), SkBits2Float(0x4154a02b)); // 15.6697f, 13.2891f
5232 path.lineTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5233 path.close();
5234 SkPath path2(path);
5239 SkPath path, pathB;
5240 path.setFillType(SkPath::kWinding_FillType);
5241 path.moveTo(0, 1);
5242 path.cubicTo(3, 5, 1, 0, 3, 0);
5243 path.close();
5248 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5252 SkPath path, pathB;
5253 path.setFillType(SkPath::kWinding_FillType);
5254 path.moveTo(0, 1);
5255 path.cubicTo(2, 5, 2, 0, 2, 1);
5256 path.close();
5261 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5265 SkPath path, pathB;
5266 path.setFillType(SkPath::kWinding_FillType);
5267 path.moveTo(2, 3);
5268 path.cubicTo(0, 4, -0.333333343f, 4.66666651f, 3, 5.83333349f);
5269 path.close();
5274 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5278 SkPath path, pathB;
5279 path.setFillType(SkPath::kWinding_FillType);
5280 path.moveTo(2, 4);
5281 path.cubicTo(0, 5, -0.333333343f, 5.66666651f, 3, 6.83333302f);
5282 path.close();
5287 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5291 SkPath path, pathB;
5292 path.setFillType(SkPath::kWinding_FillType);
5293 path.moveTo(2, 5);
5294 path.cubicTo(0, 6, -0.333333343f, 6.66666651f, 3, 7.83333302f);
5295 path.close();
5300 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5304 SkPath path, pathB;
5305 path.setFillType(SkPath::kWinding_FillType);
5306 path.moveTo(3, 4);
5307 path.cubicTo(1, 5, 0.666666627f, 5.66666651f, 4, 6.83333302f);
5308 path.close();
5313 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5317 SkPath path, pathB;
5318 path.setFillType(SkPath::kWinding_FillType);
5319 path.moveTo(3, 5);
5320 path.cubicTo(1, 6, 0.666666627f, 6.66666651f, 4, 7.83333302f);
5321 path.close();
5326 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5330 SkPath path, pathB;
5331 path.setFillType(SkPath::kWinding_FillType);
5332 path.moveTo(4, 5);
5333 path.cubicTo(2, 6, 1.66666663f, 6.66666651f, 5, 7.83333302f);
5334 path.close();
5339 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5343 SkPath path, pathB;
5344 path.setFillType(SkPath::kWinding_FillType);
5345 path.moveTo(3, 4);
5346 path.cubicTo(0, 6, 6, 1, 4, 2);
5347 path.close();
5352 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5356 SkPath path, pathB;
5357 path.setFillType(SkPath::kWinding_FillType);
5358 path.moveTo(1, 4);
5359 path.cubicTo(2, 6, 5, 0, 5, 3);
5360 path.close();
5365 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
5369 SkPath path, pathB;
5370 path.setFillType(SkPath::kWinding_FillType);
5371 path.moveTo(0,1);
5372 path.cubicTo(2,4, 2,0, 2,0);
5373 path.close();
5378 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5382 SkPath path, pathB;
5383 path.moveTo(1, 2);
5384 path.cubicTo(0, 3, -0.333333343f, 3.33333325f, 0.833333373f, 3.5f);
5385 path.close();
5389 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5393 SkPath path, pathB;
5394 path.setFillType(SkPath::kWinding_FillType);
5395 path.addCircle(0, 1, 5, SkPath::kCW_Direction);
5398 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5402 SkPath path;
5403 path.moveTo(815, 82);
5404 path.cubicTo(814.4794311523438f, 82.7868881225586f, 814.5330810546875f,
5406 path.cubicTo(814.5229492187500f, 82.6230010986328f, 814.3790283203125f,
5408 path.close();
5409 testPathOp(reporter, path, path, kUnion_SkPathOp, filename);
5413 SkPath path, pathB;
5414 path.moveTo(SkBits2Float(0xc0a00000), SkBits2Float(0x00000000)); // -5, 0
5415 path.lineTo(SkBits2Float(0x44866000), SkBits2Float(0x00000000)); // 1075, 0
5416 path.lineTo(SkBits2Float(0x44866000), SkBits2Float(0x43720000)); // 1075, 242
5417 path.lineTo(SkBits2Float(0xc0a00000), SkBits2Float(0x43720000)); // -5, 242
5418 path.lineTo(SkBits2Float(0xc0a00000), SkBits2Float(0x00000000)); // -5, 0
5419 path.close();
5426 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5430 SkPath path;
5431 path.setFillType(SkPath::kEvenOdd_FillType);
5432 path.moveTo(SkBits2Float(0x45b56000), SkBits2Float(0x45bca000)); // 5804, 6036
5433 path.lineTo(SkBits2Float(0x45b55f0a), SkBits2Float(0x45bc9fc0)); // 5803.88f, 6035.97f
5434 path.lineTo(SkBits2Float(0x45b55e15), SkBits2Float(0x45bc9f7b)); // 5803.76f, 6035.94f
5435 path.lineTo(SkBits2Float(0x45b55d1f), SkBits2Float(0x45bc9f32)); // 5803.64f, 6035.9f
5436 path.lineTo(SkBits2Float(0x45b55c29), SkBits2Float(0x45bc9ee3)); // 5803.52f, 6035.86f
5437 path.lineTo(SkBits2Float(0x45b55b34), SkBits2Float(0x45bc9e90)); // 5803.4f, 6035.82f
5438 path.lineTo(SkBits2Float(0x45b55a3f), SkBits2Float(0x45bc9e38)); // 5803.28f, 6035.78f
5439 path.lineTo(SkBits2Float(0x45b5594a), SkBits2Float(0x45bc9ddc)); // 5803.16f, 6035.73f
5440 path.lineTo(SkBits2Float(0x45b55856), SkBits2Float(0x45bc9d7a)); // 5803.04f, 6035.68f
5441 path.lineTo(SkBits2Float(0x45b55762), SkBits2Float(0x45bc9d14)); // 5802.92f, 6035.63f
5442 path.lineTo(SkBits2Float(0x45b5566f), SkBits2Float(0x45bc9caa)); // 5802.8f, 6035.58f
5443 path.lineTo(SkBits2Float(0x45b5557c), SkBits2Float(0x45bc9c3b)); // 5802.69f, 6035.53f
5444 path.lineTo(SkBits2Float(0x45b55489), SkBits2Float(0x45bc9bc7)); // 5802.57f, 6035.47f
5445 path.lineTo(SkBits2Float(0x45b55397), SkBits2Float(0x45bc9b4f)); // 5802.45f, 6035.41f
5446 path.lineTo(SkBits2Float(0x45b552a6), SkBits2Float(0x45bc9ad3)); // 5802.33f, 6035.35f
5447 path.lineTo(SkBits2Float(0x45b551b5), SkBits2Float(0x45bc9a52)); // 5802.21f, 6035.29f
5448 path.lineTo(SkBits2Float(0x45b550c5), SkBits2Float(0x45bc99cd)); // 5802.1f, 6035.23f
5449 path.lineTo(SkBits2Float(0x45b54fd6), SkBits2Float(0x45bc9943)); // 5801.98f, 6035.16f
5450 path.lineTo(SkBits2Float(0x45b54ee8), SkBits2Float(0x45bc98b6)); // 5801.86f, 6035.09f
5451 path.lineTo(SkBits2Float(0x45b54dfb), SkBits2Float(0x45bc9824)); // 5801.75f, 6035.02f
5452 path.lineTo(SkBits2Float(0x45b54d0e), SkBits2Float(0x45bc978d)); // 5801.63f, 6034.94f
5453 path.lineTo(SkBits2Float(0x45b54c23), SkBits2Float(0x45bc96f3)); // 5801.52f, 6034.87f
5454 path.lineTo(SkBits2Float(0x45b54b39), SkBits2Float(0x45bc9654)); // 5801.4f, 6034.79f
5455 path.lineTo(SkBits2Float(0x45b54a4f), SkBits2Float(0x45bc95b2)); // 5801.29f, 6034.71f
5456 path.lineTo(SkBits2Float(0x45b54967), SkBits2Float(0x45bc950b)); // 5801.18f, 6034.63f
5457 path.lineTo(SkBits2Float(0x45b54880), SkBits2Float(0x45bc9460)); // 5801.06f, 6034.55f
5458 path.lineTo(SkBits2Float(0x45b5479a), SkBits2Float(0x45bc93b1)); // 5800.95f, 6034.46f
5459 path.lineTo(SkBits2Float(0x45b546b6), SkBits2Float(0x45bc92fe)); // 5800.84f, 6034.37f
5460 path.lineTo(SkBits2Float(0x45b545d3), SkBits2Float(0x45bc9248)); // 5800.73f, 6034.29f
5461 path.lineTo(SkBits2Float(0x45b544f1), SkBits2Float(0x45bc918d)); // 5800.62f, 6034.19f
5462 path.lineTo(SkBits2Float(0x45b54410), SkBits2Float(0x45bc90cf)); // 5800.51f, 6034.1f
5463 path.lineTo(SkBits2Float(0x45b54331), SkBits2Float(0x45bc900d)); // 5800.4f, 6034.01f
5464 path.lineTo(SkBits2Float(0x45b54254), SkBits2Float(0x45bc8f47)); // 5800.29f, 6033.91f
5465 path.lineTo(SkBits2Float(0x45b54178), SkBits2Float(0x45bc8e7d)); // 5800.18f, 6033.81f
5466 path.lineTo(SkBits2Float(0x45b5409e), SkBits2Float(0x45bc8db0)); // 5800.08f, 6033.71f
5467 path.lineTo(SkBits2Float(0x45b53fc6), SkBits2Float(0x45bc8cde)); // 5799.97f, 6033.61f
5468 path.lineTo(SkBits2Float(0x45b53eef), SkBits2Float(0x45bc8c0a)); // 5799.87f, 6033.5f
5469 path.lineTo(SkBits2Float(0x45b53e1a), SkBits2Float(0x45bc8b31)); // 5799.76f, 6033.4f
5470 path.lineTo(SkBits2Float(0x45b53d47), SkBits2Float(0x45bc8a56)); // 5799.66f, 6033.29f
5471 path.lineTo(SkBits2Float(0x45b53c75), SkBits2Float(0x45bc8976)); // 5799.56f, 6033.18f
5472 path.lineTo(SkBits2Float(0x45b53ba6), SkBits2Float(0x45bc8893)); // 5799.46f, 6033.07f
5473 path.lineTo(SkBits2Float(0x45b53ad8), SkBits2Float(0x45bc87ad)); // 5799.36f, 6032.96f
5474 path.lineTo(SkBits2Float(0x45b53a0d), SkBits2Float(0x45bc86c4)); // 5799.26f, 6032.85f
5475 path.lineTo(SkBits2Float(0x45b53944), SkBits2Float(0x45bc85d6)); // 5799.16f, 6032.73f
5476 path.lineTo(SkBits2Float(0x45b5387c), SkBits2Float(0x45bc84e6)); // 5799.06f, 6032.61f
5477 path.lineTo(SkBits2Float(0x45b537b7), SkBits2Float(0x45bc83f2)); // 5798.96f, 6032.49f
5478 path.lineTo(SkBits2Float(0x45b536f4), SkBits2Float(0x45bc82fc)); // 5798.87f, 6032.37f
5479 path.lineTo(SkBits2Float(0x45b53634), SkBits2Float(0x45bc8201)); // 5798.78f, 6032.25f
5480 path.lineTo(SkBits2Float(0x45b53575), SkBits2Float(0x45bc8104)); // 5798.68f, 6032.13f
5481 path.lineTo(SkBits2Float(0x45b534ba), SkBits2Float(0x45bc8004)); // 5798.59f, 6032
5482 path.lineTo(SkBits2Float(0x45b53400), SkBits2Float(0x45bc7f00)); // 5798.5f, 6031.88f
5483 path.lineTo(SkBits2Float(0x45b53349), SkBits2Float(0x45bc7df9)); // 5798.41f, 6031.75f
5484 path.lineTo(SkBits2Float(0x45b53294), SkBits2Float(0x45bc7cf0)); // 5798.32f, 6031.62f
5485 path.lineTo(SkBits2Float(0x45b531e2), SkBits2Float(0x45bc7be3)); // 5798.24f, 6031.49f
5486 path.lineTo(SkBits2Float(0x45b53133), SkBits2Float(0x45bc7ad3)); // 5798.15f, 6031.35f
5487 path.lineTo(SkBits2Float(0x45b53086), SkBits2Float(0x45bc79c1)); // 5798.07f, 6031.22f
5488 path.lineTo(SkBits2Float(0x45b52fdc), SkBits2Float(0x45bc78ab)); // 5797.98f, 6031.08f
5489 path.lineTo(SkBits2Float(0x45b52f35), SkBits2Float(0x45bc7793)); // 5797.9f, 6030.95f
5490 path.lineTo(SkBits2Float(0x45b52e90), SkBits2Float(0x45bc7678)); // 5797.82f, 6030.81f
5491 path.lineTo(SkBits2Float(0x45b52def), SkBits2Float(0x45bc755a)); // 5797.74f, 6030.67f
5492 path.lineTo(SkBits2Float(0x45b52d50), SkBits2Float(0x45bc7439)); // 5797.66f, 6030.53f
5493 path.lineTo(SkBits2Float(0x45b52cb4), SkBits2Float(0x45bc7316)); // 5797.59f, 6030.39f
5494 path.lineTo(SkBits2Float(0x45b52c1b), SkBits2Float(0x45bc71f0)); // 5797.51f, 6030.24f
5495 path.lineTo(SkBits2Float(0x45b52b86), SkBits2Float(0x45bc70c7)); // 5797.44f, 6030.1f
5496 path.lineTo(SkBits2Float(0x45b52af3), SkBits2Float(0x45bc6f9c)); // 5797.37f, 6029.95f
5497 path.lineTo(SkBits2Float(0x45b52a63), SkBits2Float(0x45bc6e6e)); // 5797.3f, 6029.8f
5498 path.lineTo(SkBits2Float(0x45b529d7), SkBits2Float(0x45bc6d3e)); // 5797.23f, 6029.66f
5499 path.lineTo(SkBits2Float(0x45b5294e), SkBits2Float(0x45bc6c0b)); // 5797.16f, 6029.51f
5500 path.lineTo(SkBits2Float(0x45b528c8), SkBits2Float(0x45bc6ad6)); // 5797.1f, 6029.35f
5501 path.lineTo(SkBits2Float(0x45b52846), SkBits2Float(0x45bc699e)); // 5797.03f, 6029.2f
5502 path.lineTo(SkBits2Float(0x45b527c7), SkBits2Float(0x45bc6864)); // 5796.97f, 6029.05f
5503 path.lineTo(SkBits2Float(0x45b5274b), SkBits2Float(0x45bc6728)); // 5796.91f, 6028.89f
5504 path.lineTo(SkBits2Float(0x45b526d3), SkBits2Float(0x45bc65e9)); // 5796.85f, 6028.74f
5505 path.lineTo(SkBits2Float(0x45b5265e), SkBits2Float(0x45bc64a8)); // 5796.8f, 6028.58f
5506 path.lineTo(SkBits2Float(0x45b52600), SkBits2Float(0x45bc639b)); // 5796.75f, 6028.45f
5507 path.lineTo(SkBits2Float(0x45b52600), SkBits2Float(0x45bab032)); // 5796.75f, 5974.02f
5508 path.lineTo(SkBits2Float(0x45b52611), SkBits2Float(0x45baaffd)); // 5796.76f, 5974
5509 path.lineTo(SkBits2Float(0x45b52687), SkBits2Float(0x45baae9d)); // 5796.82f, 5973.83f
5510 path.lineTo(SkBits2Float(0x45b52700), SkBits2Float(0x45baad40)); // 5796.88f, 5973.66f
5511 path.lineTo(SkBits2Float(0x45b5277d), SkBits2Float(0x45baabe7)); // 5796.94f, 5973.49f
5512 path.lineTo(SkBits2Float(0x45b527fe), SkBits2Float(0x45baaa91)); // 5797, 5973.32f
5513 path.lineTo(SkBits2Float(0x45b52883), SkBits2Float(0x45baa93f)); // 5797.06f, 5973.16f
5514 path.lineTo(SkBits2Float(0x45b5290b), SkBits2Float(0x45baa7f1)); // 5797.13f, 5972.99f
5515 path.lineTo(SkBits2Float(0x45b52998), SkBits2Float(0x45baa6a6)); // 5797.2f, 5972.83f
5516 path.lineTo(SkBits2Float(0x45b52a28), SkBits2Float(0x45baa55f)); // 5797.27f, 5972.67f
5517 path.lineTo(SkBits2Float(0x45b52abb), SkBits2Float(0x45baa41c)); // 5797.34f, 5972.51f
5518 path.lineTo(SkBits2Float(0x45b52b52), SkBits2Float(0x45baa2dc)); // 5797.42f, 5972.36f
5519 path.lineTo(SkBits2Float(0x45b52bed), SkBits2Float(0x45baa1a0)); // 5797.49f, 5972.2f
5520 path.lineTo(SkBits2Float(0x45b52c8c), SkBits2Float(0x45baa068)); // 5797.57f, 5972.05f
5521 path.lineTo(SkBits2Float(0x45b52d2e), SkBits2Float(0x45ba9f34)); // 5797.65f, 5971.9f
5522 path.lineTo(SkBits2Float(0x45b52dd3), SkBits2Float(0x45ba9e04)); // 5797.73f, 5971.75f
5523 path.lineTo(SkBits2Float(0x45b52e7c), SkBits2Float(0x45ba9cd8)); // 5797.81f, 5971.61f
5524 path
5525 path.lineTo(SkBits2Float(0x45b52fd8), SkBits2Float(0x45ba9a8b)); // 5797.98f, 5971.32f
5526 path.lineTo(SkBits2Float(0x45b5308b), SkBits2Float(0x45ba996b)); // 5798.07f, 5971.18f
5527 path.lineTo(SkBits2Float(0x45b53141), SkBits2Float(0x45ba984f)); // 5798.16f, 5971.04f
5528 path.lineTo(SkBits2Float(0x45b531fa), SkBits2Float(0x45ba9736)); // 5798.25f, 5970.9f
5529 path.lineTo(SkBits2Float(0x45b532b7), SkBits2Float(0x45ba9623)); // 5798.34f, 5970.77f
5530 path.lineTo(SkBits2Float(0x45b53377), SkBits2Float(0x45ba9513)); // 5798.43f, 5970.63f
5531 path.lineTo(SkBits2Float(0x45b5343a), SkBits2Float(0x45ba9407)); // 5798.53f, 5970.5f
5532 path.lineTo(SkBits2Float(0x45b53500), SkBits2Float(0x45ba9300)); // 5798.63f, 5970.38f
5533 path.lineTo(SkBits2Float(0x45b535c9), SkBits2Float(0x45ba91fd)); // 5798.72f, 5970.25f
5534 path.lineTo(SkBits2Float(0x45b53695), SkBits2Float(0x45ba90fe)); // 5798.82f, 5970.12f
5535 path.lineTo(SkBits2Float(0x45b53765), SkBits2Float(0x45ba9004)); // 5798.92f, 5970
5536 path.lineTo(SkBits2Float(0x45b53837), SkBits2Float(0x45ba8f0e)); // 5799.03f, 5969.88f
5537 path.lineTo(SkBits2Float(0x45b5390c), SkBits2Float(0x45ba8e1d)); // 5799.13f, 5969.76f
5538 path.lineTo(SkBits2Float(0x45b539e4), SkBits2Float(0x45ba8d30)); // 5799.24f, 5969.65f
5539 path.lineTo(SkBits2Float(0x45b53abf), SkBits2Float(0x45ba8c48)); // 5799.34f, 5969.54f
5540 path.lineTo(SkBits2Float(0x45b53b9d), SkBits2Float(0x45ba8b64)); // 5799.45f, 5969.42f
5541 path.lineTo(SkBits2Float(0x45b53c7d), SkBits2Float(0x45ba8a85)); // 5799.56f, 5969.31f
5542 path.lineTo(SkBits2Float(0x45b53d60), SkBits2Float(0x45ba89aa)); // 5799.67f, 5969.21f
5543 path.lineTo(SkBits2Float(0x45b53e46), SkBits2Float(0x45ba88d4)); // 5799.78f, 5969.1f
5544 path.lineTo(SkBits2Float(0x45b53f2f), SkBits2Float(0x45ba8803)); // 5799.9f, 5969
5545 path.lineTo(SkBits2Float(0x45b5401a), SkBits2Float(0x45ba8736)); // 5800.01f, 5968.9f
5546 path.lineTo(SkBits2Float(0x45b54108), SkBits2Float(0x45ba866f)); // 5800.13f, 5968.8f
5547 path.lineTo(SkBits2Float(0x45b541f8), SkBits2Float(0x45ba85ac)); // 5800.25f, 5968.71f
5548 path.lineTo(SkBits2Float(0x45b542eb), SkBits2Float(0x45ba84ee)); // 5800.36f, 5968.62f
5549 path.lineTo(SkBits2Float(0x45b543e0), SkBits2Float(0x45ba8435)); // 5800.48f, 5968.53f
5550 path.lineTo(SkBits2Float(0x45b544d8), SkBits2Float(0x45ba8380)); // 5800.61f, 5968.44f
5551 path.lineTo(SkBits2Float(0x45b545d2), SkBits2Float(0x45ba82d1)); // 5800.73f, 5968.35f
5552 path.lineTo(SkBits2Float(0x45b546cf), SkBits2Float(0x45ba8227)); // 5800.85f, 5968.27f
5553 path.lineTo(SkBits2Float(0x45b547ce), SkBits2Float(0x45ba8182)); // 5800.98f, 5968.19f
5554 path.lineTo(SkBits2Float(0x45b548cf), SkBits2Float(0x45ba80e2)); // 5801.1f, 5968.11f
5555 path.lineTo(SkBits2Float(0x45b549d2), SkBits2Float(0x45ba8047)); // 5801.23f, 5968.03f
5556 path.lineTo(SkBits2Float(0x45b54ad8), SkBits2Float(0x45ba7fb1)); // 5801.36f, 5967.96f
5557 path.lineTo(SkBits2Float(0x45b54be0), SkBits2Float(0x45ba7f20)); // 5801.48f, 5967.89f
5558 path.lineTo(SkBits2Float(0x45b54cea), SkBits2Float(0x45ba7e95)); // 5801.61f, 5967.82f
5559 path.lineTo(SkBits2Float(0x45b54df6), SkBits2Float(0x45ba7e0e)); // 5801.75f, 5967.76f
5560 path.lineTo(SkBits2Float(0x45b54f04), SkBits2Float(0x45ba7d8d)); // 5801.88f, 5967.69f
5561 path.lineTo(SkBits2Float(0x45b55015), SkBits2Float(0x45ba7d12)); // 5802.01f, 5967.63f
5562 path.lineTo(SkBits2Float(0x45b55127), SkBits2Float(0x45ba7c9c)); // 5802.14f, 5967.58f
5563 path.lineTo(SkBits2Float(0x45b551b5), SkBits2Float(0x45ba7c62)); // 5802.21f, 5967.55f
5564 path.lineTo(SkBits2Float(0x45c7b29a), SkBits2Float(0x45ba7c62)); // 6390.33f, 5967.55f
5565 path.lineTo(SkBits2Float(0x45c7b2f2), SkBits2Float(0x45ba7c8b)); // 6390.37f, 5967.57f
5566 path.lineTo(SkBits2Float(0x45c7b3dd), SkBits2Float(0x45ba7cff)); // 6390.48f, 5967.62f
5567 path.lineTo(SkBits2Float(0x45c7b4c7), SkBits2Float(0x45ba7d78)); // 6390.6f, 5967.68f
5568 path.lineTo(SkBits2Float(0x45c7b5b1), SkBits2Float(0x45ba7df5)); // 6390.71f, 5967.74f
5569 path.lineTo(SkBits2Float(0x45c7b699), SkBits2Float(0x45ba7e78)); // 6390.82f, 5967.81f
5570 path.lineTo(SkBits2Float(0x45c7b780), SkBits2Float(0x45ba7f00)); // 6390.94f, 5967.88f
5571 path.lineTo(SkBits2Float(0x45c7b866), SkBits2Float(0x45ba7f8d)); // 6391.05f, 5967.94f
5572 path.lineTo(SkBits2Float(0x45c7b94a), SkBits2Float(0x45ba801e)); // 6391.16f, 5968.01f
5573 path.lineTo(SkBits2Float(0x45c7ba2d), SkBits2Float(0x45ba80b5)); // 6391.27f, 5968.09f
5574 path.lineTo(SkBits2Float(0x45c7bb0f), SkBits2Float(0x45ba8150)); // 6391.38f, 5968.16f
5575 path.lineTo(SkBits2Float(0x45c7bbf0), SkBits2Float(0x45ba81f0)); // 6391.49f, 5968.24f
5576 path.lineTo(SkBits2Float(0x45c7bccf), SkBits2Float(0x45ba8294)); // 6391.6f, 5968.32f
5577 path.lineTo(SkBits2Float(0x45c7bdac), SkBits2Float(0x45ba833d)); // 6391.71f, 5968.4f
5578 path.lineTo(SkBits2Float(0x45c7be88), SkBits2Float(0x45ba83eb)); // 6391.82f, 5968.49f
5579 path.lineTo(SkBits2Float(0x45c7bf62), SkBits2Float(0x45ba849d)); // 6391.92f, 5968.58f
5580 path.lineTo(SkBits2Float(0x45c7c03a), SkBits2Float(0x45ba8554)); // 6392.03f, 5968.67f
5581 path.lineTo(SkBits2Float(0x45c7c111), SkBits2Float(0x45ba860f)); // 6392.13f, 5968.76f
5582 path.lineTo(SkBits2Float(0x45c7c1e6), SkBits2Float(0x45ba86cf)); // 6392.24f, 5968.85f
5583 path.lineTo(SkBits2Float(0x45c7c2b9), SkBits2Float(0x45ba8792)); // 6392.34f, 5968.95f
5584 path.lineTo(SkBits2Float(0x45c7c38b), SkBits2Float(0x45ba885b)); // 6392.44f, 5969.04f
5585 path.lineTo(SkBits2Float(0x45c7c45a), SkBits2Float(0x45ba8927)); // 6392.54f, 5969.14f
5586 path.lineTo(SkBits2Float(0x45c7c528), SkBits2Float(0x45ba89f7)); // 6392.64f, 5969.25f
5587 path.lineTo(SkBits2Float(0x45c7c5f3), SkBits2Float(0x45ba8acc)); // 6392.74f, 5969.35f
5588 path.lineTo(SkBits2Float(0x45c7c6bc), SkBits2Float(0x45ba8ba5)); // 6392.84f, 5969.46f
5589 path.lineTo(SkBits2Float(0x45c7c784), SkBits2Float(0x45ba8c82)); // 6392.94f, 5969.56f
5590 path.lineTo(SkBits2Float(0x45c7c849), SkBits2Float(0x45ba8d62)); // 6393.04f, 5969.67f
5591 path.lineTo(SkBits2Float(0x45c7c90c), SkBits2Float(0x45ba8e47)); // 6393.13f, 5969.78f
5592 path.lineTo(SkBits2Float(0x45c7c9cc), SkBits2Float(0x45ba8f30)); // 6393.22f, 5969.9f
5593 path.lineTo(SkBits2Float(0x45c7ca8b), SkBits2Float(0x45ba901c)); // 6393.32f, 5970.01f
5594 path.lineTo(SkBits2Float(0x45c7cb46), SkBits2Float(0x45ba910c)); // 6393.41f, 5970.13f
5595 path.lineTo(SkBits2Float(0x45c7cc00), SkBits2Float(0x45ba9200)); // 6393.5f, 5970.25f
5596 path.lineTo(SkBits2Float(0x45c7ccb7), SkBits2Float(0x45ba92f8)); // 6393.59f, 5970.37f
5597 path.lineTo(SkBits2Float(0x45c7cd6c), SkBits2Float(0x45ba93f3)); // 6393.68f, 5970.49f
5598 path.lineTo(SkBits2Float(0x45c7ce1e), SkBits2Float(0x45ba94f2)); // 6393.76f, 5970.62f
5599 path.lineTo(SkBits2Float(0x45c7cecd), SkBits2Float(0x45ba95f4)); // 6393.85f, 5970.74f
5600 path.lineTo(SkBits2Float(0x45c7cf7a), SkBits2Float(0x45ba96fa)); // 6393.93f, 5970.87f
5601 path.lineTo(SkBits2Float(0x45c7d024), SkBits2Float(0x45ba9803)); // 6394.02f, 5971
5602 path.lineTo(SkBits2Float(0x45c7d0cb), SkBits2Float(0x45ba9910)); // 6394.1f, 5971.13f
5603 path.lineTo(SkBits2Float(0x45c7d170), SkBits2Float(0x45ba9a20)); // 6394.18f, 5971.27f
5604 path.lineTo(SkBits2Float(0x45c7d211), SkBits2Float(0x45ba9b33)); // 6394.26f, 5971.4f
5605 path.lineTo(SkBits2Float(0x45c7d2b0), SkBits2Float(0x45ba9c4a)); // 6394.34f, 5971.54f
5606 path.lineTo(SkBits2Float(0x45c7d34c), SkBits2Float(0x45ba9d63)); // 6394.41f, 5971.67f
5607 path.lineTo(SkBits2Float(0x45c7d3e5), SkBits2Float(0x45ba9e80)); // 6394.49f, 5971.81f
5608 path.lineTo(SkBits2Float(0x45c7d47a), SkBits2Float(0x45ba9fa0)); // 6394.56f, 5971.95f
5609 path.lineTo(SkBits2Float(0x45c7d50d), SkBits2Float(0x45baa0c3)); // 6394.63f, 5972.1f
5610 path.lineTo(SkBits2Float(0x45c7d59d), SkBits2Float(0x45baa1e9)); // 6394.7f, 5972.24f
5611 path.lineTo(SkBits2Float(0x45c7d629), SkBits2Float(0x45baa312)); // 6394.77f, 5972.38f
5612 path.lineTo(SkBits2Float(0x45c7d6b2), SkBits2Float(0x45baa43e)); // 6394.84f, 5972.53f
5613 path.lineTo(SkBits2Float(0x45c7d738), SkBits2Float(0x45baa56d)); // 6394.9f, 5972.68f
5614 path.lineTo(SkBits2Float(0x45c7d7ba), SkBits2Float(0x45baa69f)); // 6394.97f, 5972.83f
5615 path.lineTo(SkBits2Float(0x45c7d839), SkBits2Float(0x45baa7d3)); // 6395.03f, 5972.98f
5616 path.lineTo(SkBits2Float(0x45c7d8b5), SkBits2Float(0x45baa90a)); // 6395.09f, 5973.13f
5617 path.lineTo(SkBits2Float(0x45c7d92d), SkBits2Float(0x45baaa44)); // 6395.15f, 5973.28f
5618 path.lineTo(SkBits2Float(0x45c7d9a2), SkBits2Float(0x45baab80)); // 6395.2f, 5973.44f
5619 path.lineTo(SkBits2Float(0x45c7da13), SkBits2Float(0x45baacbf)); // 6395.26f, 5973.59f
5620 path.lineTo(SkBits2Float(0x45c7da80), SkBits2Float(0x45baae00)); // 6395.31f, 5973.75f
5621 path.lineTo(SkBits2Float(0x45c7daea), SkBits2Float(0x45baaf44)); // 6395.36f, 5973.91f
5622 path.lineTo(SkBits2Float(0x45c7db50), SkBits2Float(0x45bab08a)); // 6395.41f, 5974.07f
5623 path.lineTo(SkBits2Float(0x45c7dbb2), SkBits2Float(0x45bab1d3)); // 6395.46f, 5974.23f
5624 path.lineTo(SkBits2Float(0x45c7dc10), SkBits2Float(0x45bab31d)); // 6395.51f, 5974.39f
5625 path.lineTo(SkBits2Float(0x45c7dc6a), SkBits2Float(0x45bab46a)); // 6395.55f, 5974.55f
5626 path.lineTo(SkBits2Float(0x45c7dc6b), SkBits2Float(0x45bc5fbe)); // 6395.55f, 6027.97f
5627 path.lineTo(SkBits2Float(0x45c7dc10), SkBits2Float(0x45bc60e7)); // 6395.51f, 6028.11f
5628 path.lineTo(SkBits2Float(0x45c7dbb2), SkBits2Float(0x45bc620f)); // 6395.46f, 6028.26f
5629 path.lineTo(SkBits2Float(0x45c7db50), SkBits2Float(0x45bc6336)); // 6395.41f, 6028.4f
5630 path.lineTo(SkBits2Float(0x45c7daea), SkBits2Float(0x45bc645c)); // 6395.36f, 6028.54f
5631 path.lineTo(SkBits2Float(0x45c7da80), SkBits2Float(0x45bc6580)); // 6395.31f, 6028.69f
5632 path.lineTo(SkBits2Float(0x45c7da13), SkBits2Float(0x45bc66a3)); // 6395.26f, 6028.83f
5633 path.lineTo(SkBits2Float(0x45c7d9a2), SkBits2Float(0x45bc67c5)); // 6395.2f, 6028.97f
5634 path.lineTo(SkBits2Float(0x45c7d92d), SkBits2Float(0x45bc68e6)); // 6395.15f, 6029.11f
5635 path.lineTo(SkBits2Float(0x45c7d8b5), SkBits2Float(0x45bc6a05)); // 6395.09f, 6029.25f
5636 path.lineTo(SkBits2Float(0x45c7d839), SkBits2Float(0x45bc6b23)); // 6395.03f, 6029.39f
5637 path.lineTo(SkBits2Float(0x45c7d7ba), SkBits2Float(0x45bc6c3f)); // 6394.97f, 6029.53f
5638 path.lineTo(SkBits2Float(0x45c7d738), SkBits2Float(0x45bc6d5a)); // 6394.9f, 6029.67f
5639 path.lineTo(SkBits2Float(0x45c7d6b2), SkBits2Float(0x45bc6e73)); // 6394.84f, 6029.81f
5640 path.lineTo(SkBits2Float(0x45c7d629), SkBits2Float(0x45bc6f8b)); // 6394.77f, 6029.94f
5641 path.lineTo(SkBits2Float(0x45c7d59d), SkBits2Float(0x45bc70a1)); // 6394.7f, 6030.08f
5642 path.lineTo(SkBits2Float(0x45c7d50d), SkBits2Float(0x45bc71b5)); // 6394.63f, 6030.21f
5643 path.lineTo(SkBits2Float(0x45c7d47a), SkBits2Float(0x45bc72c7)); // 6394.56f, 6030.35f
5644 path.lineTo(SkBits2Float(0x45c7d3e5), SkBits2Float(0x45bc73d8)); // 6394.49f, 6030.48f
5645 path.lineTo(SkBits2Float(0x45c7d34c), SkBits2Float(0x45bc74e7)); // 6394.41f, 6030.61f
5646 path.lineTo(SkBits2Float(0x45c7d2b0), SkBits2Float(0x45bc75f4)); // 6394.34f, 6030.74f
5647 path.lineTo(SkBits2Float(0x45c7d211), SkBits2Float(0x45bc76ff)); // 6394.26f, 6030.87f
5648 path.lineTo(SkBits2Float(0x45c7d170), SkBits2Float(0x45bc7807)); // 6394.18f, 6031
5649 path.lineTo(SkBits2Float(0x45c7d0cb), SkBits2Float(0x45bc790e)); // 6394.1f, 6031.13f
5650 path.lineTo(SkBits2Float(0x45c7d024), SkBits2Float(0x45bc7a13)); // 6394.02f, 6031.26f
5651 path.lineTo(SkBits2Float(0x45c7cf7a), SkBits2Float(0x45bc7b16)); // 6393.93f, 6031.39f
5652 path.lineTo(SkBits2Float(0x45c7cecd), SkBits2Float(0x45bc7c16)); // 6393.85f, 6031.51f
5653 path.lineTo(SkBits2Float(0x45c7ce1e), SkBits2Float(0x45bc7d14)); // 6393.76f, 6031.63f
5654 path.lineTo(SkBits2Float(0x45c7cd6c), SkBits2Float(0x45bc7e10)); // 6393.68f, 6031.76f
5655 path.lineTo(SkBits2Float(0x45c7ccb7), SkBits2Float(0x45bc7f09)); // 6393.59f, 6031.88f
5656 path.lineTo(SkBits2Float(0x45c7cc00), SkBits2Float(0x45bc8000)); // 6393.5f, 6032
5657 path.lineTo(SkBits2Float(0x45c7cb46), SkBits2Float(0x45bc80f5)); // 6393.41f, 6032.12f
5658 path.lineTo(SkBits2Float(0x45c7ca8b), SkBits2Float(0x45bc81e7)); // 6393.32f, 6032.24f
5659 path.lineTo(SkBits2Float(0x45c7c9cc), SkBits2Float(0x45bc82d6)); // 6393.22f, 6032.35f
5660 path.lineTo(SkBits2Float(0x45c7c90c), SkBits2Float(0x45bc83c3)); // 6393.13f, 6032.47f
5661 path.lineTo(SkBits2Float(0x45c7c849), SkBits2Float(0x45bc84ad)); // 6393.04f, 6032.58f
5662 path.lineTo(SkBits2Float(0x45c7c784), SkBits2Float(0x45bc8595)); // 6392.94f, 6032.7f
5663 path.lineTo(SkBits2Float(0x45c7c6bc), SkBits2Float(0x45bc8679)); // 6392.84f, 6032.81f
5664 path.lineTo(SkBits2Float(0x45c7c5f3), SkBits2Float(0x45bc875b)); // 6392.74f, 6032.92f
5665 path.lineTo(SkBits2Float(0x45c7c528), SkBits2Float(0x45bc883a)); // 6392.64f, 6033.03f
5666 path.lineTo(SkBits2Float(0x45c7c45a), SkBits2Float(0x45bc8917)); // 6392.54f, 6033.14f
5667 path.lineTo(SkBits2Float(0x45c7c38b), SkBits2Float(0x45bc89f0)); // 6392.44f, 6033.24f
5668 path.lineTo(SkBits2Float(0x45c7c2b9), SkBits2Float(0x45bc8ac6)); // 6392.34f, 6033.35f
5669 path.lineTo(SkBits2Float(0x45c7c1e6), SkBits2Float(0x45bc8b99)); // 6392.24f, 6033.45f
5670 path.lineTo(SkBits2Float(0x45c7c111), SkBits2Float(0x45bc8c69)); // 6392.13f, 6033.55f
5671 path.lineTo(SkBits2Float(0x45c7c03a), SkBits2Float(0x45bc8d36)); // 6392.03f, 6033.65f
5672 path.lineTo(SkBits2Float(0x45c7bf62), SkBits2Float(0x45bc8e00)); // 6391.92f, 6033.75f
5673 path.lineTo(SkBits2Float(0x45c7be88), SkBits2Float(0x45bc8ec7)); // 6391.82f, 6033.85f
5674 path.lineTo(SkBits2Float(0x45c7bdac), SkBits2Float(0x45bc8f8a)); // 6391.71f, 6033.94f
5675 path.lineTo(SkBits2Float(0x45c7bccf), SkBits2Float(0x45bc904a)); // 6391.6f, 6034.04f
5676 path.lineTo(SkBits2Float(0x45c7bbf0), SkBits2Float(0x45bc9106)); // 6391.49f, 6034.13f
5677 path.lineTo(SkBits2Float(0x45c7bb0f), SkBits2Float(0x45bc91bf)); // 6391.38f, 6034.22f
5678 path.lineTo(SkBits2Float(0x45c7ba2d), SkBits2Float(0x45bc9275)); // 6391.27f, 6034.31f
5679 path.lineTo(SkBits2Float(0x45c7b94a), SkBits2Float(0x45bc9327)); // 6391.16f, 6034.39f
5680 path.lineTo(SkBits2Float(0x45c7b866), SkBits2Float(0x45bc93d5)); // 6391.05f, 6034.48f
5681 path.lineTo(SkBits2Float(0x45c7b780), SkBits2Float(0x45bc9480)); // 6390.94f, 6034.56f
5682 path.lineTo(SkBits2Float(0x45c7b699), SkBits2Float(0x45bc9527)); // 6390.82f, 6034.64f
5683 path.lineTo(SkBits2Float(0x45c7b5b1), SkBits2Float(0x45bc95ca)); // 6390.71f, 6034.72f
5684 path.lineTo(SkBits2Float(0x45c7b4c8), SkBits2Float(0x45bc966a)); // 6390.6f, 6034.8f
5685 path.lineTo(SkBits2Float(0x45c7b3dd), SkBits2Float(0x45bc9706)); // 6390.48f, 6034.88f
5686 path.lineTo(SkBits2Float(0x45c7b2f2), SkBits2Float(0x45bc979e)); // 6390.37f, 6034.95f
5687 path.lineTo(SkBits2Float(0x45c7b205), SkBits2Float(0x45bc9832)); // 6390.25f, 6035.02f
5688 path.lineTo(SkBits2Float(0x45c7b118), SkBits2Float(0x45bc98c2)); // 6390.14f, 6035.09f
5689 path.lineTo(SkBits2Float(0x45c7b02a), SkBits2Float(0x45bc994e)); // 6390.02f, 6035.16f
5690 path.lineTo(SkBits2Float(0x45c7af3b), SkBits2Float(0x45bc99d5)); // 6389.9f, 6035.23f
5691 path.lineTo(SkBits2Float(0x45c7ae4b), SkBits2Float(0x45bc9a59)); // 6389.79f, 6035.29f
5692 path.lineTo(SkBits2Float(0x45c7ad5a), SkBits2Float(0x45bc9ad9)); // 6389.67f, 6035.36f
5693 path.lineTo(SkBits2Float(0x45c7ac69), SkBits2Float(0x45bc9b54)); // 6389.55f, 6035.42f
5694 path.lineTo(SkBits2Float(0x45c7ab77), SkBits2Float(0x45bc9bcb)); // 6389.43f, 6035.47f
5695 path.lineTo(SkBits2Float(0x45c7aa84), SkBits2Float(0x45bc9c3e)); // 6389.31f, 6035.53f
5696 path.lineTo(SkBits2Float(0x45c7a991), SkBits2Float(0x45bc9cac)); // 6389.2f, 6035.58f
5697 path.lineTo(SkBits2Float(0x45c7a89e), SkBits2Float(0x45bc9d16)); // 6389.08f, 6035.64f
5698 path.lineTo(SkBits2Float(0x45c7a7aa), SkBits2Float(0x45bc9d7b)); // 6388.96f, 6035.69f
5699 path.lineTo(SkBits2Float(0x45c7a6b6), SkBits2Float(0x45bc9ddc)); // 6388.84f, 6035.73f
5700 path.lineTo(SkBits2Float(0x45c7a5c1), SkBits2Float(0x45bc9e39)); // 6388.72f, 6035.78f
5701 path.lineTo(SkBits2Float(0x45c7a4cc), SkBits2Float(0x45bc9e90)); // 6388.6f, 6035.82f
5702 path.lineTo(SkBits2Float(0x45c7a3d7), SkBits2Float(0x45bc9ee3)); // 6388.48f, 6035.86f
5703 path.lineTo(SkBits2Float(0x45c7a2e1), SkBits2Float(0x45bc9f32)); // 6388.36f, 6035.9f
5704 path.lineTo(SkBits2Float(0x45c7a1eb), SkBits2Float(0x45bc9f7b)); // 6388.24f, 6035.94f
5705 path.lineTo(SkBits2Float(0x45c7a0f6), SkBits2Float(0x45bc9fc0)); // 6388.12f, 6035.97f
5706 path.lineTo(SkBits2Float(0x45c7a000), SkBits2Float(0x45bca000)); // 6388, 6036
5707 path.lineTo(SkBits2Float(0x45b56000), SkBits2Float(0x45bca000)); // 5804, 6036
5708 path.close();
5720 testPathOp(reporter, path, path2, kIntersect_SkPathOp, filename);
6233 SkPath path;
6234 path.addRect(0,0, 300,170141183460469231731687303715884105728.f);
6237 testPathOpFuzz(reporter, path, pathB, kUnion_SkPathOp, filename);
6284 SkPath path;
6285 path.setFillType((SkPath::FillType) 0);
6286 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
6287 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
6288 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333));
6289 path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc));
6290 path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff));
6291 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
6292 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
6293 path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000));
6294 path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000));
6295 path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000));
6296 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
6297 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
6298 path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000));
6299 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
6300 path.close();
6302 SkPath path1(path);
6303 path.reset();
6304 path.setFillType((SkPath::FillType) 0);
6305 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
6306 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
6307 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a));
6308 path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a));
6309 path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd));
6310 path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000));
6311 path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a));
6312 path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333));
6313 path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000));
6314 path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000));
6315 path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a));
6316 path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334));
6317 path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd));
6318 path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd));
6319 path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd));
6320 path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334));
6321 path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000));
6322 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
6323 path.close();
6325 SkPath path2(path);
6330 SkPath path;
6331 path.setFillType((SkPath::FillType) 0);
6332 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
6333 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
6334 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333));
6335 path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc));
6336 path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff));
6337 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
6338 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
6339 path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000));
6340 path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000));
6341 path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000));
6342 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
6343 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
6344 path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000));
6345 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
6346 path.close();
6348 SkPath path1(path);
6349 path.reset();
6350 path.setFillType((SkPath::FillType) 0);
6351 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
6352 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
6353 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a));
6354 path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a));
6355 path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd));
6356 path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000));
6357 path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a));
6358 path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333));
6359 path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000));
6360 path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000));
6361 path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a));
6362 path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334));
6363 path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd));
6364 path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd));
6365 path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd));
6366 path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334));
6367 path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000));
6368 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
6369 path.close();
6371 SkPath path2(path);
6376 SkPath path;
6377 path.setFillType((SkPath::FillType) 1);
6378 path.moveTo(SkBits2Float(0x430c0000), SkBits2Float(0x42200000));
6379 path.lineTo(SkBits2Float(0x43480000), SkBits2Float(0x43520000));
6380 path.lineTo(SkBits2Float(0x42200000), SkBits2Float(0x42c80000));
6381 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x42c80000)); // 2.22222e+022f
6382 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x43520000)); // 2.22222e+022f
6383 path.lineTo(SkBits2Float(0x430c0000), SkBits2Float(0x42200000));
6384 path.close();
6386 SkPath path1(path);
6387 path.reset();
6388 path.setFillType((SkPath::FillType) 0);
6389 path.moveTo(SkBits2Float(0x43200000), SkBits2Float(0x42700000));
6390 path.lineTo(SkBits2Float(0x435c0000), SkBits2Float(0x43660000));
6391 path.lineTo(SkBits2Float(0x42700000), SkBits2Float(0x42f00000));
6392 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x42f00000)); // 2.22222e+022f
6393 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x43660000)); // 2.22222e+022f
6394 path.lineTo(SkBits2Float(0x43200000), SkBits2Float(0x42700000));
6395 path.close();
6397 SkPath path2(path);
6402 SkPath path;
6403 path.setFillType((SkPath::FillType) 0);
6404 path.moveTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
6405 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
6406 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
6407 path.quadTo(SkBits2Float(0xffc00000), SkBits2Float(0x7f800000), SkBits2Float(0xffc00000), SkBits2Float(0x7f800000));
6408 path.quadTo(SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000));
6409 path.quadTo(SkBits2Float(0xff000001), SkBits2Float(0xffc00000), SkBits2Float(0xffc00000), SkBits2Float(0xffc00000));
6410 path.quadTo(SkBits2Float(0xffc00000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xff000001));
6411 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xffc00000));
6412 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0xffc00000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
6413 path.close();
6415 SkPath path1(path);
6416 path.reset();
6417 path.setFillType((SkPath::FillType) 0);
6419 SkPath path2(path);
6425 SkPath path;
6426 path.setFillType((SkPath::FillType) 0);
6427 path.moveTo(SkBits2Float(0x42910000), SkBits2Float(0x00000000)); // 72.5f, 0
6428 path.lineTo(SkBits2Float(0x42166668), SkBits2Float(0x00000000)); // 37.6f, 0
6429 path.cubicTo(SkBits2Float(0x42166668), SkBits2Float(0xc1966668), SkBits2Float(0x41c66668), SkBits2Float(0xc20a6666), SkBits2Float(0x40f00010), SkBits2Float(0xc21ccccd)); // 37.6f, -18.8f, 24.8f, -34.6f, 7.50001f, -39.2f
6430 path.lineTo(SkBits2Float(0x41840004), SkBits2Float(0xc291cccd)); // 16.5f, -72.9f
6431 path.lineTo(SkBits2Float(0x42fb6668), SkBits2Float(0x42c73334)); // 125.7f, 99.6f
6432 path.lineTo(SkBits2Float(0x43646668), SkBits2Float(0x43880ccd)); // 228.4f, 272.1f
6434 SkPath path1(path);
6435 path.reset();
6436 path.setFillType((SkPath::FillType) 0);
6437 path.moveTo(SkBits2Float(0x428bf702), SkBits2Float(0xcf223cbf)); // 69.9824f, -2.72189e+09f
6438 path.lineTo(SkBits2Float(0x42112d68), SkBits2Float(0xcf223cbf)); // 36.2943f, -2.72189e+09f
6439 path.cubicTo(SkBits2Float(0x4220d9fc), SkBits2Float(0xcf223cc0), SkBits2Float(0x420ee118), SkBits2Float(0xcf223cc0), SkBits2Float(0x41cef2f8), SkBits2Float(0xcf223cc0)); // 40.2129f, -2.72189e+09f, 35.7198f, -2.72189e+09f, 25.8686f, -2.72189e+09f
6440 path.lineTo(SkBits2Float(0x424a99e0), SkBits2Float(0xcf223cc0)); // 50.6503f, -2.72189e+09f
6441 path.cubicTo(SkBits2Float(0x42266e32), SkBits2Float(0xcf223cc0), SkBits2Float(0x41f0fa20), SkBits2Float(0xcf223cc0), SkBits2Float(0x41872ed4), SkBits2Float(0xcf223cc0)); // 41.6076f, -2.72189e+09f, 30.1221f, -2.72189e+09f, 16.8979f, -2.72189e+09f
6442 path.lineTo(SkBits2Float(0x40f8fbe0), SkBits2Float(0xcf223cc0)); // 7.78075f, -2.72189e+09f
6444 SkPath path2(path);
6449 SkPath path;
6450 path.setFillType((SkPath::FillType) 0);
6451 path.moveTo(SkBits2Float(0x43b38000), SkBits2Float(0x433e0000)); // 359, 190
6452 path.lineTo(SkBits2Float(0x40c00000), SkBits2Float(0x449ce000)); // 6, 1255
6453 path.cubicTo(SkBits2Float(0x438c0000), SkBits2Float(0x4497a000), SkBits2Float(0x43e40000), SkBits2Float(0x44750000), SkBits2Float(0x41000000), SkBits2Float(0x44aa2000)); // 280, 1213, 456, 980, 8, 1361
6454 path.moveTo(SkBits2Float(0x43290000), SkBits2Float(0x4431c000)); // 169, 711
6455 path.lineTo(SkBits2Float(0xd987d6ba), SkBits2Float(0xd93d0ad4)); // -4.7794e+15f, -3.32567e+15f
6456 path.conicTo(SkBits2Float(0x43cc8000), SkBits2Float(0x445b8000), SkBits2Float(0xd888b096), SkBits2Float(0xd9a1ebfa), SkBits2Float(0x3ebcb199)); // 409, 878, -1.20234e+15f, -5.69712e+15f, 0.368542f
6457 path.cubicTo(SkBits2Float(0x43c00000), SkBits2Float(0x443a8000), SkBits2Float(0x42380000), SkBits2Float(0x4421c000), SkBits2Float(0x42500000), SkBits2Float(0x448ca000)); // 384, 746, 46, 647, 52, 1125
6458 path.quadTo(SkBits2Float(0x43948000), SkBits2Float(0x42ac0000), SkBits2Float(0x43880000), SkBits2Float(0x4487e000)); // 297, 86, 272, 1087
6459 SkPath path1(path);
6460 path.reset();
6461 path.setFillType((SkPath::FillType) 0);
6462 path.moveTo(SkBits2Float(0xc51d735c), SkBits2Float(0xc49db029)); // -2519.21f, -1261.51f
6463 path.cubicTo(SkBits2Float(0xc51d1dbd), SkBits2Float(0xc49d7a3f), SkBits2Float(0xc51c524a), SkBits2Float(0xc49d1610), SkBits2Float(0xc51d1a96), SkBits2Float(0xc49d86a6)); // -2513.86f, -1259.82f, -2501.14f, -1256.69f, -2513.66f, -1260.21f
6464 path.cubicTo(SkBits2Float(0xc51cd471), SkBits2Float(0xc49d54d0), SkBits2Float(0xc51c2e51), SkBits2Float(0xc49d0081), SkBits2Float(0xc51d197b), SkBits2Float(0xc49d7927)); // -2509.28f, -1258.65f, -2498.89f, -1256.02f, -2513.59f, -1259.79f
6465 path.quadTo(SkBits2Float(0xc51bf7eb), SkBits2Float(0xc49cf010), SkBits2Float(0xc51ba866), SkBits2Float(0xc49cb9e6)); // -2495.49f, -1255.5f, -2490.52f, -1253.81f
6466 path.cubicTo(SkBits2Float(0xc51bac0d), SkBits2Float(0xc49cc50e), SkBits2Float(0xc51c29eb), SkBits2Float(0xc49cfb01), SkBits2Float(0xc51c5bca), SkBits2Float(0xc49d1fa6)); // -2490.75f, -1254.16f, -2498.62f, -1255.84f, -2501.74f, -1256.99f
6467 SkPath path2(path);
6472 SkPath path;
6473 path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0xcf000000)); // 360, -2.14748e+09f
6474 path
6475 path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0x43800001), SkBits2Float(0x43348000), SkBits2Float(0x43800001), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, 256, 180.5f, 256, 0.707107f
6476 SkPath path1(path);
6477 path.reset();
6478 path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140
6479 path.conicTo(SkBits2Float(0x43b40005), SkBits2Float(0x458a945d), SkBits2Float(0x45610000), SkBits2Float(0x458a945d), SkBits2Float(0x3f3504f3)); // 360, 4434.55f, 3600, 4434.55f, 0.707107f
6480 path.conicTo(SkBits2Float(0x45d5bfff), SkBits2Float(0x458a945d), SkBits2Float(0x45d5bfff), SkBits2Float(0x45816000), SkBits2Float(0x3f3504f3)); // 6840, 4434.55f, 6840, 4140, 0.707107f
6481 path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000)); // 100, 512
6482 path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000)); // 32, 16
6483 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000)); // 360, 1024
6484 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140
6485 path.close();
6486 SkPath path2(path);
6491 SkPath path;
6492 path.setFillType(SkPath::kEvenOdd_FillType);
6493 path.moveTo(SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe)); // 1.07374e+09f, -1.07374e+09f
6494 path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0xcf000000), SkBits2Float(0x43b40000), SkBits2Float(0xcf000000), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, -2.14748e+09f, 360, -2.14748e+09f, 0.707107f
6495 path.lineTo(SkBits2Float(0x43348000), SkBits2Float(0x43800001)); // 180.5f, 256
6496 path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000)); // 32, 16
6497 path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000)); // 100, 512
6498 path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f
6499 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000)); // 360, 1024
6500 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140
6501 path.conicTo(SkBits2Float(0x43b40005), SkBits2Float(0x458a945d), SkBits2Float(0x45610000), SkBits2Float(0x458a945d), SkBits2Float(0x3f3504f3)); // 360, 4434.55f, 3600, 4434.55f, 0.707107f
6502 path.conicTo(SkBits2Float(0x45d5bfff), SkBits2Float(0x458a945d), SkBits2Float(0x45d5bfff), SkBits2Float(0x45816000), SkBits2Float(0x3f3504f3)); // 6840, 4434.55f, 6840, 4140, 0.707107f
6503 path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f
6504 path.lineTo(SkBits2Float(0x43348000), SkBits2Float(0x43800001)); // 180.5f, 256
6505 path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0x43800001), SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, 256, 1.07374e+09f, -1.07374e+09f, 0.707107f
6506 path.close();
6507 SkPath path1(path);
6508 path.reset();
6509 path.moveTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321
6510 path.lineTo(SkBits2Float(0x45d5c000), SkBits2Float(0x43870000)); // 6840, 270
6511 path.lineTo(SkBits2Float(0xd0a00000), SkBits2Float(0x4cbebc20)); // -2.14748e+10f, 1e+08
6512 path.lineTo(SkBits2Float(0x451f7000), SkBits2Float(0x42800000)); // 2551, 64
6513 path.lineTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321
6514 path.close();
6515 SkPath path2(path);
6520 SkPath path;
6521 path.setFillType((SkPath::FillType) 1);
6523 SkPath path1(path);
6524 path.reset();
6525 path.setFillType((SkPath::FillType) 0);
6526 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6527 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321), SkBits2Float(0xed7a6a4b), SkBits2Float(0x1f212a8c)); // 2.49282e-13f, 4.78968e-34f, 1.99397e+36f, -4.84373e+27f, 3.41283e-20f
6528 path.lineTo(SkBits2Float(0x7bc00321), SkBits2Float(0xed7a6a4b)); // 1.99397e+36f, -4.84373e+27f
6529 path.lineTo(SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28)); // 9.4495e-15f, 0.000617492f
6530 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6531 path.close();
6532 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6533 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3), SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6)); // -8.10388e-33f, 0.00148185f, 2.25206e-21f, 5.54035e+21f
6534 path.moveTo(SkBits2Float(0x29272a81), SkBits2Float(0x2ab03a55)); // 3.71183e-14f, 3.13044e-13f
6535 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a214729), SkBits2Float(0xdf28282a), SkBits2Float(0x8a2f2121)); // 2.22225e-15f, 0.000615227f, -1.2117e+19f, -8.43217e-33f
6536 path.quadTo(SkBits2Float(0x373b3a27), SkBits2Float(0x201fc4c1), SkBits2Float(0x27576c2a), SkBits2Float(0x5921c25d)); // 1.11596e-05f, 1.35329e-19f, 2.98959e-15f, 2.8457e+15f
6537 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a214729), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21)); // 2.22225e-15f, 0.000615227f, -1.2117e+19f, 0.00105459f
6538 path.cubicTo(SkBits2Float(0x373b3ac5), SkBits2Float(0x201fc422), SkBits2Float(0x523a702a), SkBits2Float(0x27576c51), SkBits2Float(0x5921c25d), SkBits2Float(0x51523a70)); // 1.11598e-05f, 1.35327e-19f, 2.00186e+11f, 2.9896e-15f, 2.8457e+15f, 5.64327e+10f
6539 path.quadTo(SkBits2Float(0xd912102a), SkBits2Float(0x284f9a28), SkBits2Float(0xb38a1f30), SkBits2Float(0x3a3ac23a)); // -2.56957e+15f, 1.15242e-14f, -6.4318e-08f, 0.000712428f
6540 path.lineTo(SkBits2Float(0xc809272a), SkBits2Float(0x29b02829)); // -140445, 7.82294e-14f
6542 SkPath path2(path);
6548 SkPath path;
6549 path.setFillType((SkPath::FillType) 1);
6551 SkPath path1(path);
6552 path.reset();
6553 path.setFillType((SkPath::FillType) 0);
6554 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6555 path.lineTo(SkBits2Float(0x555b3a2d), SkBits2Float(0x2a212a8c)); // 1.50652e+13f, 1.43144e-13f
6556 path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f
6557 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac2b33a)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148544f
6558 path.cubicTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6), SkBits2Float(0x295b2d2a), SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c275b)); // 2.25206e-21f, 5.54035e+21f, 4.86669e-14f, 3.19905e+24f, 9.6297e-12f, 2.48963e-13f
6559 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6560 path.close();
6561 path.moveTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f
6562 path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x2a21081f)); // 1.43144e-13f, 1.43025e-13f
6563 path.conicTo(SkBits2Float(0xde6a4b7b), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // -4.22068e+18f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121589
6564 path.lineTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f
6565 path.close();
6566 path.moveTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f
6567 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
6568 path.lineTo(SkBits2Float(0x2928088c), SkBits2Float(0x2be61d2a)); // 3.73109e-14f, 1.63506e-12f
6569 path.conicTo(SkBits2Float(0x2a812a63), SkBits2Float(0x2d292a27), SkBits2Float(0x5568295b), SkBits2Float(0x5b2d2968), SkBits2Float(0x552d6829)); // 2.29444e-13f, 9.6159e-12f, 1.5954e+13f, 4.87407e+16f, 1.19164e+13f
6570 path.conicTo(SkBits2Float(0x395b2d5b), SkBits2Float(0x68552768), SkBits2Float(0x555b2df0), SkBits2Float(0x1f722a8c), SkBits2Float(0x082a212a)); // 0.000209024f, 4.02636e+24f, 1.50619e+13f, 5.12807e-20f, 5.11965e-34f
6571 path.lineTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f
6572 path.close();
6573 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6574 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2147ed7a), SkBits2Float(0x28282a3a), SkBits2Float(0x21df212a), SkBits2Float(0x033a8a3a)); // 6.14991e+25f, 6.77381e-19f, 9.33503e-15f, 1.51198e-18f, 5.48192e-37f
6576 SkPath path2(path);
6581 SkPath path;
6582 path.setFillType((SkPath::FillType) 1);
6584 SkPath path1(path);
6585 path.reset();
6586 path.setFillType((SkPath::FillType) 0);
6587 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6588 path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f
6589 path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x295b2d1f), SkBits2Float(0x29685568)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.86669e-14f, 5.15884e-14f
6590 path.conicTo(SkBits2Float(0x8c28295b), SkBits2Float(0x1f21212a), SkBits2Float(0xc0032a08), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced)); // -1.29547e-31f, 3.41205e-20f, -2.04944f, 3.04132e+35f, 5.77848e-19f
6591 path.moveTo(SkBits2Float(0x25682929), SkBits2Float(0x212a8c5b)); // 2.01367e-16f, 5.7784e-19f
6592 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4a7bc0)); // 4.7323e-37f, 6.11969e+25f
6593 path.conicTo(SkBits2Float(0x032108ed), SkBits2Float(0x283a7bc0), SkBits2Float(0x47ed7a6a), SkBits2Float(0x282a3a21), SkBits2Float(0x3a21ff28)); // 4.73239e-37f, 1.03519e-14f, 121589, 9.4495e-15f, 0.000617968f
6594 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.00148185f, 1.50241e-13f, -1.38859e-25f
6595 path.lineTo(SkBits2Float(0x295b2d2a), SkBits2Float(0x2d296868)); // 4.86669e-14f, 9.62972e-12f
6596 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6597 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x898ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // 6.14991e+25f, -3.39271e-33f, 4.61198e-19f, 0.00096035f, 121589
6598 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6599 path.close();
6600 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6601 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0xb38a281a), SkBits2Float(0x29283ac2)); // -1.2117e+19f, 0.00105459f, -6.43342e-08f, 3.73545e-14f
6602 path.moveTo(SkBits2Float(0x962be61d), SkBits2Float(0x432a2927)); // -1.38859e-25f, 170.161f
6603 path.conicTo(SkBits2Float(0x3a2a552a), SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x3b3ac527), SkBits2Float(0x1fc42236)); // 0.000649768f, 0.00241343f, 3.71093e-14f, 0.00284989f, 8.30658e-20f
6604 path.cubicTo(SkBits2Float(0x27576c2a), SkBits2Float(0x5921c25d), SkBits2Float(0x51503a70), SkBits2Float(0x12102a10), SkBits2Float(0x633a28d9), SkBits2Float(0x29c80927)); // 2.98959e-15f, 2.8457e+15f, 5.58959e+10f, 4.54902e-28f, 3.43404e+21f, 8.88337e-14f
6605 path.lineTo(SkBits2Float(0x272927b0), SkBits2Float(0x5b392929)); // 2.3475e-15f, 5.21181e+16f
6606 path.moveTo(SkBits2Float(0x3a1127b4), SkBits2Float(0x2921ee3b)); // 0.000553723f, 3.59558e-14f
6607 path.cubicTo(SkBits2Float(0x5e215d3b), SkBits2Float(0x7828ee3a), SkBits2Float(0x8e28b03b), SkBits2Float(0x50783be8), SkBits2Float(0x9e0b8a3a), SkBits2Float(0x555b2d68)); // 2.90688e+18f, 1.37053e+34f, -2.07925e-30f, 1.66587e+10f, -7.38718e-21f, 1.50618e+13f
6608 path.moveTo(SkBits2Float(0x21081f3f), SkBits2Float(0x9fd4e62a)); // 4.61199e-19f, -9.01663e-20f
6609 path.cubicTo(SkBits2Float(0x3a293a2a), SkBits2Float(0x0e3bf0c5), SkBits2Float(0x3b29d42a), SkBits2Float(0x0f217265), SkBits2Float(0x2d5d2921), SkBits2Float(0x5568295b)); // 0.000645551f, 2.31655e-30f, 0.00259138f, 7.95994e-30f, 1.25715e-11f, 1.5954e+13f
6611 SkPath path2(path);
6616 SkPath path;
6617 path.setFillType((SkPath::FillType) 1);
6619 SkPath path1(path);
6620 path.reset();
6621 path.setFillType((SkPath::FillType) 0);
6622 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
6623 path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b79), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f
6624 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
6625 path.cubicTo(SkBits2Float(0xe62a2928), SkBits2Float(0x2a63962b), SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x001f2a21)); // -2.0089e+23f, 2.02138e-13f, 3.19905e+24f, 9.6297e-12f, 2.49282e-13f, 2.86201e-39f
6626 path.lineTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
6627 path.close();
6628 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
6629 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121589
6630 path.lineTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
6631 path.close();
6632 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
6633 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3b21), SkBits2Float(0x28ee4f9a), SkBits2Float(0x68293b78)); // -1.2117e+19f, 0.00105462f, 2.64578e-14f, 3.19671e+24f
6634 path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x5b2d8c55)); // 4.87407e+16f, 4.88495e+16f
6636 SkPath path2(path);
6641 SkPath path;
6642 path.setFillType((SkPath::FillType) 1);
6644 SkPath path1(path);
6645 path.reset();
6646 path.setFillType((SkPath::FillType) 0);
6647 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6648 path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f
6649 path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f
6650 path.lineTo(SkBits2Float(0x081f2ad7), SkBits2Float(0x7bc00321)); // 4.78977e-34f, 1.99397e+36f
6651 path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
6652 path.quadTo(SkBits2Float(0x4f1a3a8a), SkBits2Float(0x3ab38a28), SkBits2Float(0x29283ac2), SkBits2Float(0x962be62a)); // 2.58753e+09f, 0.00136978f, 3.73545e-14f, -1.38859e-25f
6653 path.cubicTo(SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529), SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x3b3ac527), SkBits2Float(0x1fc42237)); // 2.36623e-15f, 0.000649768f, 0.00241343f, 3.71093e-14f, 0.00284989f, 8.30658e-20f
6654 path.cubicTo(SkBits2Float(0x27576c2a), SkBits2Float(0x5921c25d), SkBits2Float(0x51523a70), SkBits2Float(0x12102a10), SkBits2Float(0x633a28d9), SkBits2Float(0x29c80927)); // 2.98959e-15f, 2.8457e+15f, 5.64327e+10f, 4.54902e-28f, 3.43404e+21f, 8.88337e-14f
6655 path.lineTo(SkBits2Float(0x29292727), SkBits2Float(0x21475b3b)); // 3.75595e-14f, 6.75446e-19f
6656 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
6657 path.cubicTo(SkBits2Float(0x682d2928), SkBits2Float(0x555b6829), SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 3.27091e+24f, 1.50775e+13f, 1.50606e+13f, 1.43144e-13f, 4.7323e-37f, 6.14991e+25f
6658 path.conicTo(SkBits2Float(0x295b2ded), SkBits2Float(0x29685568), SkBits2Float(0x8c555b2d), SkBits2Float(0xe61d2a2a), SkBits2Float(0x2a63962b)); // 4.86676e-14f, 5.15884e-14f, -1.64364e-31f, -1.85547e+23f, 2.02138e-13f
6659 path.conicTo(SkBits2Float(0x5568295b), SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a), SkBits2Float(0x4b7bc003)); // 1.5954e+13f, 4.87407e+16f, 5.7784e-19f, 4.61198e-19f, 1.64987e+07f
6660 path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21)); // 2.50338e-13f, 4.61198e-19f
6661 path.conicTo(SkBits2Float(0x6a3a7bc0), SkBits2Float(0x2147ed7a), SkBits2Float(0x28282a3a), SkBits2Float(0x8a3a21df), SkBits2Float(0x27b42a3a)); // 5.63611e+25f, 6.77381e-19f, 9.33503e-15f, -8.96194e-33f, 5.00058e-15f
6662 path.conicTo(SkBits2Float(0x2921217d), SkBits2Float(0x5e3a3b35), SkBits2Float(0x7828ee3a), SkBits2Float(0x8e28b03b), SkBits2Float(0x783be82a)); // 3.57782e-14f, 3.35484e+18f, 1.37053e+34f, -2.07925e-30f, 1.52448e+34f
6663 path.conicTo(SkBits2Float(0x8e0b8a3a), SkBits2Float(0x279fd4e6), SkBits2Float(0x7a293a2a), SkBits2Float(0x2a0ef0c5), SkBits2Float(0x653b29d4)); // -1.71996e-30f, 4.43622e-15f, 2.19669e+35f, 1.26957e-13f, 5.52409e+22f
6664 path.quadTo(SkBits2Float(0x29210f21), SkBits2Float(0x282a085d), SkBits2Float(0xc2ab2127), SkBits2Float(0xa6800028)); // 3.57623e-14f, 9.43871e-15f, -85.5648f, -8.88183e-16f
6665 path.lineTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
6666 path.close();
6667 path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
6668 path.quadTo(SkBits2Float(0x216a2770), SkBits2Float(0x2ab73b28), SkBits2Float(0x4b28f427), SkBits2Float(0x283b5b28)); // 7.93345e-19f, 3.25484e-13f, 1.10726e+07f, 1.04004e-14f
6669 path.lineTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
6670 path.close();
6671 path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
6672 path.conicTo(SkBits2Float(0xf86d273b), SkBits2Float(0x27e523e3), SkBits2Float(0x2927e0f5), SkBits2Float(0x2ac0e729), SkBits2Float(0x6b492128)); // -1.92402e+34f, 6.35992e-15f, 3.72766e-14f, 3.42665e-13f, 2.43151e+26f
6673 path.cubicTo(SkBits2Float(0x2f273927), SkBits2Float(0xa83a2c21), SkBits2Float(0xd7122121), SkBits2Float(0x21212921), SkBits2Float(0x3be3db3a), SkBits2Float(0xa9deb63b)); // 1.52089e-10f, -1.03346e-14f, -1.60671e+14f, 5.46034e-19f, 0.00695362f, -9.89039e-14f
6675 SkPath path2(path);
6681 SkPath path;
6682 path.setFillType((SkPath::FillType) 0);
6684 SkPath path1(path);
6685 path.reset();
6686 path.setFillType((SkPath::FillType) 0);
6687 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6688 path.cubicTo(SkBits2Float(0x1931204a), SkBits2Float(0x2ba1a14a), SkBits2Float(0x4a4a08ff), SkBits2Float(0x4a4a08ff), SkBits2Float(0x4a4a4a34), SkBits2Float(0x4a4a4a4a)); // 9.15721e-24f, 1.14845e-12f, 3.31014e+06f, 3.31014e+06f, 3.31432e+06f, 3.31432e+06f
6689 path.moveTo(SkBits2Float(0x000010a1), SkBits2Float(0x19312000)); // 5.96533e-42f, 9.15715e-24f
6690 path.cubicTo(SkBits2Float(0x4a4a4a4a), SkBits2Float(0x4a4a4a4a), SkBits2Float(0xa14a4a4a), SkBits2Float(0x08ff2ba1), SkBits2Float(0x08ff4a4a), SkBits2Float(0x4a344a4a)); // 3.31432e+06f, 3.31432e+06f, -6.85386e-19f, 1.53575e-33f, 1.53647e-33f, 2.95387e+06f
6691 path.cubicTo(SkBits2Float(0x4a4a4a4a), SkBits2Float(0x4a4a4a4a), SkBits2Float(0x2ba1a14a), SkBits2Float(0x4e4a08ff), SkBits2Float(0x4a4a4a4a), SkBits2Float(0xa1a181ff)); // 3.31432e+06f, 3.31432e+06f, 1.14845e-12f, 8.47397e+08f, 3.31432e+06f, -1.09442e-18f
6693 SkPath path2(path);
6700 SkPath path;
6701 path.setFillType((SkPath::FillType) 0);
6702 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6703 path.cubicTo(SkBits2Float(0x0000ff07), SkBits2Float(0xf9f9ff00), SkBits2Float(0xfe0ef9f4), SkBits2Float(0xd9b105fb), SkBits2Float(0x000000f9), SkBits2Float(0xfe11f901)); // 9.14866e-41f, -1.62257e+35f, -4.75121e+37f, -6.22846e+15f, 3.48923e-43f, -4.85077e+37f
6704 path.lineTo(SkBits2Float(0xda1905ed), SkBits2Float(0x3c05fbfb)); // -1.0768e+16f, 0.00817775f
6705 path.cubicTo(SkBits2Float(0x3c3c3c3c), SkBits2Float(0x3c3c3c3c), SkBits2Float(0x253c7f00), SkBits2Float(0xfa00d3fa), SkBits2Float(0x250025fe), SkBits2Float(0x00000006)); // 0.011489f, 0.011489f, 1.63494e-16f, -1.67228e+35f, 1.11151e-16f, 8.40779e-45f
6707 SkPath path1(path);
6708 path.reset();
6709 path.setFillType((SkPath::FillType) 0);
6710 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6711 path.quadTo(SkBits2Float(0x3c3c3c3c), SkBits2Float(0xfa253c3c), SkBits2Float(0xfefa00d3), SkBits2Float(0x25fad9df)); // 0.011489f, -2.14488e+35f, -1.66156e+38f, 4.35157e-16f
6712 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6713 path.close();
6714 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6715 path.lineTo(SkBits2Float(0x8dfefa00), SkBits2Float(0xf0f9fad9)); // -1.57141e-30f, -6.1892e+29f
6716 path.cubicTo(SkBits2Float(0x20fe58f9), SkBits2Float(0x0525fbed), SkBits2Float(0x1905ffff), SkBits2Float(0x01f9f9f9), SkBits2Float(0xfbfe0ef9), SkBits2Float(0xfb212fff)); // 4.30882e-19f, 7.80453e-36f, 6.92764e-24f, 9.18268e-38f, -2.63829e+36f, -8.36933e+35f
6718 SkPath path2(path);
6723 SkPath path;
6724 path.setFillType((SkPath::FillType) 0);
6725 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6726 path.cubicTo(SkBits2Float(0x154be880), SkBits2Float(0x80000640), SkBits2Float(0x5559a419), SkBits2Float(0x59d55928), SkBits2Float(0x80045959), SkBits2Float(0x40154be8)); // 4.11789e-26f, -2.24208e-42f, 1.49562e+13f, 7.50652e+15f, -3.99394e-40f, 2.33276f
6728 SkPath path1(path);
6729 path.reset();
6730 path.setFillType((SkPath::FillType) 0);
6731 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6732 path.quadTo(SkBits2Float(0x5559a419), SkBits2Float(0x59d55928), SkBits2Float(0xbd595959), SkBits2Float(0x3f3f3f09)); // 1.49562e+13f, 7.50652e+15f, -0.0530637f, 0.747056f
6733 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0x3f3f3f3f)); // 0.747059f, 0.747059f
6734 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f
6735 path.lineTo(SkBits2Float(0x09090909), SkBits2Float(0x3038d509)); // 1.6495e-33f, 6.72416e-10f
6736 path.conicTo(SkBits2Float(0x5947ffff), SkBits2Float(0x40e88004), SkBits2Float(0x00002059), SkBits2Float(0x28555900), SkBits2Float(0x5959d559)); // 3.51844e+15f, 7.26563f, 1.16042e-41f, 1.18432e-14f, 3.83217e+15f
6737 path.lineTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f
6738 path.close();
6739 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f
6740 path.lineTo(SkBits2Float(0x38d57f4b), SkBits2Float(0x59597f4b)); // 0.000101803f, 3.82625e+15f
6741 path.lineTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f
6742 path.close();
6743 path.moveTo(SkBits2Float(0x384700ff), SkBits2Float(0x0108804b)); // 4.74462e-05f, 2.50713e-38f
6745 SkPath path2(path);
6751 SkPath path;
6752 path.setFillType((SkPath::FillType) 1);
6754 SkPath path1(path);
6755 path.reset();
6756 path.setFillType((SkPath::FillType) 0);
6757 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6758 path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f
6759 path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f
6760 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
6761 path.cubicTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6), SkBits2Float(0x272a812a), SkBits2Float(0x295b2d29), SkBits2Float(0x2a685568), SkBits2Float(0x68295b2d)); // 2.25206e-21f, 5.54035e+21f, 2.36623e-15f, 4.86669e-14f, 2.06354e-13f, 3.19905e+24f
6762 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321), SkBits2Float(0x7a6a4b77), SkBits2Float(0x3a214726)); // 2.49282e-13f, 4.78968e-34f, 1.99397e+36f, 3.04132e+35f, 0.000615226f
6763 path.moveTo(SkBits2Float(0x8adf2028), SkBits2Float(0x3a219a3a)); // -2.14862e-32f, 0.000616464f
6764 path.quadTo(SkBits2Float(0x3ab38e28), SkBits2Float(0x29283ac2), SkBits2Float(0x2be61d2a), SkBits2Float(0x812a4396)); // 0.0013699f, 3.73545e-14f, 1.63506e-12f, -3.12726e-38f
6766 SkPath path2(path);
6772 SkPath path;
6773 path.setFillType((SkPath::FillType) 1);
6774 path.moveTo(SkBits2Float(0x38bd8610), SkBits2Float(0x00000000)); // 9.03719e-05f, 0
6775 path.conicTo(SkBits2Float(0x4183d871), SkBits2Float(0x41fea321), SkBits2Float(0xb700ff00), SkBits2Float(0x4240b8b8), SkBits2Float(0x3b058283)); // 16.4807f, 31.8297f, -7.68877e-06f, 48.1804f, 0.0020372f
6776 path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f
6777 path.conicTo(SkBits2Float(0x3a455ec8), SkBits2Float(0xb8b8b8b3), SkBits2Float(0x38b2418d), SkBits2Float(0xb730d014), SkBits2Float(0x3f7ffff3)); // 0.000752908f, -8.80821e-05f, 8.49991e-05f, -1.05389e-05f, 0.999999f
6778 path.quadTo(SkBits2Float(0x3a51246a), SkBits2Float(0xb6da45a3), SkBits2Float(0x38bc5c3c), SkBits2Float(0x00000000)); // 0.000797814f, -6.50501e-06f, 8.98172e-05f, 0
6779 path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f
6780 path.quadTo(SkBits2Float(0x39a32d2d), SkBits2Float(0x00000000), SkBits2Float(0xb8a13a00), SkBits2Float(0x00000000)); // 0.000311234f, 0, -7.68788e-05f, 0
6781 path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f
6782 path.quadTo(SkBits2Float(0x39ba814c), SkBits2Float(0xb838fed2), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0.00035573f, -4.41063e-05f, 0, 0
6783 path.lineTo(SkBits2Float(0x38bd8610), SkBits2Float(0x00000000)); // 9.03719e-05f, 0
6784 path.close();
6786 SkPath path1(path);
6787 path.reset();
6788 path.setFillType((SkPath::FillType) 0);
6790 SkPath path2(path);
6796 SkPath path;
6797 path.setFillType((SkPath::FillType) 1);
6799 SkPath path1(path);
6800 path.reset();
6801 path.setFillType((SkPath::FillType) 0);
6802 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6803 path.quadTo(SkBits2Float(0x3e484500), SkBits2Float(0x164f3a30), SkBits2Float(0x49484801), SkBits2Float(0x7d0100c8)); // 0.195576f, 1.67397e-25f, 820352, 1.07172e+37f
6804 path.conicTo(SkBits2Float(0xff7f36fd), SkBits2Float(0x3e647d01), SkBits2Float(0x0c00f430), SkBits2Float(0x486b6448), SkBits2Float(0x00484848)); // -3.39239e+38f, 0.223133f, 9.93424e-32f, 241041, 6.63809e-39f
6805 path.lineTo(SkBits2Float(0x4f4f557d), SkBits2Float(0x48480112)); // 3.47849e+09f, 204804
6806 path.lineTo(SkBits2Float(0xf40c01ff), SkBits2Float(0x45008000)); // -4.43702e+31f, 2056
6807 path.moveTo(SkBits2Float(0x4bfffa00), SkBits2Float(0x7d4ac859)); // 3.35514e+07f, 1.68465e+37f
6808 path.conicTo(SkBits2Float(0x7d014f3e), SkBits2Float(0x00f4ff01), SkBits2Float(0x6b64480c), SkBits2Float(0x48484848), SkBits2Float(0x557d0100)); // 1.07426e+37f, 2.24993e-38f, 2.75975e+26f, 205089, 1.73863e+13f
6810 SkPath path2(path);
6816 SkPath path;
6817 path.setFillType((SkPath::FillType) 1);
6819 SkPath path1(path);
6820 path.reset();
6821 path.setFillType((SkPath::FillType) 0);
6822 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55)); // 4.76191e+16f, 5.7784e-19f
6823 path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
6824 path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21)); // 2.50338e-13f, 4.61198e-19f
6825 path.conicTo(SkBits2Float(0x6a3a7bc0), SkBits2Float(0x4721ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28), SkBits2Float(0x4f9a3a8a)); // 5.63611e+25f, 41453.5f, 9.4495e-15f, 0.000617492f, 5.17506e+09f
6826 path.lineTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
6827 path.close();
6828 path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
6829 path.cubicTo(SkBits2Float(0x273ac23a), SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6), SkBits2Float(0x272a812a), SkBits2Float(0x295b2d29), SkBits2Float(0x29685568)); // 2.5918e-15f, 2.25206e-21f, 5.54035e+21f, 2.36623e-15f, 4.86669e-14f, 5.15884e-14f
6830 path.lineTo(SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321)); // 4.78968e-34f, 1.99397e+36f
6831 path.lineTo(SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28)); // 9.4495e-15f, 0.000617492f
6832 path.lineTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
6833 path.close();
6834 path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
6835 path.quadTo(SkBits2Float(0x8a4fc29a), SkBits2Float(0x3ab3283a), SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6)); // -1.00033e-32f, 0.00136686f, 2.25206e-21f, 300.343f
6836 path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
6837 path.conicTo(SkBits2Float(0x1e2ab03a), SkBits2Float(0x2920213b), SkBits2Float(0x3b3ac527), SkBits2Float(0xc422333b), SkBits2Float(0x6c2a9f1f)); // 9.03617e-21f, 3.5556e-14f, 0.00284989f, -648.8f, 8.25075e+26f
6838 path.quadTo(SkBits2Float(0xc25d2757), SkBits2Float(0x3a705921), SkBits2Float(0x2a105152), SkBits2Float(0x28d91210)); // -55.2884f, 0.000916855f, 1.2818e-13f, 2.40997e-14f
6839 path.quadTo(SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19905e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f
6840 path.lineTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
6841 path.close();
6842 path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
6843 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0xcb7bc003), SkBits2Float(0x47ed7a6a)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, -1.64987e+07f, 121589
6844 path.lineTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
6845 path.close();
6846 path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
6847 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x2d8a3a21), SkBits2Float(0x5b682b68), SkBits2Float(0x5b292d55)); // -1.2117e+19f, 1.57146e-11f, 6.53499e+16f, 4.76191e+16f
6848 path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x0321081f)); // 1.43144e-13f, 4.7323e-37f
6849 path.conicTo(SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x3a21477a)); // 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f, 0.000615231f
6850 path.moveTo(SkBits2Float(0x21df2828), SkBits2Float(0x9a3a8a3a)); // 1.51217e-18f, -3.85756e-23f
6851 path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x28273ac2), SkBits2Float(0xe61d2a29), SkBits2Float(0x2a63962b)); // 0.00136978f, 9.2831e-15f, -1.85547e+23f, 2.02138e-13f
6852 path.conicTo(SkBits2Float(0x2d29272a), SkBits2Float(0x5568295b), SkBits2Float(0x5b2d2968), SkBits2Float(0x5b2d6829), SkBits2Float(0x212a8c55)); // 9.61523e-12f, 1.5954e+13f, 4.87407e+16f, 4.88097e+16f, 5.7784e-19f
6853 path
6854 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
6855 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6856 path.close();
6858 SkPath path2(path);
6863 SkPath path;
6864 path.setFillType((SkPath::FillType) 1);
6866 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x36344a4a)); // 0, 2.68653e-06f
6867 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x364a4a4a), SkBits2Float(0x364a4a4a), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0, 3.01436e-06f, 3.01436e-06f, 0, 0
6868 path.lineTo(SkBits2Float(0x364a4a4a), SkBits2Float(0x00000000)); // 3.01436e-06f, 0
6869 path.cubicTo(SkBits2Float(0x364a30f0), SkBits2Float(0x344ac7fb), SkBits2Float(0x3656d432), SkBits2Float(0x34cabb48), SkBits2Float(0x367031a9), SkBits2Float(0x351802f1)); // 3.01288e-06f, 1.88855e-07f, 3.2012e-06f, 3.77617e-07f, 3.57917e-06f, 5.66287e-07f
6870 path.cubicTo(SkBits2Float(0x36a7b150), SkBits2Float(0x35ab09db), SkBits2Float(0x371874ed), SkBits2Float(0x3604f2c7), SkBits2Float(0x3784e0c7), SkBits2Float(0x36344a51)); // 4.99763e-06f, 1.27434e-06f, 9.08713e-06f, 1.98108e-06f, 1.58403e-05f, 2.68653e-06f
6871 path.cubicTo(SkBits2Float(0x3743dc9a), SkBits2Float(0x36344a4f), SkBits2Float(0x36fbef33), SkBits2Float(0x36344a4e), SkBits2Float(0x36604a35), SkBits2Float(0x36344a4c)); // 1.16743e-05f, 2.68653e-06f, 7.50823e-06f, 2.68653e-06f, 3.34218e-06f, 2.68653e-06f
6872 path.cubicTo(SkBits2Float(0x36531715), SkBits2Float(0x36344a4c), SkBits2Float(0x3645e3f5), SkBits2Float(0x36344a4b), SkBits2Float(0x3638b0d4), SkBits2Float(0x36344a4b)); // 3.14549e-06f, 2.68653e-06f, 2.9488e-06f, 2.68653e-06f, 2.75211e-06f, 2.68653e-06f
6873 path.cubicTo(SkBits2Float(0x35f64120), SkBits2Float(0x36344a4b), SkBits2Float(0x35764124), SkBits2Float(0x36344a4a), SkBits2Float(0x00000000), SkBits2Float(0x36344a4a)); // 1.83474e-06f, 2.68653e-06f, 9.17369e-07f, 2.68653e-06f, 0, 2.68653e-06f
6874 path.close();
6875 SkPath path1(path);
6876 path.reset();
6877 path.setFillType((SkPath::FillType) 0);
6878 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6879 path.cubicTo(SkBits2Float(0x1931204a), SkBits2Float(0x2ba1a14a), SkBits2Float(0x4a4a08ff), SkBits2Float(0x4a4a08ff), SkBits2Float(0x4a4a4a34), SkBits2Float(0x4a4a4a4a)); // 9.15721e-24f, 1.14845e-12f, 3.31014e+06f, 3.31014e+06f, 3.31432e+06f, 3.31432e+06f
6880 path.moveTo(SkBits2Float(0x000010a1), SkBits2Float(0x19312000)); // 5.96533e-42f, 9.15715e-24f
6881 path.cubicTo(SkBits2Float(0x4a4a4a4a), SkBits2Float(0x4a4a4a4a), SkBits2Float(0xa14a4a4a), SkBits2Float(0x08ff2ba1), SkBits2Float(0x08ff4a4a), SkBits2Float(0x4a344a4a)); // 3.31432e+06f, 3.31432e+06f, -6.85386e-19f, 1.53575e-33f, 1.53647e-33f, 2.95387e+06f
6882 path.cubicTo(SkBits2Float(0x544a4a4a), SkBits2Float(0x4a4a4a4a), SkBits2Float(0x2ba1a14a), SkBits2Float(0x4e4a08ff), SkBits2Float(0x4a4a4a4a), SkBits2Float(0xa1a181ff)); // 3.47532e+12f, 3.31432e+06f, 1.14845e-12f, 8.47397e+08f, 3.31432e+06f, -1.09442e-18f
6883 SkPath path2(path);
6888 SkPath path;
6889 path.setFillType((SkPath::FillType) 1);
6890 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f
6891 path.cubicTo(SkBits2Float(0x68295b2d), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 3.19905e+24f, 0, 0, 0, 0, 4.03114e+24f
6892 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f
6893 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x67d55b2a), SkBits2Float(0x67296a4b), SkBits2Float(0x67555b2a), SkBits2Float(0x677e1f70), SkBits2Float(0x66d55b2a)); // 0, 2.01509e+24f, 8.00041e+23f, 1.00755e+24f, 1.20006e+24f, 5.03773e+23f
6894 path.cubicTo(SkBits2Float(0x678f0684), SkBits2Float(0x6684f008), SkBits2Float(0x6798f8ea), SkBits2Float(0x6625a942), SkBits2Float(0x67961914), SkBits2Float(0x65ce709a)); // 1.35084e+24f, 3.1389e+23f, 1.44478e+24f, 1.95578e+23f, 1.41764e+24f, 1.21861e+23f
6895 path.cubicTo(SkBits2Float(0x679174f7), SkBits2Float(0x63199132), SkBits2Float(0x6756c79f), SkBits2Float(0x606478de), SkBits2Float(0x65682bcf), SkBits2Float(0x00000000)); // 1.3738e+24f, 2.83281e+21f, 1.01427e+24f, 6.58526e+19f, 6.85248e+22f, 0
6896 path.conicTo(SkBits2Float(0x68295b02), SkBits2Float(0x60f7f28b), SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f), SkBits2Float(0x42784f5a)); // 3.19903e+24f, 1.42932e+20f, 0, 5.14279e+25f, 62.0775f
6897 path.close();
6898 path.moveTo(SkBits2Float(0x654d6d10), SkBits2Float(0x00000000)); // 6.06311e+22f, 0
6899 path.lineTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000)); // 6.14991e+25f, 0
6900 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc0)); // 0, 6.14991e+25f
6901 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6903 SkPath path1(path);
6904 path.reset();
6905 path.setFillType((SkPath::FillType) 0);
6906 path.moveTo(SkBits2Float(0x3ac23a55), SkBits2Float(0x2a292827)); // 0.00148184f, 1.50241e-13f
6907 path.lineTo(SkBits2Float(0x63962be6), SkBits2Float(0x272a812a)); // 5.54035e+21f, 2.36623e-15f
6909 SkPath path2(path);
6914 SkPath path;
6915 path.setFillType((SkPath::FillType) 0);
6917 SkPath path1(path);
6918 path.reset();
6919 path.setFillType((SkPath::FillType) 0);
6920 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
6921 path.moveTo(SkBits2Float(0x0f2a312a), SkBits2Float(0xc0032108)); // 8.39112e-30f, -2.04889f
6922 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a1f2a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76395e-19f, 4.7323e-37f, 6.14991e+25f
6923 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
6924 path.moveTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f
6925 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0xef2a8c55), SkBits2Float(0x295b2d2a), SkBits2Float(0x08685568), SkBits2Float(0x7bc00321)); // 5.76397e-19f, -5.27821e+28f, 4.86669e-14f, 6.99154e-34f, 1.99397e+36f
6926 path.lineTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f
6927 path.close();
6928 path.moveTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f
6929 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
6930 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6931 path.lineTo(SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a281a4f)); // 0.00105461f, -8.09385e-33f
6932 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f
6933 path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f
6934 path.conicTo(SkBits2Float(0xba1f203a), SkBits2Float(0xc422c538), SkBits2Float(0x215d5927), SkBits2Float(0x70ec2ac2), SkBits2Float(0x2a51523a)); // -0.000607017f, -651.082f, 7.49957e-19f, 5.84721e+29f, 1.85915e-13f
6935 path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x683a5b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.52017e+24f
6936 path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f
6937 path.conicTo(SkBits2Float(0xaa8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x5b2d0321), SkBits2Float(0x68556829), SkBits2Float(0x2a552d29)); // -2.49282e-13f, 4.78968e-34f, 4.86986e+16f, 4.03114e+24f, 1.89339e-13f
6938 path.cubicTo(SkBits2Float(0x21295b2d), SkBits2Float(0x2a688c5b), SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x8c08555b), SkBits2Float(0x2a2a29ca)); // 5.73801e-19f, 2.06544e-13f, 3.19905e+24f, 9.6297e-12f, -1.05027e-31f, 1.51135e-13f
6939 path.quadTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f
6940 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6941 path.close();
6942 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6943 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x5b2d6829), SkBits2Float(0x212a8c55), SkBits2Float(0xed7aba1f), SkBits2Float(0x2a212a8c)); // 6.14991e+25f, 4.88097e+16f, 5.7784e-19f, -4.84977e+27f, 1.43144e-13f
6944 path.moveTo(SkBits2Float(0x2d212d08), SkBits2Float(0x5568295b)); // 9.16179e-12f, 1.5954e+13f
6945 path.moveTo(SkBits2Float(0x5529685b), SkBits2Float(0x11295b68)); // 1.16416e+13f, 1.33599e-28f
6946 path.conicTo(SkBits2Float(0x5b782968), SkBits2Float(0x3a292d55), SkBits2Float(0x2a8c555b), SkBits2Float(0x68295a2d), SkBits2Float(0x2d296855)); // 6.98513e+16f, 0.000645359f, 2.49282e-13f, 3.19897e+24f, 9.6297e-12f
6947 path.moveTo(SkBits2Float(0x555b8c55), SkBits2Float(0x21682929)); // 1.50872e+13f, 7.86591e-19f
6948 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6949 path.conicTo(SkBits2Float(0xac2d8ced), SkBits2Float(0x5b682968), SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55), SkBits2Float(0x081f282a)); // -2.4663e-12f, 6.53477e+16f, 4.76191e+16f, 5.7784e-19f, 4.78945e-34f
6950 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6951 path.close();
6952 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6953 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x03081f21), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x2147ed7a)); // 6.14991e+25f, 2.50338e-13f, 4.00025e-37f, 5.63611e+25f, 6.77381e-19f
6954 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6955 path.close();
6956 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6957 path.quadTo(SkBits2Float(0x2d28282a), SkBits2Float(0x5568295b), SkBits2Float(0x3a21df68), SkBits2Float(0x4f9a3a8a)); // 9.55861e-12f, 1.5954e+13f, 0.000617495f, 5.17506e+09f
6958 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6959 path.close();
6960 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6961 path.cubicTo(SkBits2Float(0x5568c23a), SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a), SkBits2Float(0x3a7bc003), SkBits2Float(0x294b2827)); // 1.59951e+13f, 4.87407e+16f, 5.7784e-19f, 4.61198e-19f, 0.00096035f, 4.51099e-14f
6963 SkPath path2(path);
6969 SkPath path;
6970 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
6971 path.close();
6972 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
6973 path.cubicTo(SkBits2Float(0xe3000000), SkBits2Float(0xf19e92c7), SkBits2Float(0xf17febcb), SkBits2Float(0xff7febcb), SkBits2Float(0x60600100), SkBits2Float(0x0100ff60)); // -2.36118e+21f, -1.57043e+30f, -1.26726e+30f, -3.40177e+38f, 6.45647e+19f, 2.36931e-38f
6974 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
6975 path.close();
6976 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
6977 path.lineTo(SkBits2Float(0x60601a1d), SkBits2Float(0x60606060)); // 6.4593e+19f, 6.46721e+19f
6978 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
6979 path.close();
6980 path.moveTo(SkBits2Float(0xe5e2f300), SkBits2Float(0xee244a40)); // -1.33967e+23f, -1.27113e+28f
6981 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
6982 path.close();
6983 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
6984 path.lineTo(SkBits2Float(0xfafafafa), SkBits2Float(0xe30000fa)); // -6.51582e+35f, -2.36125e+21f
6985 path.conicTo(SkBits2Float(0x92e592e5), SkBits2Float(0xfafafafb), SkBits2Float(0xc4fa0000), SkBits2Float(0x6060fafa), SkBits2Float(0x60606060)); // -1.44881e-27f, -6.51582e+35f, -2000, 6.48462e+19f, 6.46721e+19f
6986 path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
6987 path.close();
6988 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
6989 path.cubicTo(SkBits2Float(0xe3000000), SkBits2Float(0xf19e92c7), SkBits2Float(0xf17febcb), SkBits2Float(0xff7febcb), SkBits2Float(0xfafafa00), SkBits2Float(0xfafafafa)); // -2.36118e+21f, -1.57043e+30f, -1.26726e+30f, -3.40177e+38f, -6.51572e+35f, -6.51582e+35f
6990 path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
6991 path.close();
6992 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
6993 path.cubicTo(SkBits2Float(0xe3000000), SkBits2Float(0xe39e92c7), SkBits2Float(0xf17febcb), SkBits2Float(0xff7febcb), SkBits2Float(0xeed0ee9a), SkBits2Float(0x9a98ffca)); // -2.36118e+21f, -5.85032e+21f, -1.26726e+30f, -3.40177e+38f, -3.23307e+28f, -6.3279e-23f
6994 path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
6995 path.close();
6996 SkPath path2(path);
7001 SkPath path;
7002 path.setFillType((SkPath::FillType) 1);
7003 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 0, 4.03114e+24f
7004 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7005 path.quadTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 6.14991e+25f, 0, 0, 6.14991e+25f
7006 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 0, 4.03114e+24f
7007 path.close();
7009 SkPath path1(path);
7010 path.reset();
7011 path.setFillType((SkPath::FillType) 0);
7012 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7013 path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x2a8c8f55)); // 4.87407e+16f, 2.49685e-13f
7014 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7015 path.close();
7016 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
7017 path.conicTo(SkBits2Float(0x682d2fed), SkBits2Float(0x755b6829), SkBits2Float(0x5b292d2b), SkBits2Float(0xc92a8c55), SkBits2Float(0x081f2a21)); // 3.27141e+24f, 2.78131e+32f, 4.76189e+16f, -698565, 4.78968e-34f
7018 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
7019 path.close();
7020 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
7021 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a29)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121588
7022 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
7023 path.close();
7024 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
7025 path.quadTo(SkBits2Float(0x6829682d), SkBits2Float(0x292d555b), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a29)); // 3.20001e+24f, 3.84878e-14f, 2.49282e-13f, 4.78969e-34f
7026 path.conicTo(SkBits2Float(0x6a497b19), SkBits2Float(0x218ced7a), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x47ed3a7a)); // 6.08939e+25f, 9.54963e-19f, 4.7323e-37f, 5.63611e+25f, 121461
7027 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
7028 path.close();
7029 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
7030 path
7031 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3a3ac2b3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.000712435f, 1.50241e-13f, -1.38859e-25f
7032 path.lineTo(SkBits2Float(0x272a802a), SkBits2Float(0x2a8c2d29)); // 2.36617e-15f, 2.49003e-13f
7033 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
7034 path.close();
7035 path.moveTo(SkBits2Float(0x4f9a3a29), SkBits2Float(0x3ab38a28)); // 5.17501e+09f, 0.00136978f
7036 path.quadTo(SkBits2Float(0xc368305b), SkBits2Float(0x5b296855), SkBits2Float(0x2d8c5568), SkBits2Float(0x1f2a2172)); // -232.189f, 4.7684e+16f, 1.59541e-11f, 3.60266e-20f
7037 path.lineTo(SkBits2Float(0x29c00321), SkBits2Float(0x5b4b7b13)); // 8.52706e-14f, 5.72747e+16f
7039 SkPath path2(path);
7044 SkPath path;
7045 path.setFillType((SkPath::FillType) 0);
7047 SkPath path1(path);
7048 path.reset();
7049 path.setFillType((SkPath::FillType) 0);
7050 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7051 path.moveTo(SkBits2Float(0x2a0f312a), SkBits2Float(0xc0032108)); // 1.2718e-13f, -2.04889f
7052 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a1f2a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76395e-19f, 4.7323e-37f, 6.14991e+25f
7053 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7b21), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14984e+25f, 9.43289e-15f, 1.21279e-11f
7054 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f
7055 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0xef2a8c55), SkBits2Float(0x295b2d2a), SkBits2Float(0x08685568), SkBits2Float(0x7bc00321)); // 5.76397e-19f, -5.27821e+28f, 4.86669e-14f, 6.99154e-34f, 1.99397e+36f
7056 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f
7057 path.close();
7058 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f
7059 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7060 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7061 path.lineTo(SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a281a4f)); // 0.00105461f, -8.09385e-33f
7062 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x2a812a3b), SkBits2Float(0x2a552927)); // 2.25206e-21f, 300.343f, 2.29443e-13f, 1.89325e-13f
7063 path.quadTo(SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x203a3b27), SkBits2Float(0x22c5381f)); // 0.00241343f, 3.71093e-14f, 1.57744e-19f, 5.34564e-18f
7064 path.moveTo(SkBits2Float(0x5d27ec2a), SkBits2Float(0x705921c2)); // 7.56256e+17f, 2.68796e+29f
7065 path.quadTo(SkBits2Float(0x102a5152), SkBits2Float(0x5b2dd912), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 3.35892e-29f, 4.89338e+16f, 4.03114e+24f, 1.50617e+13f
7066 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032127)); // 3.60396e-20f, -2.0489f
7067 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0x2a8c684b), SkBits2Float(0xf05b272d), SkBits2Float(0x2a1f1555), SkBits2Float(0x21082a21), SkBits2Float(0x6a4b7b03)); // 3.4979e+24f, 2.49414e-13f, -2.71298e+29f, 1.41294e-13f, 4.61343e-19f, 6.14982e+25f
7068 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
7069 path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
7070 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0xef2a8c55), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -5.27821e+28f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f
7071 path.lineTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
7072 path.close();
7073 path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
7074 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x2a21211f)); // 4.85282e+16f, 1.43112e-13f
7075 path.lineTo(SkBits2Float(0x03552a8c), SkBits2Float(0x6a4f7b28)); // 6.26439e-37f, 6.27073e+25f
7076 path.conicTo(SkBits2Float(0x2347ed93), SkBits2Float(0x282a3a21), SkBits2Float(0x3adf2128), SkBits2Float(0x4f1a3a8a), SkBits2Float(0x3ab38a28)); // 1.08381e-17f, 9.4495e-15f, 0.00170234f, 2.58753e+09f, 0.00136978f
7077 path.lineTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
7078 path.close();
7079 path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
7080 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x262a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 5.91556e-16f, 0.000649768f
7081 path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f
7082 path.conicTo(SkBits2Float(0x371f203a), SkBits2Float(0xc52a22c4), SkBits2Float(0xc25d27ec), SkBits2Float(0x3a705921), SkBits2Float(0x5210513a)); // 9.48464e-06f, -2722.17f, -55.289f, 0.000916855f, 1.5496e+11f
7083 path.cubicTo(SkBits2Float(0x63102ad9), SkBits2Float(0x29c80927), SkBits2Float(0x633a27b0), SkBits2Float(0x2909c827), SkBits2Float(0x272927b1), SkBits2Float(0x3a685b2d)); // 2.65942e+21f, 8.88337e-14f, 3.43395e+21f, 3.05937e-14f, 2.3475e-15f, 0.000886368f
7084 path.moveTo(SkBits2Float(0x682d6829), SkBits2Float(0x29685555)); // 3.27556e+24f, 5.15884e-14f
7085 path.conicTo(SkBits2Float(0xaa8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x5b2d0321), SkBits2Float(0x68556829), SkBits2Float(0x5b2d2729)); // -2.49282e-13f, 4.78968e-34f, 4.86986e+16f, 4.03114e+24f, 4.87382e+16f
7086 path.quadTo(SkBits2Float(0x2d685568), SkBits2Float(0x5568295b), SkBits2Float(0x2a552d29), SkBits2Float(0x295b2d27)); // 1.32066e-11f, 1.5954e+13f, 1.89339e-13f, 4.86669e-14f
7087 path.lineTo(SkBits2Float(0x682d6829), SkBits2Float(0x29685555)); // 3.27556e+24f, 5.15884e-14f
7088 path.close();
7090 SkPath path2(path);
7095 SkPath path;
7096 path.setFillType((SkPath::FillType) 1);
7097 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7098 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a29082a)); // 0, 5.10868e+25f
7099 path.conicTo(SkBits2Float(0x6a295ac3), SkBits2Float(0x61bb988e), SkBits2Float(0x6829682d), SkBits2Float(0x5f3ba76a), SkBits2Float(0x42730a87)); // 5.11843e+25f, 4.32567e+20f, 3.20001e+24f, 1.35219e+19f, 60.7603f
7100 path.conicTo(SkBits2Float(0x67aedf99), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x3f801112)); // 1.65163e+24f, 0, 0, 0, 1.00052f
7101 path.close();
7102 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7103 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 6.14991e+25f, 0, 0, 4.03114e+24f, 1.50617e+13f
7104 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f
7105 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x67d55b2a), SkBits2Float(0x67296a4b), SkBits2Float(0x67555b2a), SkBits2Float(0x677e1f70), SkBits2Float(0x66d55b2a)); // 0, 2.01509e+24f, 8.00041e+23f, 1.00755e+24f, 1.20006e+24f, 5.03773e+23f
7106 path.cubicTo(SkBits2Float(0x678f0684), SkBits2Float(0x6684f008), SkBits2Float(0x6798f8ea), SkBits2Float(0x6625a942), SkBits2Float(0x67961914), SkBits2Float(0x65ce709a)); // 1.35084e+24f, 3.1389e+23f, 1.44478e+24f, 1.95578e+23f, 1.41764e+24f, 1.21861e+23f
7107 path.cubicTo(SkBits2Float(0x679158b0), SkBits2Float(0x00000000), SkBits2Float(0x67531e34), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 1.37276e+24f, 0, 9.96976e+23f, 0, 0, 0
7108 path.close();
7110 SkPath path1(path);
7111 path.reset();
7112 path.setFillType((SkPath::FillType) 0);
7113 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7114 path.conicTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003), SkBits2Float(0xed237a6a), SkBits2Float(0x2d682967), SkBits2Float(0x2a8c555b)); // 4.61198e-19f, 1.64987e+07f, -3.16213e+27f, 1.31969e-11f, 2.49282e-13f
7115 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7116 path.close();
7117 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7118 path.lineTo(SkBits2Float(0x3a6821df), SkBits2Float(0x2a8c3a8a)); // 0.000885514f, 2.49096e-13f
7119 path.moveTo(SkBits2Float(0x29272a1d), SkBits2Float(0xb03a2a55)); // 3.7118e-14f, -6.77266e-10f
7120 path.moveTo(SkBits2Float(0x20213b1e), SkBits2Float(0xc5272927)); // 1.36568e-19f, -2674.57f
7121 path.quadTo(SkBits2Float(0xc422373b), SkBits2Float(0xec2a201f), SkBits2Float(0x21c25d27), SkBits2Float(0x523a7059)); // -648.863f, -8.22676e+26f, 1.31706e-18f, 2.00187e+11f
7122 path.cubicTo(SkBits2Float(0x12102a10), SkBits2Float(0xe73a28d9), SkBits2Float(0xc8092763), SkBits2Float(0x2927b029), SkBits2Float(0x295b2d27), SkBits2Float(0x2d685568)); // 4.54902e-28f, -8.79114e+23f, -140446, 3.72342e-14f, 4.86669e-14f, 1.32066e-11f
7123 path.moveTo(SkBits2Float(0x68556809), SkBits2Float(0x555b2d29)); // 4.03113e+24f, 1.50617e+13f
7124 path.moveTo(SkBits2Float(0x1f2a212a), SkBits2Float(0x2d032108)); // 3.60263e-20f, 7.45382e-12f
7125 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x2a552d29)); // 4.03114e+24f, 1.89339e-13f
7126 path.cubicTo(SkBits2Float(0x21295b2d), SkBits2Float(0x2a528c5b), SkBits2Float(0x284f5b2d), SkBits2Float(0x218aa621), SkBits2Float(0x3f2d2db3), SkBits2Float(0x68293a2a)); // 5.73801e-19f, 1.87004e-13f, 1.15106e-14f, 9.39522e-19f, 0.676479f, 3.19661e+24f
7128 SkPath path2(path);
7133 SkPath path;
7134 path.setFillType((SkPath::FillType) 1);
7136 SkPath path1(path);
7137 path.reset();
7138 path.setFillType((SkPath::FillType) 0);
7139 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
7140 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0x3adf2128), SkBits2Float(0x4f1a3a8a)); // 6.14991e+25f, 75739, 9.4495e-15f, 0.00170234f, 2.58753e+09f
7141 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
7142 path.close();
7143 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
7144 path.cubicTo(SkBits2Float(0x3ac2213a), SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a8128), SkBits2Float(0x3a2a5529), SkBits2Float(0x3b1e2ab0)); // 0.00148109f, 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f, 0.00241343f
7145 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
7146 path.close();
7147 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
7148 path.cubicTo(SkBits2Float(0x3b272927), SkBits2Float(0x381f203a), SkBits2Float(0x2ac422c5), SkBits2Float(0xc25d27ec), SkBits2Float(0x3a705921), SkBits2Float(0x2a105152)); // 0.00255067f, 3.79386e-05f, 3.48407e-13f, -55.289f, 0.000916855f, 1.2818e-13f
7149 path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x68295b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.19905e+24f
7150 path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f
7151 path.conicTo(SkBits2Float(0xaa8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x5b2d0321), SkBits2Float(0x68556829), SkBits2Float(0x2a552d29)); // -2.49282e-13f, 4.78968e-34f, 4.86986e+16f, 4.03114e+24f, 1.89339e-13f
7152 path.cubicTo(SkBits2Float(0x21295b2d), SkBits2Float(0x2a688c5b), SkBits2Float(0x6829292d), SkBits2Float(0x2d296855), SkBits2Float(0x8c08555b), SkBits2Float(0x2a2a291f)); // 5.73801e-19f, 2.06544e-13f, 3.19536e+24f, 9.6297e-12f, -1.05027e-31f, 1.51133e-13f
7153 path.conicTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321)); // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f, 1.99397e+36f
7154 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
7155 path.close();
7156 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
7157 path.lineTo(SkBits2Float(0x5b2d6829), SkBits2Float(0x212a8c55)); // 4.88097e+16f, 5.7784e-19f
7158 path.conicTo(SkBits2Float(0x8ced7aba), SkBits2Float(0x3f2a212a), SkBits2Float(0x2d212d08), SkBits2Float(0x5568295b), SkBits2Float(0x29685b2d)); // -3.65895e-31f, 0.664569f, 9.16179e-12f, 1.5954e+13f, 5.15934e-14f
7159 path.lineTo(SkBits2Float(0x68295b68), SkBits2Float(0x2d296855)); // 3.19906e+24f, 9.6297e-12f
7160 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
7161 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x6aba7b03), SkBits2Float(0x2147ed7a)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 1.12721e+26f, 6.77381e-19f
7162 path.quadTo(SkBits2Float(0x6028282a), SkBits2Float(0x68292ddf), SkBits2Float(0x5b2d555b), SkBits2Float(0x68556829)); // 4.84679e+19f, 3.1957e+24f, 4.8789e+16f, 4.03114e+24f
7164 SkPath path2(path);
7169 SkPath path;
7170 path.setFillType((SkPath::FillType) 0);
7172 SkPath path1(path);
7173 path.reset();
7174 path.setFillType((SkPath::FillType) 0);
7175 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0xf45b2d29)); // 4.03114e+24f, -6.94598e+31f
7176 path.moveTo(SkBits2Float(0x1f2a302a), SkBits2Float(0xc8032108)); // 3.60387e-20f, -134276
7177 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf0db684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x302a5b25), SkBits2Float(0xf0685568)); // 3.4979e+24f, -5.43226e+29f, -1.64207e-31f, 5.76527e-19f, 6.19752e-10f, -2.87615e+29f
7179 SkPath path2(path);
7184 SkPath path;
7185 path.setFillType((SkPath::FillType) 1);
7187 SkPath path1(path);
7188 path.reset();
7189 path.setFillType((SkPath::FillType) 0);
7190 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55)); // 4.76191e+16f, 5.7784e-19f
7191 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f
7192 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x2c6829c0), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a29)); // 5.77848e-19f, 4.7323e-37f, 3.29924e-12f, 2.49282e-13f, 4.78969e-34f
7193 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f
7194 path.close();
7195 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f
7196 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0xdf218a28), SkBits2Float(0x4f1a3a3a)); // 6.14991e+25f, 75739, 9.4495e-15f, -1.16402e+19f, 2.58751e+09f
7197 path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x283ac221), SkBits2Float(0xe6432a29), SkBits2Float(0x2a96812b)); // 0.00136978f, 1.03672e-14f, -2.3041e+23f, 2.6735e-13f
7198 path.lineTo(SkBits2Float(0x5529272a), SkBits2Float(0x1eb03a2a)); // 1.16241e+13f, 1.86588e-20f
7199 path.conicTo(SkBits2Float(0x2a272021), SkBits2Float(0x3ac52729), SkBits2Float(0xc422313b), SkBits2Float(0xec2a201f), SkBits2Float(0x21c25d27)); // 1.48437e-13f, 0.00150416f, -648.769f, -8.22676e+26f, 1.31706e-18f
7200 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f
7201 path.close();
7202 path.moveTo(SkBits2Float(0x1051523a), SkBits2Float(0xd912102a)); // 4.12813e-29f, -2.56957e+15f
7203 path.close();
7204 path.moveTo(SkBits2Float(0x1051523a), SkBits2Float(0xd912102a)); // 4.12813e-29f, -2.56957e+15f
7205 path
7206 path.moveTo(SkBits2Float(0x68556809), SkBits2Float(0x8c555b2d)); // 4.03113e+24f, -1.64364e-31f
7207 path.moveTo(SkBits2Float(0x081f2a21), SkBits2Float(0x252d0321)); // 4.78968e-34f, 1.50064e-16f
7208 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x5b2df068)); // 1.59583e+13f, 4.89595e+16f
7209 path.quadTo(SkBits2Float(0x2a1f2a8c), SkBits2Float(0x21482a21), SkBits2Float(0x4b7bc003), SkBits2Float(0x8ced3a6a)); // 1.41368e-13f, 6.78184e-19f, 1.64987e+07f, -3.65508e-31f
7210 path.moveTo(SkBits2Float(0x21481f21), SkBits2Float(0x4b7bc003)); // 6.78038e-19f, 1.64987e+07f
7211 path.conicTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d155b2d), SkBits2Float(0x5568295b), SkBits2Float(0x5b2d2968), SkBits2Float(0x2a8c8f55)); // 3.20982e+24f, 8.48991e-12f, 1.5954e+13f, 4.87407e+16f, 2.49685e-13f
7212 path.lineTo(SkBits2Float(0x21481f21), SkBits2Float(0x4b7bc003)); // 6.78038e-19f, 1.64987e+07f
7213 path.close();
7214 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
7215 path.conicTo(SkBits2Float(0x682d2fed), SkBits2Float(0x755b6829), SkBits2Float(0x5b292d2b), SkBits2Float(0xc92a8c55), SkBits2Float(0x081f2a21)); // 3.27141e+24f, 2.78131e+32f, 4.76189e+16f, -698565, 4.78968e-34f
7216 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
7217 path.close();
7218 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
7219 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x212aed7a), SkBits2Float(0x0321081f), SkBits2Float(0x293a7bc0), SkBits2Float(0x2147ed7a)); // 6.14991e+25f, 5.79125e-19f, 4.7323e-37f, 4.14076e-14f, 6.77381e-19f
7220 path.quadTo(SkBits2Float(0x6829682d), SkBits2Float(0x292d555b), SkBits2Float(0x292a8c55), SkBits2Float(0x21081f2a)); // 3.20001e+24f, 3.84878e-14f, 3.78693e-14f, 4.61198e-19f
7221 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x218ced7a), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x47ed3a7a)); // 6.14991e+25f, 9.54963e-19f, 4.7323e-37f, 5.63611e+25f, 121461
7222 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
7223 path.close();
7224 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
7225 path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3a21df), SkBits2Float(0x2728282a), SkBits2Float(0x8a3a21df)); // 9.4456e-15f, -8.96194e-33f, 2.33365e-15f, -8.96194e-33f
7226 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3a3ac2b3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.000712435f, 1.50241e-13f, -1.38859e-25f
7227 path.lineTo(SkBits2Float(0x272a802a), SkBits2Float(0x2a8c2d29)); // 2.36617e-15f, 2.49003e-13f
7228 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
7229 path.close();
7230 path.moveTo(SkBits2Float(0x4f9a3a29), SkBits2Float(0x3ab38a28)); // 5.17501e+09f, 0.00136978f
7231 path.quadTo(SkBits2Float(0xc368305b), SkBits2Float(0x5b296855), SkBits2Float(0x2d8c5568), SkBits2Float(0x1f2a2172)); // -232.189f, 4.7684e+16f, 1.59541e-11f, 3.60266e-20f
7232 path.lineTo(SkBits2Float(0x29c00321), SkBits2Float(0x5b4b7b13)); // 8.52706e-14f, 5.72747e+16f
7234 SkPath path2(path);
7239 SkPath path;
7240 path.setFillType((SkPath::FillType) 0);
7242 SkPath path1(path);
7243 path.reset();
7244 path.setFillType((SkPath::FillType) 0);
7245 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7246 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7247 path.cubicTo(SkBits2Float(0x68372d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c552775), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.46012e+24f, -2.71613e+29f, -1.64208e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7248 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f
7249 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
7250 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f
7251 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
7252 path.close();
7253 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
7254 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7255 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7256 path.conicTo(SkBits2Float(0x68385b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.48239e+24f, 1.51141e+13f, 1.41368e-13f, 4.7362e-37f, 1.43189e+16f
7257 path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f
7258 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7259 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 1.31626e+28f, 4.7323e-37f, 6.14991e+25f, 75739
7260 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7261 path.close();
7262 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7263 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f
7264 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7265 path.close();
7266 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7267 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
7268 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7269 path.close();
7270 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7271 path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x681aed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 2.92648e+24f, 1.46617e+13f, 9.01175e-21f
7272 path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2769), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21512727)); // 2.22225e-15f, 0.000713936f, -732.486f, -1.90686e+27f, 7.08638e-19f
7273 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7274 path.close();
7275 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
7276 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7277 path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0xc0032108)); // 3.60404e-20f, -2.04889f
7278 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05bd24b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0xed4b7bc0)); // 4.06458e+24f, -2.72126e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, -3.93594e+27f
7279 path.conicTo(SkBits2Float(0x212a8c6a), SkBits2Float(0x0329081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77841e-19f, 4.9674e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
7280 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
7281 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f
7282 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
7283 path.close();
7284 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
7285 path.lineTo(SkBits2Float(0x555b6829), SkBits2Float(0x6c212a8c)); // 1.50775e+13f, 7.79352e+26f
7286 path.conicTo(SkBits2Float(0x084b0321), SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a), SkBits2Float(0x5bf05568), SkBits2Float(0x212a3a8c)); // 6.10918e-34f, 1.16348e+26f, 0.000209024f, 1.35296e+17f, 5.76757e-19f
7287 path.lineTo(SkBits2Float(0x8c558c55), SkBits2Float(0x212a1f2a)); // -1.64512e-31f, 5.76395e-19f
7289 SkPath path2(path);
7294 SkPath path;
7295 path.setFillType((SkPath::FillType) 0);
7297 SkPath path1(path);
7298 path.reset();
7299 path.setFillType((SkPath::FillType) 0);
7300 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7301 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7302 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7303 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f
7304 path.moveTo(SkBits2Float(0x6835282d), SkBits2Float(0xf0682955)); // 3.42196e+24f, -2.87402e+29f
7305 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef552a), SkBits2Float(0x68295b2d), SkBits2Float(0x08682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 4.2514e-13f, 3.19905e+24f, 6.98538e-34f, 1.64988e+07f
7306 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7307 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7308 path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, 1.51141e+13f, 1.41368e-13f, 4.7362e-37f, 1.43189e+16f
7309 path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f
7310 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7311 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x212a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x254793ed)); // 2.49282e-13f, 5.76399e-19f, 4.7323e-37f, 6.14991e+25f, 1.73106e-16f
7312 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
7313 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
7314 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7315 path.close();
7316 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7317 path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f
7318 path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0x16c52a22), SkBits2Float(0x515d27ec)); // 2.22225e-15f, 0.000713932f, -732.486f, 3.18537e-25f, 5.93661e+10f
7319 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7320 path.close();
7321 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
7322 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7323 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7324 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7325 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
7326 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7327 path.lineTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x2a212a1f)); // 2.49282e-13f, 1.43143e-13f
7328 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7329 path.close();
7330 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7331 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x2a1f08c0)); // -1.31678e-31f, 1.41251e-13f
7332 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7333 path.close();
7334 path.moveTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f
7335 path.conicTo(SkBits2Float(0x55086821), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x5b2c6829), SkBits2Float(0x21218c55), SkBits2Float(0x2a6c1f03)); // 9.3738e+12f, 6.14991e+25f, 4.85282e+16f, 5.47346e-19f, 2.09718e-13f
7336 path.lineTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f
7337 path.close();
7338 path.moveTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f
7339 path.lineTo(SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a)); // 1.16348e+26f, 0.000209024f
7341 SkPath path2(path);
7346 SkPath path;
7347 path.setFillType((SkPath::FillType) 0);
7349 SkPath path1(path);
7350 path.reset();
7351 path.setFillType((SkPath::FillType) 0);
7352 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7353 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7354 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7355 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f
7356 path.moveTo(SkBits2Float(0x6835282d), SkBits2Float(0xf0682955)); // 3.42196e+24f, -2.87402e+29f
7357 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef552a), SkBits2Float(0x68295b2d), SkBits2Float(0x08682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 4.2514e-13f, 3.19905e+24f, 6.98538e-34f, 1.64988e+07f
7358 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7359 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7360 path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, 1.51141e+13f, 1.41368e-13f, 4.7362e-37f, 1.43189e+16f
7361 path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f
7362 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7363 path
7364 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
7365 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
7366 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7367 path.close();
7368 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7369 path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f
7370 path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0x16c52a22), SkBits2Float(0x515d27ec)); // 2.22225e-15f, 0.000713932f, -732.486f, 3.18537e-25f, 5.93661e+10f
7371 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7372 path.close();
7373 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
7374 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7375 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7376 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7377 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
7378 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7379 path.lineTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x2a212a1f)); // 2.49282e-13f, 1.43143e-13f
7380 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7381 path.close();
7382 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7383 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x2a1f08c0)); // -1.31678e-31f, 1.41251e-13f
7385 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
7386 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7387 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7388 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7389 path.conicTo(SkBits2Float(0x2a8c54ed), SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003), SkBits2Float(0x29ed846a), SkBits2Float(0x555b2d28)); // 2.49279e-13f, 4.61198e-19f, 1.64987e+07f, 1.05479e-13f, 1.50617e+13f
7390 path.conicTo(SkBits2Float(0x68392d5b), SkBits2Float(0xf0682955), SkBits2Float(0x2a1f5b2d), SkBits2Float(0xef552a21), SkBits2Float(0x5b2d2a8c)); // 3.4979e+24f, -2.87402e+29f, 1.41537e-13f, -6.59712e+28f, 4.8742e+16f
7392 SkPath path2(path);
7397 SkPath path;
7398 path.setFillType((SkPath::FillType) 1);
7400 SkPath path1(path);
7401 path.reset();
7402 path.setFillType((SkPath::FillType) 0);
7403 path.moveTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003)); // 4.61198e-19f, 1.64987e+07f
7404 path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 9.43289e-15f, 1.61207e+25f
7405 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
7406 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef552a), SkBits2Float(0x68295b2d), SkBits2Float(0x08682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 4.2514e-13f, 3.19905e+24f, 6.98538e-34f, 1.64988e+07f
7407 path.moveTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7408 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7409 path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x8c5bf055), SkBits2Float(0x2a1f2a55), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, -1.69435e-31f, 1.41367e-13f, 4.7362e-37f, 1.43189e+16f
7410 path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f
7411 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7412 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x212a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2547937a)); // 2.49282e-13f, 5.76399e-19f, 4.7323e-37f, 6.14991e+25f, 1.73105e-16f
7413 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
7414 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
7415 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7416 path.close();
7417 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7418 path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f
7419 path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21515d27)); // 2.22225e-15f, 0.000713932f, -732.486f, -1.90686e+27f, 7.09352e-19f
7420 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7421 path.close();
7422 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
7423 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7424 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7425 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7426 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
7427 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7428 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f
7429 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7430 path.close();
7431 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7432 path.lineTo(SkBits2Float(0x555b2c29), SkBits2Float(0x6c212a8c)); // 1.50614e+13f, 7.79352e+26f
7433 path.conicTo(SkBits2Float(0x084b0321), SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a), SkBits2Float(0xf05b5568), SkBits2Float(0x212a3a8c)); // 6.10918e-34f, 1.16348e+26f, 0.000209024f, -2.71522e+29f, 5.76757e-19f
7434 path.conicTo(SkBits2Float(0x290321d9), SkBits2Float(0x555b2d68), SkBits2Float(0x2a8c558c), SkBits2Float(0x2abe2a1f), SkBits2Float(0x7bc00321)); // 2.91172e-14f, 1.50618e+13f, 2.49284e-13f, 3.378e-13f, 1.99397e+36f
7435 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7436 path.close();
7437 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7438 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x1f2128c0)); // -1.31678e-31f, 3.41268e-20f
7439 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7440 path.close();
7442 SkPath path2(path);
7447 SkPath path;
7448 path.setFillType((SkPath::FillType) 0);
7450 SkPath path1(path);
7451 path.reset();
7452 path.setFillType((SkPath::FillType) 0);
7453 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7454 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7455 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7456 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f
7457 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
7458 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2a8c552a), SkBits2Float(0x68295b2d), SkBits2Float(0x08682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 2.49281e-13f, 3.19905e+24f, 6.98538e-34f, 1.64988e+07f
7459 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7460 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7461 path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, 1.51141e+13f, 1.41368e-13f, 4.7362e-37f, 1.43189e+16f
7462 path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f
7463 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7464 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321182a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 1.31626e+28f, 4.73414e-37f, 6.14991e+25f, 75739
7465 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7466 path.close();
7467 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7468 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f
7469 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7470 path.close();
7471 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7472 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
7473 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7474 path.close();
7475 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7476 path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f
7477 path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2769), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x51282727)); // 2.22225e-15f, 0.000713936f, -732.486f, -1.90686e+27f, 4.51382e+10f
7478 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7479 path.close();
7480 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
7481 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x8c555b2d)); // 4.03114e+24f, -1.64364e-31f
7482 path.moveTo(SkBits2Float(0x081f2a31), SkBits2Float(0xc0032921)); // 4.78969e-34f, -2.04939f
7483 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05bd24b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0xed4b7bc0)); // 4.06458e+24f, -2.72126e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, -3.93594e+27f
7484 path.conicTo(SkBits2Float(0x212a8c6a), SkBits2Float(0x4329081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 5.77841e-19f, 169.032f, 6.14991e+25f, 9.43289e-15f, 4.8745e+16f
7485 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7486 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x3a210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 0.000614217f, 1.99729e+36f
7487 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7488 path.close();
7489 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7490 path.lineTo(SkBits2Float(0x555b6829), SkBits2Float(0x6c212a8c)); // 1.50775e+13f, 7.79352e+26f
7491 path.lineTo(SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556830)); // 4.88298e+16f, -2.64185e+29f
7492 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7493 path.close();
7494 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7495 path.conicTo(SkBits2Float(0x0321d90a), SkBits2Float(0x555b2d68), SkBits2Float(0x2a8c558c), SkBits2Float(0x212a2a1f), SkBits2Float(0x4b7bc003)); // 4.75628e-37f, 1.50618e+13f, 2.49284e-13f, 5.7654e-19f, 1.64987e+07f
7496 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x212128c0)); // -1.31678e-31f, 5.46029e-19f
7497 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7498 path.close();
7500 SkPath path2(path);
7505 SkPath path;
7506 path.setFillType((SkPath::FillType) 1);
7507 path.moveTo(SkBits2Float(0x6828c6f9), SkBits2Float(0x6614dc9e)); // 3.18811e+24f, 1.75745e+23f
7508 path.cubicTo(SkBits2Float(0x68303469), SkBits2Float(0x661f92fc), SkBits2Float(0x6837d3c3), SkBits2Float(0x662b0eb2), SkBits2Float(0x683fa268), SkBits2Float(0x663759e1)); // 3.32841e+24f, 1.88392e+23f, 3.4724e+24f, 2.01949e+23f, 3.61987e+24f, 2.16463e+23f
7509 path.cubicTo(SkBits2Float(0x68c4391f), SkBits2Float(0x672c5c9f), SkBits2Float(0x688b20ab), SkBits2Float(0x6804b825), SkBits2Float(0x681ddb5e), SkBits2Float(0x6838dc00)); // 7.4131e+24f, 8.13956e+23f, 5.25609e+24f, 2.507e+24f, 2.98183e+24f, 3.49189e+24f
7510 path.lineTo(SkBits2Float(0x6828c6f9), SkBits2Float(0x6614dc9e)); // 3.18811e+24f, 1.75745e+23f
7511 path.close();
7512 path.moveTo(SkBits2Float(0x68226c73), SkBits2Float(0x660bd15e)); // 3.0681e+24f, 1.65068e+23f
7513 path.cubicTo(SkBits2Float(0x6823b0e1), SkBits2Float(0x660d990f), SkBits2Float(0x6824f6d5), SkBits2Float(0x660f668c), SkBits2Float(0x68263e4e), SkBits2Float(0x66113632)); // 3.09203e+24f, 1.67169e+23f, 3.11609e+24f, 1.69298e+23f, 3.14025e+24f, 1.71436e+23f
7514 path.cubicTo(SkBits2Float(0x682715e4), SkBits2Float(0x6612676d), SkBits2Float(0x6827ee22), SkBits2Float(0x66139997), SkBits2Float(0x6828c709), SkBits2Float(0x6614cba5)); // 3.15616e+24f, 1.72843e+23f, 3.17211e+24f, 1.74255e+23f, 3.18812e+24f, 1.75667e+23f
7515 path.lineTo(SkBits2Float(0x6828d720), SkBits2Float(0x6604a1a2)); // 3.1893e+24f, 1.56583e+23f
7516 path.cubicTo(SkBits2Float(0x68270421), SkBits2Float(0x6601102c), SkBits2Float(0x68252b97), SkBits2Float(0x65fb1edd), SkBits2Float(0x68234ce5), SkBits2Float(0x65f4367f)); // 3.15485e+24f, 1.52371e+23f, 3.11998e+24f, 1.48235e+23f, 3.08466e+24f, 1.44158e+23f
7517 path
7518 path.close();
7519 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f
7520 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f
7521 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x68617414), SkBits2Float(0x66af1c42), SkBits2Float(0x68624f96), SkBits2Float(0x6757755b), SkBits2Float(0x685b93f2)); // 0, 4.25869e+24f, 4.13468e+23f, 4.27489e+24f, 1.01747e+24f, 4.14771e+24f
7522 path.cubicTo(SkBits2Float(0x67a63a84), SkBits2Float(0x68fe1c37), SkBits2Float(0x67c05eed), SkBits2Float(0x69930962), SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 1.56998e+24f, 9.60001e+24f, 1.81689e+24f, 2.22196e+25f, 0, 5.14279e+25f
7523 path.close();
7524 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f
7525 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f
7526 path.cubicTo(SkBits2Float(0x6a2c8798), SkBits2Float(0x68f7a144), SkBits2Float(0x6951f5ea), SkBits2Float(0x6796ad55), SkBits2Float(0x683fa268), SkBits2Float(0x663759e1)); // 5.21439e+25f, 9.35519e+24f, 1.58642e+25f, 1.4231e+24f, 3.61987e+24f, 2.16463e+23f
7527 path.cubicTo(SkBits2Float(0x683871e3), SkBits2Float(0x66253b4f), SkBits2Float(0x6830da01), SkBits2Float(0x66144d3e), SkBits2Float(0x6828d720), SkBits2Float(0x6604a1a2)); // 3.48407e+24f, 1.95071e+23f, 3.34063e+24f, 1.75084e+23f, 3.1893e+24f, 1.56583e+23f
7528 path.conicTo(SkBits2Float(0x68295b21), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x492bb324)); // 3.19904e+24f, 0, 0, 0, 703282
7529 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x677b84f0), SkBits2Float(0x00000000), SkBits2Float(0x68226c73), SkBits2Float(0x660bd15e)); // 0, 0, 1.18777e+24f, 0, 3.0681e+24f, 1.65068e+23f
7530 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68156829)); // 0, 2.82222e+24f
7531 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f
7532 path.lineTo(SkBits2Float(0x673918f3), SkBits2Float(0x681b0f5f)); // 8.74098e+23f, 2.929e+24f
7533 path.lineTo(SkBits2Float(0x67391759), SkBits2Float(0x681b0fae)); // 8.74068e+23f, 2.92902e+24f
7534 path.cubicTo(SkBits2Float(0x674384e7), SkBits2Float(0x682e2068), SkBits2Float(0x674db698), SkBits2Float(0x6843893b), SkBits2Float(0x6757755b), SkBits2Float(0x685b93f2)); // 9.23313e+23f, 3.28916e+24f, 9.71453e+23f, 3.69357e+24f, 1.01747e+24f, 4.14771e+24f
7535 path.cubicTo(SkBits2Float(0x67a63484), SkBits2Float(0x68556bdd), SkBits2Float(0x67f18c5f), SkBits2Float(0x6848eb25), SkBits2Float(0x681ddb5e), SkBits2Float(0x6838dc00)); // 1.56976e+24f, 4.03142e+24f, 2.28136e+24f, 3.79524e+24f, 2.98183e+24f, 3.49189e+24f
7536 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f
7537 path.close();
7539 SkPath path1(path);
7540 path.reset();
7541 path.setFillType((SkPath::FillType) 0);
7543 SkPath path2(path);
7548 SkPath path;
7549 path.setFillType((SkPath::FillType) 1);
7550 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x68295b2d)); // 0, 3.19905e+24f
7551 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7552 path.lineTo(SkBits2Float(0x6a3a7bc0), SkBits2Float(0x00000000)); // 5.63611e+25f, 0
7553 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a034b21)); // 0, 3.9681e+25f
7554 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68295b2d)); // 0, 3.19905e+24f
7555 path.close();
7556 path.moveTo(SkBits2Float(0x6617da56), SkBits2Float(0x00000000)); // 1.79276e+23f, 0
7557 path.conicTo(SkBits2Float(0x5e704d09), SkBits2Float(0x5e3a4dfd), SkBits2Float(0x00000000), SkBits2Float(0x65eb62ef), SkBits2Float(0x430fa5e6)); // 4.32888e+18f, 3.35617e+18f, 0, 1.38948e+23f, 143.648f
7558 path.conicTo(SkBits2Float(0x5e798b32), SkBits2Float(0x627a95c0), SkBits2Float(0x61f5014c), SkBits2Float(0x61fba0fd), SkBits2Float(0x40f8a1a1)); // 4.49538e+18f, 1.15562e+21f, 5.64943e+20f, 5.80217e+20f, 7.76973f
7559 path.conicTo(SkBits2Float(0x62743d2d), SkBits2Float(0x5e49b862), SkBits2Float(0x6617da56), SkBits2Float(0x00000000), SkBits2Float(0x410ef54c)); // 1.12635e+21f, 3.63387e+18f, 1.79276e+23f, 0, 8.93489f
7560 path.close();
7562 SkPath path1(path);
7563 path.reset();
7564 path.setFillType((SkPath::FillType) 0);
7565 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7566 path.quadTo(SkBits2Float(0x4f9a3a8a), SkBits2Float(0xc28a0d28), SkBits2Float(0x273a3ab3), SkBits2Float(0x8b2a2928)); // 5.17506e+09f, -69.0257f, 2.58445e-15f, -3.27718e-32f
7567 path.lineTo(SkBits2Float(0x63283ae6), SkBits2Float(0x27282a81)); // 3.1033e+21f, 2.33377e-15f
7569 SkPath path2(path);
7574 SkPath path;
7575 path.setFillType((SkPath::FillType) 0);
7577 SkPath path1(path);
7578 path.reset();
7579 path.setFillType((SkPath::FillType) 0);
7580 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7581 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7582 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x03210c2a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.73276e-37f, 6.14991e+25f
7583 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f
7584 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
7585 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef552a), SkBits2Float(0x29295b2d), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, 4.2514e-13f, 3.76046e-14f, 3.04146e+24f, 1.99729e+36f
7586 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
7587 path.close();
7588 path.moveTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7589 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7590 path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x8c5bf055), SkBits2Float(0x2a1f2a55), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, -1.69435e-31f, 1.41367e-13f, 4.7362e-37f, 1.43189e+16f
7591 path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f
7592 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7593 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x08211f72), SkBits2Float(0x032a2a21), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2547937a)); // 2.49282e-13f, 4.84861e-34f, 5.00069e-37f, 6.14991e+25f, 1.73105e-16f
7594 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
7595 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
7596 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7597 path.close();
7598 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7599 path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f
7600 path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21515d27)); // 2.22225e-15f, 0.000713932f, -732.486f, -1.90686e+27f, 7.09352e-19f
7601 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7602 path.close();
7603 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
7604 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7605 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7606 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7607 path.conicTo(SkBits2Float(0x2a8c54ed), SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003), SkBits2Float(0x29ed846a), SkBits2Float(0x555b2d28)); // 2.49279e-13f, 4.61198e-19f, 1.64987e+07f, 1.05479e-13f, 1.50617e+13f
7608 path.conicTo(SkBits2Float(0x68392d5b), SkBits2Float(0xf0682955), SkBits2Float(0x2a1f5b2d), SkBits2Float(0xef552a21), SkBits2Float(0x5b2d2a8c)); // 3.4979e+24f, -2.87402e+29f, 1.41537e-13f, -6.59712e+28f, 4.8742e+16f
7610 SkPath path2(path);
7615 SkPath path;
7616 path.setFillType((SkPath::FillType) 1);
7618 SkPath path1(path);
7619 path.reset();
7620 path.setFillType((SkPath::FillType) 0);
7621 path.moveTo(SkBits2Float(0xededed02), SkBits2Float(0xedededed)); // -9.20431e+27f, -9.20445e+27f
7622 path.close();
7623 path.moveTo(SkBits2Float(0xededed02), SkBits2Float(0xedededed)); // -9.20431e+27f, -9.20445e+27f
7624 path.quadTo(SkBits2Float(0x9fb9c16e), SkBits2Float(0x27737375), SkBits2Float(0xb7c5ff00), SkBits2Float(0x00ff9908)); // -7.86706e-20f, 3.37856e-15f, -2.3603e-05f, 2.34729e-38f
7625 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7626 path.cubicTo(SkBits2Float(0x1616ecec), SkBits2Float(0x2c321616), SkBits2Float(0x3516c616), SkBits2Float(0x6e161616), SkBits2Float(0x4c416033), SkBits2Float(0xf6000000)); // 1.21917e-25f, 2.53076e-12f, 5.61676e-07f, 1.16124e+28f, 5.06923e+07f, -6.49037e+32f
7627 path.quadTo(SkBits2Float(0x04007f41), SkBits2Float(0xecececec), SkBits2Float(0xecececec), SkBits2Float(0xecec41ec)); // 1.51048e-36f, -2.2914e+27f, -2.2914e+27f, -2.28494e+27f
7628 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7629 path.close();
7630 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7631 path.quadTo(SkBits2Float(0x000000ec), SkBits2Float(0xececcc00), SkBits2Float(0x48ececec), SkBits2Float(0x0278806e)); // 3.30706e-43f, -2.29016e+27f, 485223, 1.8257e-37f
7632 path.lineTo(SkBits2Float(0x72ececec), SkBits2Float(0xecec02ec)); // 9.38559e+30f, -2.28256e+27f
7633 path.quadTo(SkBits2Float(0xec04007f), SkBits2Float(0xecececec), SkBits2Float(0xecececec), SkBits2Float(0xecec0400)); // -6.38322e+26f, -2.2914e+27f, -2.2914e+27f, -2.2826e+27f
7634 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7635 path.close();
7636 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7637 path.quadTo(SkBits2Float(0x000040ec), SkBits2Float(0x3a333300), SkBits2Float(0xecec3333), SkBits2Float(0xececdbec)); // 2.32896e-41f, 0.000683591f, -2.28439e+27f, -2.29076e+27f
7638 path.lineTo(SkBits2Float(0x3300007f), SkBits2Float(0x33d83333)); // 2.98028e-08f, 1.00676e-07f
7639 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7640 path.close();
7641 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7642 path.quadTo(SkBits2Float(0x9e9ea900), SkBits2Float(0x33ececec), SkBits2Float(0xececec33), SkBits2Float(0xec336e6e)); // -1.67988e-20f, 1.10327e-07f, -2.29138e+27f, -8.67677e+26f
7643 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7644 path.close();
7645 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7646 path.lineTo(SkBits2Float(0xedededed), SkBits2Float(0xedededed)); // -9.20445e+27f, -9.20445e+27f
7647 path.lineTo(SkBits2Float(0xecececec), SkBits2Float(0xecececec)); // -2.2914e+27f, -2.2914e+27f
7648 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7649 path.close();
7650 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7651 path.lineTo(SkBits2Float(0x01003300), SkBits2Float(0x33d83333)); // 2.35465e-38f, 1.00676e-07f
7652 path.quadTo(SkBits2Float(0xecec3333), SkBits2Float(0x04eeedec), SkBits2Float(0xe0e0e0e0), SkBits2Float(0x9ee0e0e0)); // -2.28439e+27f, 5.6172e-36f, -1.29634e+20f, -2.38099e-20f
7653 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7654 path.close();
7655 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7656 path.cubicTo(SkBits2Float(0x299e9e9e), SkBits2Float(0xecececec), SkBits2Float(0xececb6ec), SkBits2Float(0xf0ececec), SkBits2Float(0x0000ecec), SkBits2Float(0x9ebe6e6e)); // 7.04413e-14f, -2.2914e+27f, -2.28936e+27f, -5.86599e+29f, 8.49916e-41f, -2.01627e-20f
7657 path.cubicTo(SkBits2Float(0x9e9e9e9e), SkBits2Float(0xe8009e9e), SkBits2Float(0x9e9e9e9e), SkBits2Float(0xecec9e9e), SkBits2Float(0xec3333ec), SkBits2Float(0xececf0ec)); // -1.67945e-20f, -2.42956e+24f, -1.67945e-20f, -2.28844e+27f, -8.66572e+26f, -2.29155e+27f
7659 SkPath path2(path);
7664 SkPath path;
7665 path.setFillType((SkPath::FillType) 1);
7666 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f
7667 path.conicTo(SkBits2Float(0x653140d9), SkBits2Float(0x6a4b4f74), SkBits2Float(0x65906630), SkBits2Float(0x6a25a070), SkBits2Float(0x3f6728a2)); // 5.23159e+22f, 6.14468e+25f, 8.52382e+22f, 5.00576e+25f, 0.902964f
7668 path.cubicTo(SkBits2Float(0x68295bc5), SkBits2Float(0x00000000), SkBits2Float(0x682958ff), SkBits2Float(0x00000000), SkBits2Float(0x68286829), SkBits2Float(0x00000000)); // 3.19909e+24f, 0, 3.19889e+24f, 0, 3.18112e+24f, 0
7669 path.lineTo(SkBits2Float(0x68555b29), SkBits2Float(0x00000000)); // 4.03018e+24f, 0
7670 path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x682d2927), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6829686f)); // 0, 3.27091e+24f, 0, 0, 3.20003e+24f
7671 path.lineTo(SkBits2Float(0xdf218a28), SkBits2Float(0x00000000)); // -1.16402e+19f, 0
7672 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f
7673 path.close();
7674 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7675 path.conicTo(SkBits2Float(0x6642c40c), SkBits2Float(0x00000000), SkBits2Float(0x65906630), SkBits2Float(0x6a25a070), SkBits2Float(0x3edcd74d)); // 2.29939e+23f, 0, 8.52382e+22f, 5.00576e+25f, 0.43133f
7676 path.conicTo(SkBits2Float(0x68295afa), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x4277a57b)); // 3.19903e+24f, 0, 0, 0, 61.9116f
7677 path.close();
7679 SkPath path1(path);
7680 path.reset();
7681 path.setFillType((SkPath::FillType) 0);
7683 SkPath path2(path);
7689 SkPath path;
7690 path.setFillType((SkPath::FillType) 0);
7692 SkPath path1(path);
7693 path.reset();
7694 path.setFillType((SkPath::FillType) 0);
7695 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7696 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc003210a)); // 3.60396e-20f, -2.04889f
7697 path.cubicTo(SkBits2Float(0x68372d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.46012e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7698 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f
7699 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
7700 path
7701 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
7702 path.close();
7703 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
7704 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7705 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7706 path.conicTo(SkBits2Float(0x68385b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212121), SkBits2Float(0x5a4b7bc0)); // 3.48239e+24f, 1.51141e+13f, 1.41368e-13f, 4.73517e-37f, 1.43189e+16f
7707 path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f
7708 path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
7709 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 1.31626e+28f, 4.7323e-37f, 6.14991e+25f, 75739
7710 path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
7711 path.close();
7712 path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
7713 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f
7714 path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
7715 path.close();
7716 path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
7717 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2127ed29)); // 2.25206e-21f, 300.343f, 0.000650423f, 5.68957e-19f
7718 path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f
7719 path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2769), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21512727)); // 2.22225e-15f, 0.000713936f, -732.486f, -1.90686e+27f, 7.08638e-19f
7720 path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
7721 path.close();
7722 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
7723 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x5b2d5529)); // 4.03114e+24f, 4.87888e+16f
7724 path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0xc0032108)); // 3.60404e-20f, -2.04889f
7725 path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05bd24b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0xed4b7bc0)); // 4.06458e+24f, -2.72126e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, -3.93594e+27f
7726 path.conicTo(SkBits2Float(0x212a8c6a), SkBits2Float(0x0329081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77841e-19f, 4.9674e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
7727 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
7728 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f
7729 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
7730 path.close();
7731 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
7732 path.lineTo(SkBits2Float(0x555b1b29), SkBits2Float(0x6c212a8c)); // 1.50569e+13f, 7.79352e+26f
7733 path.conicTo(SkBits2Float(0x084b0321), SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a), SkBits2Float(0x8c5bf055), SkBits2Float(0x1f212a3a)); // 6.10918e-34f, 1.16348e+26f, 0.000209024f, -1.69435e-31f, 3.4128e-20f
7734 path.conicTo(SkBits2Float(0x290321d9), SkBits2Float(0x555b2d68), SkBits2Float(0x2a8c558c), SkBits2Float(0x2a212a1f), SkBits2Float(0x7bc00321)); // 2.91172e-14f, 1.50618e+13f, 2.49284e-13f, 1.43143e-13f, 1.99397e+36f
7735 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
7736 path.close();
7737 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
7738 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x1f2128c0)); // -1.31678e-31f, 3.41268e-20f
7739 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
7740 path.close();
7742 SkPath path2(path);
7747 SkPath path;
7748 path.setFillType((SkPath::FillType) 0);
7750 SkPath path1(path);
7751 path.reset();
7752 path.setFillType((SkPath::FillType) 0);
7753 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7754 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7755 path.cubicTo(SkBits2Float(0x68302d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a1f2a), SkBits2Float(0x0321082a), SkBits2Float(0x6aa37bc0)); // 3.32789e+24f, -2.71613e+29f, -1.64207e-31f, 5.76395e-19f, 4.7323e-37f, 9.88197e+25f
7756 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2d28ed84), SkBits2Float(0x5b2d2955)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.60243e-12f, 4.87406e+16f
7757 path.moveTo(SkBits2Float(0x6c395b2d), SkBits2Float(0xf0682955)); // 8.96327e+26f, -2.87402e+29f
7758 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef8c55), SkBits2Float(0x68295b2d), SkBits2Float(0x21086855), SkBits2Float(0x4b7bc003)); // 5.76397e-19f, 4.25523e-13f, 3.19905e+24f, 4.62167e-19f, 1.64987e+07f
7759 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7760 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7761 path.lineTo(SkBits2Float(0x8a283a28), SkBits2Float(0x284f1a3a)); // -8.09984e-33f, 1.14965e-14f
7762 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f
7763 path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f
7764 path.conicTo(SkBits2Float(0x381f203a), SkBits2Float(0x2ac422c5), SkBits2Float(0xc25d27ec), SkBits2Float(0x3a705921), SkBits2Float(0x2a105152)); // 3.79386e-05f, 3.48407e-13f, -55.289f, 0.000916855f, 1.2818e-13f
7765 path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x683a5b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.52017e+24f
7766 path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f
7767 path.conicTo(SkBits2Float(0xaa8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x5b2d0321), SkBits2Float(0x68556829), SkBits2Float(0x2a552d29)); // -2.49282e-13f, 4.78968e-34f, 4.86986e+16f, 4.03114e+24f, 1.89339e-13f
7768 path.cubicTo(SkBits2Float(0x21295b2d), SkBits2Float(0x2a688c5b), SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x8c08555b), SkBits2Float(0x2a2a29ca)); // 5.73801e-19f, 2.06544e-13f, 3.19905e+24f, 9.6297e-12f, -1.05027e-31f, 1.51135e-13f
7769 path.quadTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f
7770 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7771 path.close();
7772 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7773 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x5b2d6829), SkBits2Float(0x1f212a55), SkBits2Float(0x8ced7aba), SkBits2Float(0x3f2a212a)); // 6.14991e+25f, 4.88097e+16f, 3.41281e-20f, -3.65895e-31f, 0.664569f
7774 path.lineTo(SkBits2Float(0x5b2d212d), SkBits2Float(0x2d556829)); // 4.87316e+16f, 1.21308e-11f
7775 path.moveTo(SkBits2Float(0x68552968), SkBits2Float(0x5568295b)); // 4.02651e+24f, 1.5954e+13f
7776 path.moveTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55)); // 4.87407e+16f, 5.7784e-19f
7777 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7778 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x2147ed7a), SkBits2Float(0x28282a3a)); // 5.77848e-19f, 4.7323e-37f, 5.63611e+25f, 6.77381e-19f, 9.33503e-15f
7780 SkPath path2(path);
7785 SkPath path;
7786 path.setFillType((SkPath::FillType) 0);
7788 SkPath path1(path);
7789 path.reset();
7790 path.setFillType((SkPath::FillType) 0);
7791 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7792 path.quadTo(SkBits2Float(0x30309ab8), SkBits2Float(0x305b3030), SkBits2Float(0x00f53030), SkBits2Float(0x3a3a0000)); // 6.42483e-10f, 7.97402e-10f, 2.2517e-38f, 0.000709534f
7793 path.quadTo(SkBits2Float(0xb8b8d5b8), SkBits2Float(0x0b0b0b03), SkBits2Float(0x0b0b0b0b), SkBits2Float(0x3a3a0b0b)); // -8.81361e-05f, 2.67787e-32f, 2.67787e-32f, 0.000709698f
7794 path.quadTo(SkBits2Float(0xb8b8b8b8), SkBits2Float(0x0b1203b8), SkBits2Float(0x0b0b0b0b), SkBits2Float(0x3a3a2110)); // -8.80821e-05f, 2.81214e-32f, 2.67787e-32f, 0.000710026f
7796 SkPath path2(path);
7801 SkPath path;
7802 path.setFillType((SkPath::FillType) 1);
7803 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7804 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x743e0000)); // 0, 6.02134e+31f
7805 path.cubicTo(SkBits2Float(0x74083cf1), SkBits2Float(0x74536e73), SkBits2Float(0x742ac4e4), SkBits2Float(0x7415f5be), SkBits2Float(0x7433ee3c), SkBits2Float(0x7405a69a)); // 4.31756e+31f, 6.70053e+31f, 5.41189e+31f, 4.75242e+31f, 5.70223e+31f, 4.23556e+31f
7806 path.quadTo(SkBits2Float(0x74360ca0), SkBits2Float(0x7401e10c), SkBits2Float(0x7436a382), SkBits2Float(0x7401cc18)); // 5.76937e+31f, 4.11603e+31f, 5.78805e+31f, 4.11344e+31f
7807 path.cubicTo(SkBits2Float(0x74374a91), SkBits2Float(0x7401ef19), SkBits2Float(0x74375c84), SkBits2Float(0x7404d9b9), SkBits2Float(0x7437868f), SkBits2Float(0x740bae8a)); // 5.80873e+31f, 4.11777e+31f, 5.81095e+31f, 4.2102e+31f, 5.81616e+31f, 4.42669e+31f
7808 path.cubicTo(SkBits2Float(0x7437d6c1), SkBits2Float(0x7418b629), SkBits2Float(0x74387e9b), SkBits2Float(0x7433fbc5), SkBits2Float(0x743e2ff7), SkBits2Float(0x74655fa2)); // 5.82609e+31f, 4.83962e+31f, 5.84687e+31f, 5.7039e+31f, 6.02728e+31f, 7.26914e+31f
7809 path.cubicTo(SkBits2Float(0x741ada75), SkBits2Float(0x74745717), SkBits2Float(0x73c106b4), SkBits2Float(0x74744e64), SkBits2Float(0x00000000), SkBits2Float(0x74744006)); // 4.9075e+31f, 7.74345e+31f, 3.05862e+31f, 7.74237e+31f, 0, 7.74059e+31f
7810 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x74746c7c), SkBits2Float(0x74244dce), SkBits2Float(0x7474733e), SkBits2Float(0x74400000), SkBits2Float(0x74747445)); // 0, 7.7461e+31f, 5.207e+31f, 7.74693e+31f, 6.08472e+31f, 7.74706e+31f
7811 path.cubicTo(SkBits2Float(0x743f5854), SkBits2Float(0x746f3659), SkBits2Float(0x743ebe05), SkBits2Float(0x746a3017), SkBits2Float(0x743e2ff7), SkBits2Float(0x74655fa2)); // 6.06397e+31f, 7.58094e+31f, 6.04486e+31f, 7.42171e+31f, 6.02728e+31f, 7.26914e+31f
7812 path.cubicTo(SkBits2Float(0x7447a582), SkBits2Float(0x74615dee), SkBits2Float(0x744f74f6), SkBits2Float(0x745c4903), SkBits2Float(0x7455e7e6), SkBits2Float(0x7455d751)); // 6.32705e+31f, 7.14216e+31f, 6.57457e+31f, 6.98112e+31f, 6.77895e+31f, 6.77689e+31f
7813 path.cubicTo(SkBits2Float(0x74747474), SkBits2Float(0x743750a4), SkBits2Float(0x74747474), SkBits2Float(0x73f46f0d), SkBits2Float(0x74747474), SkBits2Float(0x00000000)); // 7.74708e+31f, 5.80948e+31f, 7.74708e+31f, 3.87321e+31f, 7.74708e+31f, 0
7814 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7815 path.close();
7817 SkPath path1(path);
7818 path.reset();
7819 path.setFillType((SkPath::FillType) 0);
7820 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7821 path.lineTo(SkBits2Float(0xf0682955), SkBits2Float(0x211f5b2d)); // -2.87402e+29f, 5.3992e-19f
7822 path.moveTo(SkBits2Float(0x2d2aff2d), SkBits2Float(0x74747474)); // 9.72004e-12f, 7.74708e+31f
7823 path.cubicTo(SkBits2Float(0x7474748e), SkBits2Float(0x74747490), SkBits2Float(0x8c722174), SkBits2Float(0x181f0080), SkBits2Float(0x74c0e520), SkBits2Float(0x747d7463)); // 7.7471e+31f, 7.7471e+31f, -1.86531e-31f, 2.05505e-24f, 1.22262e+32f, 8.0323e+31f
7824 path.cubicTo(SkBits2Float(0x7b005e4b), SkBits2Float(0xdf3a6a3a), SkBits2Float(0x2a3a2848), SkBits2Float(0x2d2d7821), SkBits2Float(0x8c55212d), SkBits2Float(0x2d2d2d24)); // 6.66526e+35f, -1.34326e+19f, 1.65341e-13f, 9.86059e-12f, -1.64189e-31f, 9.84393e-12f
7825 path.conicTo(SkBits2Float(0xde28804c), SkBits2Float(0x28e03721), SkBits2Float(0x3329df28), SkBits2Float(0x2d291515), SkBits2Float(0x0568295b)); // -3.03545e+18f, 2.48929e-14f, 3.95513e-08f, 9.61122e-12f, 1.09162e-35f
7826 path.conicTo(SkBits2Float(0x556a2d21), SkBits2Float(0x21088c2a), SkBits2Float(0x3a333303), SkBits2Float(0x5b293a8a), SkBits2Float(0x6855683b)); // 1.60925e+13f, 4.62641e-19f, 0.000683591f, 4.76336e+16f, 4.03115e+24f
7828 SkPath path2(path);
7833 SkPath path;
7834 path.setFillType((SkPath::FillType) 1);
7836 SkPath path1(path);
7837 path.reset();
7838 path.setFillType((SkPath::FillType) 0);
7839 path.moveTo(SkBits2Float(0x1f2108c0), SkBits2Float(0x4b7b0321)); // 3.41003e-20f, 1.64503e+07f
7840 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f
7841 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7842 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x2a4b7bc0), SkBits2Float(0x68295b2d)); // 2.49282e-13f, 1.31626e+28f, 4.7323e-37f, 1.8073e-13f, 3.19905e+24f
7843 path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55)); // 4.87407e+16f, 5.7784e-19f
7844 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x4b7b28c0)); // 4.7323e-37f, 1.646e+07f
7845 path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x2d081f21)); // 2.50338e-13f, 7.73762e-12f
7846 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7847 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7848 path.cubicTo(SkBits2Float(0x69392d55), SkBits2Float(0x2d5b684b), SkBits2Float(0x8c5527f0), SkBits2Float(0x212a1f2a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 1.39916e+25f, 1.24719e-11f, -1.64209e-31f, 5.76395e-19f, 4.7323e-37f, 6.14991e+25f
7849 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0xed7a6a1f), SkBits2Float(0x3a214793), SkBits2Float(0x3328282a), SkBits2Float(0x3a8a3adf)); // 5.77848e-19f, -4.84372e+27f, 0.000615233f, 3.91521e-08f, 0.00105461f
7850 path.conicTo(SkBits2Float(0x4be80304), SkBits2Float(0xdcdcdc15), SkBits2Float(0xdcdcdcdc), SkBits2Float(0x71dcdcdc), SkBits2Float(0x6c107164)); // 3.04102e+07f, -4.97332e+17f, -4.97339e+17f, 2.18732e+30f, 6.98483e+26f
7851 path.conicTo(SkBits2Float(0x6c0f1d6c), SkBits2Float(0x8e406c6e), SkBits2Float(0x6c6c0200), SkBits2Float(0x6c6ce46c), SkBits2Float(0x6c6c6c6c)); // 6.92061e+26f, -2.3718e-30f, 1.14126e+27f, 1.14554e+27f, 1.14327e+27f
7852 path.lineTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7853 path.close();
7854 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7855 path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x3ac22c21), SkBits2Float(0x6c401057), SkBits2Float(0x6d6d6b64)); // 0.00136978f, 0.00148142f, 9.28764e+26f, 4.59236e+27f
7856 path
7858 SkPath path2(path);
7863 SkPath path;
7864 path.setFillType((SkPath::FillType) 1);
7866 SkPath path1(path);
7867 path.reset();
7868 path.setFillType((SkPath::FillType) 0);
7869 path.moveTo(SkBits2Float(0xd72a8c55), SkBits2Float(0x61081f2a)); // -1.8752e+14f, 1.56938e+20f
7870 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0xdf3a2128), SkBits2Float(0x471ac575)); // 6.14991e+25f, 75739, 9.4495e-15f, -1.3412e+19f, 39621.5f
7871 path.lineTo(SkBits2Float(0x28404040), SkBits2Float(0x552a298a)); // 1.06721e-14f, 1.16935e+13f
7872 path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
7873 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x80ed7a3a), SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828), SkBits2Float(0x4f1a3a3a)); // 6.14991e+25f, -2.18089e-38f, 1.65317e-13f, -1.16126e+19f, 2.58751e+09f
7874 path.lineTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
7875 path.close();
7876 path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
7877 path.cubicTo(SkBits2Float(0x3ac2213a), SkBits2Float(0x432a2928), SkBits2Float(0x96812be6), SkBits2Float(0x272a1d2a), SkBits2Float(0x3a2a3529), SkBits2Float(0x3b1e2ab0)); // 0.00148109f, 170.161f, -2.08688e-25f, 2.3608e-15f, 0.000649291f, 0.00241343f
7878 path.lineTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
7879 path.close();
7880 path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
7881 path.cubicTo(SkBits2Float(0xc5272927), SkBits2Float(0x22383b39), SkBits2Float(0x1051523a), SkBits2Float(0x2927b029), SkBits2Float(0x685b2d27), SkBits2Float(0x5b2d6855)); // -2674.57f, 2.4968e-18f, 4.12813e-29f, 3.72342e-14f, 4.14012e+24f, 4.88099e+16f
7883 SkPath path2(path);
7888 SkPath path;
7889 path.setFillType((SkPath::FillType) 1);
7890 path.moveTo(SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 7.66623e+30f, 7.66608e+30f
7891 path.quadTo(SkBits2Float(0x724341bf), SkBits2Float(0x72433fc4), SkBits2Float(0x6d757575), SkBits2Float(0x6d6d6d6d)); // 3.86746e+30f, 3.86731e+30f, 4.74786e+27f, 4.59251e+27f
7892 path.cubicTo(SkBits2Float(0x6d18b5e5), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6cbe03bd), SkBits2Float(0x6d4b455b), SkBits2Float(0x6c6c69d8), SkBits2Float(0x6d20df31)); // 2.95385e+27f, 4.59251e+27f, 1.83771e+27f, 3.93183e+27f, 1.14323e+27f, 3.11171e+27f
7893 path.conicTo(SkBits2Float(0x6c6c8b72), SkBits2Float(0x00000000), SkBits2Float(0x6c6c6c6c), SkBits2Float(0x00000000), SkBits2Float(0x400812df)); // 1.14386e+27f, 0, 1.14327e+27f, 0, 2.12615f
7894 path.quadTo(SkBits2Float(0x72432acb), SkBits2Float(0x72432295), SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 3.86568e+30f, 3.86505e+30f, 7.66623e+30f, 7.66608e+30f
7895 path.close();
7896 path.moveTo(SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 7.66623e+30f, 7.66608e+30f
7897 path.cubicTo(SkBits2Float(0x74f97d76), SkBits2Float(0x74f97d90), SkBits2Float(0x75381628), SkBits2Float(0x7538182c), SkBits2Float(0x7538153b), SkBits2Float(0x75381835)); // 1.58133e+32f, 1.58133e+32f, 2.33357e+32f, 2.33367e+32f, 2.33353e+32f, 2.33368e+32f
7898 path.cubicTo(SkBits2Float(0x7538144e), SkBits2Float(0x7538183f), SkBits2Float(0x74f9760f), SkBits2Float(0x74f97ddd), SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 2.33348e+32f, 2.33368e+32f, 1.58115e+32f, 1.58134e+32f, 7.66623e+30f, 7.66608e+30f
7899 path.close();
7900 path.moveTo(SkBits2Float(0x6c6c69d8), SkBits2Float(0x6d20df31)); // 1.14323e+27f, 3.11171e+27f
7901 path.conicTo(SkBits2Float(0x6c6c55ae), SkBits2Float(0x6d80b520), SkBits2Float(0x6c6c1071), SkBits2Float(0x6e0f1d6c), SkBits2Float(0x3f96e656)); // 1.14284e+27f, 4.97913e+27f, 1.14154e+27f, 1.1073e+28f, 1.1789f
7902 path.lineTo(SkBits2Float(0x6a674231), SkBits2Float(0x6c0c3394)); // 6.98936e+25f, 6.77973e+26f
7903 path.cubicTo(SkBits2Float(0x6b12c63f), SkBits2Float(0x6c881439), SkBits2Float(0x6bba4ae5), SkBits2Float(0x6ced1e23), SkBits2Float(0x6c6c69d8), SkBits2Float(0x6d20df31)); // 1.77439e+26f, 1.31608e+27f, 4.50428e+26f, 2.29326e+27f, 1.14323e+27f, 3.11171e+27f
7904 path.close();
7906 SkPath path1(path);
7907 path.reset();
7908 path.setFillType((SkPath::FillType) 0);
7909 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7910 path.lineTo(SkBits2Float(0x6c6b6ba7), SkBits2Float(0x886b6b6b)); // 1.13842e+27f, -7.0844e-34f
7911 path.quadTo(SkBits2Float(0x0000206b), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d)); // 1.16294e-41f, 4.59251e+27f, 4.59251e+27f, 4.59251e+27f
7912 path.conicTo(SkBits2Float(0x3e3e3e3e), SkBits2Float(0xafbcad20), SkBits2Float(0x78787878), SkBits2Float(0x78787829), SkBits2Float(0x78787878)); // 0.185784f, -3.432e-10f, 2.01583e+34f, 2.01582e+34f, 2.01583e+34f
7913 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x95066b78)); // 2.01583e+34f, -2.71459e-26f
7914 path.lineTo(SkBits2Float(0x6c6b6ba7), SkBits2Float(0x886b6b6b)); // 1.13842e+27f, -7.0844e-34f
7915 path.quadTo(SkBits2Float(0x0000206b), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d)); // 1.16294e-41f, 4.59251e+27f, 4.59251e+27f, 4.59251e+27f
7916 path.conicTo(SkBits2Float(0x3e3e3e3e), SkBits2Float(0xafbcad20), SkBits2Float(0x78787878), SkBits2Float(0x78787829), SkBits2Float(0x78787878)); // 0.185784f, -3.432e-10f, 2.01583e+34f, 2.01582e+34f, 2.01583e+34f
7917 path.lineTo(SkBits2Float(0x8787878f), SkBits2Float(0x87878787)); // -2.03922e-34f, -2.03922e-34f
7918 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
7919 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
7920 path.lineTo(SkBits2Float(0x6c105778), SkBits2Float(0x6d406b64)); // 6.97994e+26f, 3.72193e+27f
7921 path.cubicTo(SkBits2Float(0x7575756d), SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x6d6d7575), SkBits2Float(0x6d6d6d6d)); // 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 4.59312e+27f, 4.59251e+27f
7922 path.cubicTo(SkBits2Float(0x6d696d6d), SkBits2Float(0x026d6d6d), SkBits2Float(0x80bc6b6b), SkBits2Float(0xaebcdfd0), SkBits2Float(0x7878bcac), SkBits2Float(0x78787878)); // 4.51514e+27f, 1.74434e-37f, -1.73036e-38f, -8.58901e-11f, 2.01799e+34f, 2.01583e+34f
7923 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
7924 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
7925 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
7926 path.lineTo(SkBits2Float(0xb4bcacbc), SkBits2Float(0xbcadbcbc)); // -3.51434e-07f, -0.0212082f
7927 path.moveTo(SkBits2Float(0xa03aacbc), SkBits2Float(0x757575a0)); // -1.5812e-19f, 3.11157e+32f
7928 path.close();
7930 SkPath path2(path);
7935 SkPath path;
7936 path.setFillType((SkPath::FillType) 1);
7938 SkPath path1(path);
7939 path.reset();
7940 path.setFillType((SkPath::FillType) 0);
7941 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7942 path.cubicTo(SkBits2Float(0xdedcdcdc), SkBits2Float(0xdcdcdcdc), SkBits2Float(0xdcdcdcdc), SkBits2Float(0xdcdcdcdc), SkBits2Float(0x55dcdcdc), SkBits2Float(0x29407d7f)); // -7.95742e+18f, -4.97339e+17f, -4.97339e+17f, -4.97339e+17f, 3.03551e+13f, 4.27414e-14f
7943 path.cubicTo(SkBits2Float(0x7b93ed4b), SkBits2Float(0x29521472), SkBits2Float(0xdfc83c28), SkBits2Float(0x1a3a834e), SkBits2Float(0x6855e84f), SkBits2Float(0xf2f22a80)); // 1.53616e+36f, 4.66471e-14f, -2.88569e+19f, 3.857e-23f, 4.0406e+24f, -9.59318e+30f
7944 path.moveTo(SkBits2Float(0xe0f2f210), SkBits2Float(0xc3f2eef2)); // -1.40049e+20f, -485.867f
7945 path.cubicTo(SkBits2Float(0x108ced7a), SkBits2Float(0x7bc00308), SkBits2Float(0x287a6a3a), SkBits2Float(0x242847ed), SkBits2Float(0x2bcb302a), SkBits2Float(0xf21003e8)); // 5.55862e-29f, 1.99396e+36f, 1.39008e-14f, 3.64901e-17f, 1.44374e-12f, -2.85252e+30f
7946 path.moveTo(SkBits2Float(0x556c0010), SkBits2Float(0x002a8768)); // 1.62178e+13f, 3.90567e-39f
7947 path.quadTo(SkBits2Float(0xf2f22021), SkBits2Float(0xf2f2f56e), SkBits2Float(0xf2f2f2f2), SkBits2Float(0xf22040d9)); // -9.59158e+30f, -9.62459e+30f, -9.6242e+30f, -3.17414e+30f
7948 path.lineTo(SkBits2Float(0xc013f2f2), SkBits2Float(0x0000294d)); // -2.3117f, 1.48159e-41f
7950 SkPath path2(path);
7955 SkPath path;
7956 path.setFillType((SkPath::FillType) 1);
7957 path.moveTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f
7958 path.quadTo(SkBits2Float(0x63690f37), SkBits2Float(0x6d0a3d9b), SkBits2Float(0x00000000), SkBits2Float(0x6d3e3e3e)); // 4.29919e+21f, 2.67396e+27f, 0, 3.67984e+27f
7959 path.conicTo(SkBits2Float(0x6b9253fc), SkBits2Float(0x6c956a8b), SkBits2Float(0x6c6ac798), SkBits2Float(0x692a5d27), SkBits2Float(0x3e56eb72)); // 3.538e+26f, 1.44506e+27f, 1.13532e+27f, 1.28723e+25f, 0.209883f
7960 path.lineTo(SkBits2Float(0x6c6c586c), SkBits2Float(0x00000000)); // 1.1429e+27f, 0
7961 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7962 path.conicTo(SkBits2Float(0x6c8c6c6c), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6cc8e82a), SkBits2Float(0x5b684b68)); // 1.35809e+27f, 0, 0, 1.94305e+27f, 6.53851e+16f
7963 path.lineTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f
7964 path.close();
7965 path.moveTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f
7966 path.quadTo(SkBits2Float(0x641ae35f), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 1.14287e+22f, 0, 0, 0
7967 path.lineTo(SkBits2Float(0x6c6c586c), SkBits2Float(0x00000000)); // 1.1429e+27f, 0
7968 path.conicTo(SkBits2Float(0x6c6ba1fc), SkBits2Float(0x688c9eb1), SkBits2Float(0x6c6ac798), SkBits2Float(0x692a5d27), SkBits2Float(0x3f7fec32)); // 1.13945e+27f, 5.31247e+24f, 1.13532e+27f, 1.28723e+25f, 0.999698f
7969 path.lineTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f
7970 path.close();
7972 SkPath path1(path);
7973 path.reset();
7974 path.setFillType((SkPath::FillType) 0);
7975 path.moveTo(SkBits2Float(0x6c3e3e3e), SkBits2Float(0x586c79ff)); // 9.19959e+26f, 1.04003e+15f
7976 path.quadTo(SkBits2Float(0x6c6c4a6c), SkBits2Float(0x6c6c6c6c), SkBits2Float(0xc83e6c6c), SkBits2Float(0x3e313e3e)); // 1.14263e+27f, 1.14327e+27f, -194994, 0.173089f
7978 SkPath path2(path);
7983 SkPath path;
7984 path.setFillType((SkPath::FillType) 0);
7986 SkPath path1(path);
7987 path.reset();
7988 path.setFillType((SkPath::FillType) 0);
7989 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7990 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7991 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7992 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
7993 path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
7994 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f
7995 path.lineTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
7996 path.close();
7997 path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
7998 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7999 path.conicTo(SkBits2Float(0x212a081f), SkBits2Float(0x4b7bc003), SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556839), SkBits2Float(0x2a8c555b)); // 5.7609e-19f, 1.64987e+07f, 4.88298e+16f, -2.64185e+29f, 2.49282e-13f
8000 path.conicTo(SkBits2Float(0xf42a212a), SkBits2Float(0x4b7bc003), SkBits2Float(0x2aed7a39), SkBits2Float(0x2108c08c), SkBits2Float(0x7b03211f)); // -5.39162e+31f, 1.64987e+07f, 4.21845e-13f, 4.63334e-19f, 6.80863e+35f
8001 path.lineTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
8002 path.close();
8003 path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
8004 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f
8005 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8006 path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x212a1f72), SkBits2Float(0x03210807), SkBits2Float(0x6a4b7b28), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 5.76399e-19f, 4.73229e-37f, 6.14984e+25f, 75739
8007 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8008 path.close();
8009 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8010 path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3adf21), SkBits2Float(0x284f1a3a), SkBits2Float(0x213ab38a)); // 9.4456e-15f, -8.99754e-33f, 1.14965e-14f, 6.32569e-19f
8011 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8012 path.close();
8013 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8014 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a20002a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000610354f, 2.50336e-13f
8015 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8016 path.close();
8017 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8018 path.conicTo(SkBits2Float(0xed210830), SkBits2Float(0xc04b6a03), SkBits2Float(0x68297b27), SkBits2Float(0x55555b2d), SkBits2Float(0x2ab03a2a)); // -3.11481e+27f, -3.17835f, 3.20141e+24f, 1.46617e+13f, 3.13042e-13f
8019 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4341f20), SkBits2Float(0xecc52a22)); // 2.22225e-15f, 0.000713932f, -720.486f, -1.90686e+27f
8020 path.cubicTo(SkBits2Float(0x5921c25d), SkBits2Float(0x29523a70), SkBits2Float(0x555b2d68), SkBits2Float(0x1f212a8c), SkBits2Float(0x0321d90a), SkBits2Float(0x5b2d6829)); // 2.8457e+15f, 4.66801e-14f, 1.50618e+13f, 3.41283e-20f, 4.75628e-37f, 4.88097e+16f
8021 path.lineTo(SkBits2Float(0x1f2a2a8c), SkBits2Float(0x03210821)); // 3.60341e-20f, 4.7323e-37f
8022 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8023 path.close();
8024 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8025 path.conicTo(SkBits2Float(0x2eed6a7a), SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28), SkBits2Float(0x4f1a3a8a), SkBits2Float(0x3ab38a28)); // 1.07964e-10f, 9.4495e-15f, 0.000617492f, 2.58753e+09f, 0.00136978f
8026 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8027 path.close();
8028 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8029 path.quadTo(SkBits2Float(0xe61d2a28), SkBits2Float(0x2a43962b), SkBits2Float(0x29272a81), SkBits2Float(0x2bb02a55)); // -1.85547e+23f, 1.73716e-13f, 3.71183e-14f, 1.25173e-12f
8030 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3ac52729), SkBits2Float(0xc4223b32), SkBits2Float(0x6c2a201f)); // 2.22225e-15f, 0.00150416f, -648.925f, 8.22676e+26f
8032 SkPath path2(path);
8037 SkPath path;
8038 path.setFillType((SkPath::FillType) 1);
8040 SkPath path1(path);
8041 path.reset();
8042 path.setFillType((SkPath::FillType) 0);
8043 path.moveTo(SkBits2Float(0x2aed2a8c), SkBits2Float(0x03210a1f)); // 4.21292e-13f, 4.73253e-37f
8044 path.conicTo(SkBits2Float(0x0000007b), SkBits2Float(0x7474747f), SkBits2Float(0x74747474), SkBits2Float(0x747474c4), SkBits2Float(0x74747474)); // 1.7236e-43f, 7.74709e+31f, 7.74708e+31f, 7.74712e+31f, 7.74708e+31f
8045 path.quadTo(SkBits2Float(0x74747474), SkBits2Float(0x74747474), SkBits2Float(0x20437474), SkBits2Float(0x43a52b02)); // 7.74708e+31f, 7.74708e+31f, 1.65557e-19f, 330.336f
8046 path.moveTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f
8047 path.lineTo(SkBits2Float(0x4b7bd603), SkBits2Float(0x6cf33b6a)); // 1.65043e+07f, 2.3524e+27f
8048 path.conicTo(SkBits2Float(0x35778caa), SkBits2Float(0x0000002a), SkBits2Float(0x74742164), SkBits2Float(0x2a3a7474), SkBits2Float(0x4cc22157)); // 9.22194e-07f, 5.88545e-44f, 7.7368e+31f, 1.65605e-13f, 1.0178e+08f
8049 path.cubicTo(SkBits2Float(0x21479321), SkBits2Float(0x23434cc2), SkBits2Float(0x3a214793), SkBits2Float(0x2128282a), SkBits2Float(0x323adf81), SkBits2Float(0x77291a3a)); // 6.76185e-19f, 1.05872e-17f, 0.000615233f, 5.69738e-19f, 1.08774e-08f, 3.42981e+33f
8050 path.conicTo(SkBits2Float(0x0000002a), SkBits2Float(0x7474743e), SkBits2Float(0x74747474), SkBits2Float(0x74746474), SkBits2Float(0x74747474)); // 5.88545e-44f, 7.74706e+31f, 7.74708e+31f, 7.7451e+31f, 7.74708e+31f
8051 path.cubicTo(SkBits2Float(0x21e7fc06), SkBits2Float(0x2a212a59), SkBits2Float(0x0321081f), SkBits2Float(0x00002a35), SkBits2Float(0x74744000), SkBits2Float(0x2974e874)); // 1.57199e-18f, 1.43144e-13f, 4.7323e-37f, 1.5141e-41f, 7.74059e+31f, 5.43805e-14f
8052 path.cubicTo(SkBits2Float(0x74647474), SkBits2Float(0x74747474), SkBits2Float(0x12ec7474), SkBits2Float(0x4cc22147), SkBits2Float(0x47932343), SkBits2Float(0x282a3a21)); // 7.24002e+31f, 7.74708e+31f, 1.49224e-27f, 1.0178e+08f, 75334.5f, 9.4495e-15f
8053 path.lineTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f
8054 path.close();
8055 path.moveTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f
8056 path.conicTo(SkBits2Float(0x3a323adf), SkBits2Float(0x4977291a), SkBits2Float(0x0000002a), SkBits2Float(0x7474743e), SkBits2Float(0x74747474)); // 0.000679893f, 1.01237e+06f, 5.88545e-44f, 7.74706e+31f, 7.74708e+31f
8057 path.cubicTo(SkBits2Float(0x74747464), SkBits2Float(0x74747474), SkBits2Float(0x21e7fc06), SkBits2Float(0x2a212a59), SkBits2Float(0x0321081f), SkBits2Float(0x00002a35)); // 7.74708e+31f, 7.74708e+31f, 1.57199e-18f, 1.43144e-13f, 4.7323e-37f, 1.5141e-41f
8058 path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x742974e8)); // 7.74706e+31f, 5.3703e+31f
8059 path.cubicTo(SkBits2Float(0x74746474), SkBits2Float(0x74747474), SkBits2Float(0xd912ec74), SkBits2Float(0x553a3728), SkBits2Float(0x29202a8c), SkBits2Float(0x5555201b)); // 7.7451e+31f, 7.74708e+31f, -2.58471e+15f, 1.27966e+13f, 3.5564e-14f, 1.46459e+13f
8060 path.moveTo(SkBits2Float(0x31292768), SkBits2Float(0x212d2aff)); // 2.46151e-09f, 5.86716e-19f
8061 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x323adf81), SkBits2Float(0x77291a3a), SkBits2Float(0x00002a49)); // 5.69738e-19f, 1.08774e-08f, 3.42981e+33f, 1.51691e-41f
8062 path.moveTo(SkBits2Float(0x7474743e), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f
8063 path.cubicTo(SkBits2Float(0x74747464), SkBits2Float(0x74747474), SkBits2Float(0x21e7fc06), SkBits2Float(0x2a212a59), SkBits2Float(0x0321081f), SkBits2Float(0x00002a35)); // 7.74708e+31f, 7.74708e+31f, 1.57199e-18f, 1.43144e-13f, 4.7323e-37f, 1.5141e-41f
8064 path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f
8065 path.cubicTo(SkBits2Float(0x74747464), SkBits2Float(0x74747474), SkBits2Float(0x43747474), SkBits2Float(0xa52b0220), SkBits2Float(0x47812a43), SkBits2Float(0x282a3a21)); // 7.74708e+31f, 7.74708e+31f, 244.455f, -1.48326e-16f, 66132.5f, 9.4495e-15f
8066 path.lineTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f
8067 path.close();
8068 path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f
8069 path.conicTo(SkBits2Float(0x3a323adf), SkBits2Float(0x19433b1a), SkBits2Float(0x5921e7fc), SkBits2Float(0x1f2a212a), SkBits2Float(0x35032108)); // 0.000679893f, 1.00932e-23f, 2.84828e+15f, 3.60263e-20f, 4.88494e-07f
8071 SkPath path2(path);
8076 SkPath path;
8077 path.setFillType((SkPath::FillType) 0);
8078 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x5b2d3368)); // 1.59583e+13f, 4.87517e+16f
8079 path.conicTo(SkBits2Float(0x5b2d555b), SkBits2Float(0x68275b2d), SkBits2Float(0x21685527), SkBits2Float(0x0321082a), SkBits2Float(0x6ab485c0)); // 4.8789e+16f, 3.16127e+24f, 7.87174e-19f, 4.7323e-37f, 1.09119e+26f
8080 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 4.8745e+16f
8081 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
8082 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2a8cef2a), SkBits2Float(0x682d2953), SkBits2Float(0xee682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 2.50349e-13f, 3.27093e+24f, -1.79601e+28f, 1.64988e+07f
8083 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
8084 path.conicTo(SkBits2Float(0x4b03213b), SkBits2Float(0xc07b2a08), SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556830), SkBits2Float(0x2a8c555b)); // 8.59372e+06f, -3.92444f, 4.88298e+16f, -2.64185e+29f, 2.49282e-13f
8085 path.conicTo(SkBits2Float(0x0321212a), SkBits2Float(0x4b7bd2c0), SkBits2Float(0xed7ac039), SkBits2Float(0x2f218c08), SkBits2Float(0x1f037b2a)); // 4.73517e-37f, 1.65035e+07f, -4.85023e+27f, 1.46926e-10f, 2.78422e-20f
8086 path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
8087 path.close();
8088 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
8089 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f
8090 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8091 path.conicTo(SkBits2Float(0x721f2a5b), SkBits2Float(0x212a8c55), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7b28), SkBits2Float(0x4793ed7a)); // 3.1526e+30f, 5.7784e-19f, 4.7323e-37f, 6.14984e+25f, 75739
8092 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8093 path.close();
8094 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8095 path.quadTo(SkBits2Float(0x28282a2a), SkBits2Float(0x2c682921), SkBits2Float(0x8c555bf6), SkBits2Float(0x6d03de30)); // 9.33502e-15f, 3.2992e-12f, -1.64366e-31f, 2.5507e+27f
8096 path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x081f2a21)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 4.78968e-34f
8097 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8098 path.close();
8099 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8100 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0xdf93ed7a), SkBits2Float(0x1a3a803a), SkBits2Float(0xb38a294f), SkBits2Float(0x3ac2213a)); // 6.14991e+25f, -2.13186e+19f, 3.85675e-23f, -6.43364e-08f, 0.00148109f
8101 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8102 path.close();
8103 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8104 path.conicTo(SkBits2Float(0xe62b291d), SkBits2Float(0x2a812a43), SkBits2Float(0x8ced093a), SkBits2Float(0xb38a5c5c), SkBits2Float(0x3ac2213a)); // -2.02071e+23f, 2.29443e-13f, -3.65212e-31f, -6.44293e-08f, 0.00148109f
8105 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8106 path.close();
8107 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8108 path.lineTo(SkBits2Float(0x8ced293a), SkBits2Float(0x5c5c5c5c)); // -3.65404e-31f, 2.48104e+17f
8109 path.moveTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003)); // 4.61198e-19f, 1.64987e+07f
8110 path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 9.43289e-15f, 4.8745e+16f
8111 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f
8112 path.lineTo(SkBits2Float(0x682d2952), SkBits2Float(0xee682103)); // 3.27093e+24f, -1.79601e+28f
8113 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x2a3b0355)); // 4.85282e+16f, 1.66101e-13f
8114 path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f
8115 path.close();
8116 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f
8117 path.conicTo(SkBits2Float(0x084b218c), SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a), SkBits2Float(0x5bf05568), SkBits2Float(0x1f2a8c55)); // 6.11275e-34f, 1.16348e+26f, 0.000209024f, 1.35296e+17f, 3.6115e-20f
8119 SkPath path1(path);
8120 path.reset();
8121 path.setFillType((SkPath::FillType) 0);
8122 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8123 path.cubicTo(SkBits2Float(0xbcb4bcac), SkBits2Float(0x000029ff), SkBits2Float(0x010000bc), SkBits2Float(0x00bcbc00), SkBits2Float(0xbebcbcbc), SkBits2Float(0xb6aebcae)); // -0.0220626f, 1.50654e-41f, 2.35104e-38f, 1.73325e-38f, -0.368627f, -5.20757e-06f
8125 SkPath path2(path);
8130 SkPath path;
8131 path.setFillType((SkPath::FillType) 0);
8132 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8133 path.conicTo(SkBits2Float(0x5b682968), SkBits2Float(0x5b292d11), SkBits2Float(0x212a8c55), SkBits2Float(0x555b2d2d), SkBits2Float(0x52525268)); // 6.53477e+16f, 4.76188e+16f, 5.7784e-19f, 1.50617e+13f, 2.25831e+11f
8134 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8135 path.close();
8136 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
8137 path.close();
8138 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
8139 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x2ac05252), SkBits2Float(0x727fb721)); // 4.80216e+30f, 2.25832e+11f, 3.41632e-13f, 5.06496e+30f
8140 path.lineTo(SkBits2Float(0x73727322), SkBits2Float(0x555b2d29)); // 1.92088e+31f, 1.50617e+13f
8141 path.lineTo(SkBits2Float(0xab2a212e), SkBits2Float(0x7a27872a)); // -6.04422e-13f, 2.17464e+35f
8142 path.moveTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f
8143 path.quadTo(SkBits2Float(0x52524852), SkBits2Float(0x72525228), SkBits2Float(0x72727272), SkBits2Float(0x3a727272)); // 2.25789e+11f, 4.16584e+30f, 4.80216e+30f, 0.000924862f
8144 path.lineTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f
8145 path.close();
8146 path.moveTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f
8147 path.quadTo(SkBits2Float(0x2a292827), SkBits2Float(0x962b0080), SkBits2Float(0x5252752a), SkBits2Float(0x72725252)); // 1.50241e-13f, -1.38134e-25f, 2.25977e+11f, 4.79967e+30f
8148 path.quadTo(SkBits2Float(0x72725252), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.79967e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
8149 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda000072), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.00732e+15f, 2.25867e+11f, 2.25831e+11f
8150 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525272), SkBits2Float(0x72525248), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16584e+30f, 4.80216e+30f
8151 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 2.25831e+11f
8152 path.quadTo(SkBits2Float(0x86727272), SkBits2Float(0x5252528d), SkBits2Float(0x72525252), SkBits2Float(0x72727227)); // -4.55992e-35f, 2.25832e+11f, 4.16585e+30f, 4.80214e+30f
8153 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x29217272), SkBits2Float(0xc003211c), SkBits2Float(0x556a4b7b)); // 4.80216e+30f, 3.58484e-14f, -2.0489f, 1.61006e+13f
8154 path.moveTo(SkBits2Float(0x72557272), SkBits2Float(0x00727272)); // 4.22775e+30f, 1.05103e-38f
8155 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
8156 path.close();
8157 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
8158 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x3a727272), SkBits2Float(0x28273ac2), SkBits2Float(0x00802a29)); // 4.80216e+30f, 0.000924862f, 9.2831e-15f, 1.17701e-38f
8159 path.lineTo(SkBits2Float(0x52752a96), SkBits2Float(0x72525252)); // 2.63245e+11f, 4.16585e+30f
8160 path.quadTo(SkBits2Float(0x72525272), SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72727272)); // 4.16586e+30f, 2.25966e+11f, 2.25831e+11f, 4.80216e+30f
8161 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f
8162 path.lineTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
8163 path.close();
8164 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
8165 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525272), SkBits2Float(0x72525248), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16584e+30f, 4.80216e+30f
8166 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x72525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 4.16585e+30f
8167 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x72727252), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada)); // 4.80216e+30f, 4.80215e+30f, -9.04113e+15f, 2.25867e+11f
8168 path.lineTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
8169 path.close();
8170 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
8171 path.quadTo(SkBits2Float(0x86727272), SkBits2Float(0x5252528d), SkBits2Float(0x72525252), SkBits2Float(0x72727227)); // -4.55992e-35f, 2.25832e+11f, 4.16585e+30f, 4.80214e+30f
8172 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x29217272), SkBits2Float(0xc003211c), SkBits2Float(0x556a4b7b)); // 4.80216e+30f, 3.58484e-14f, -2.0489f, 1.61006e+13f
8173 path.moveTo(SkBits2Float(0x72557272), SkBits2Float(0x00727272)); // 4.22775e+30f, 1.05103e-38f
8174 path.moveTo(SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 2.34994e+11f, 2.25831e+11f
8175 path.close();
8176 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
8177 path.close();
8178 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
8179 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
8180 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 2.25831e+11f
8181 path.quadTo(SkBits2Float(0x52525272), SkBits2Float(0x3b3b0052), SkBits2Float(0x5b2d553a), SkBits2Float(0x68556829)); // 2.25832e+11f, 0.00285341f, 4.87889e+16f, 4.03114e+24f
8183 SkPath path1(path);
8184 path.reset();
8185 path.setFillType((SkPath::FillType) 0);
8186 path.moveTo(SkBits2Float(0x52528c55), SkBits2Float(0x29215252)); // 2.26074e+11f, 3.58206e-14f
8188 SkPath path2(path);
8193 SkPath path;
8194 path.setFillType((SkPath::FillType) 0);
8196 SkPath path1(path);
8197 path.reset();
8198 path.setFillType((SkPath::FillType) 0);
8199 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8200 path.quadTo(SkBits2Float(0x7a057c72), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x055f0089)); // 1.73275e+35f, 4.80216e+30f, 4.34505e+30f, 1.04855e-35f
8201 path.quadTo(SkBits2Float(0x00057272), SkBits2Float(0x72ff0000), SkBits2Float(0xba405e72), SkBits2Float(0x031b0074)); // 5.00233e-40f, 1.01016e+31f, -0.000733829f, 4.55509e-37f
8202 path.lineTo(SkBits2Float(0x664af700), SkBits2Float(0x56397d39)); // 2.39619e+23f, 5.09869e+13f
8203 path.quadTo(SkBits2Float(0x7a057273), SkBits2Float(0x057300e4), SkBits2Float(0x257c0c9f), SkBits2Float(0x72400006)); // 1.73224e+35f, 1.1426e-35f, 2.18618e-16f, 3.80295e+30f
8204 path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x030000ff), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8ec4000)); // -0.000836826f, 3.7617e-37f, 1.17894e+32f, -8.92527e+24f
8205 path.moveTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d)); // 0.000231069f, 2.53975e+30f
8206 path.quadTo(SkBits2Float(0x827a0572), SkBits2Float(0x08727272), SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // -1.83687e-37f, 7.29588e-34f, 4.09355e-34f, 4.09355e-34f
8207 path.lineTo(SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // 4.09355e-34f, 4.09355e-34f
8208 path.lineTo(SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // 4.09355e-34f, 4.09355e-34f
8209 path.conicTo(SkBits2Float(0x72728c08), SkBits2Float(0x5b5e7272), SkBits2Float(0x000074ba), SkBits2Float(0x03f8e300), SkBits2Float(0x5aff00e8)); // 4.80414e+30f, 6.26133e+16f, 4.18736e-41f, 1.46282e-36f, 3.58886e+16f
8210 path.quadTo(SkBits2Float(0x00800039), SkBits2Float(0x72100039), SkBits2Float(0x727a0572), SkBits2Float(0x7a727272)); // 1.1755e-38f, 2.85223e+30f, 4.95218e+30f, 3.14714e+35f
8211 path.lineTo(SkBits2Float(0x7272727a), SkBits2Float(0xdb5e6472)); // 4.80216e+30f, -6.25979e+16f
8212 path.moveTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f
8213 path.lineTo(SkBits2Float(0x666d0100), SkBits2Float(0x726efe62)); // 2.79805e+23f, 4.73376e+30f
8214 path.lineTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f
8215 path.close();
8216 path.moveTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f
8217 path.conicTo(SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x475afc16), SkBits2Float(0x170100ad), SkBits2Float(0x01008000)); // 4.80216e+30f, -3.47604e+31f, 56060.1f, 4.1683e-25f, 2.36017e-38f
8218 path.quadTo(SkBits2Float(0x72057272), SkBits2Float(0x8c7a3472), SkBits2Float(0x72727272), SkBits2Float(0x00f6475e)); // 2.64319e+30f, -1.92751e-31f, 4.80216e+30f, 2.26171e-38f
8219 path.moveTo(SkBits2Float(0x6d106d43), SkBits2Float(0x6efe6266)); // 2.79362e+27f, 3.93641e+28f
8220 path.quadTo(SkBits2Float(0x72727a05), SkBits2Float(0xba5b7272), SkBits2Float(0x03000074), SkBits2Float(0x5aff00e8)); // 4.80274e+30f, -0.000837124f, 3.76163e-37f, 3.58886e+16f
8221 path.quadTo(SkBits2Float(0x00da0039), SkBits2Float(0x72100039), SkBits2Float(0x727a0572), SkBits2Float(0x7a727272)); // 2.00202e-38f, 2.85223e+30f, 4.95218e+30f, 3.14714e+35f
8222 path.lineTo(SkBits2Float(0x7272727a), SkBits2Float(0xdb5e6472)); // 4.80216e+30f, -6.25979e+16f
8223 path.lineTo(SkBits2Float(0xfc5b97fc), SkBits2Float(0x47440039)); // -4.56078e+36f, 50176.2f
8224 path.lineTo(SkBits2Float(0x00710000), SkBits2Float(0x62766d01)); // 1.03774e-38f, 1.13644e+21f
8225 path.quadTo(SkBits2Float(0x7a05726e), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f
8227 SkPath path2(path);
8232 SkPath path;
8233 path.setFillType((SkPath::FillType) 1);
8235 SkPath path1(path);
8236 path.reset();
8237 path.setFillType((SkPath::FillType) 0);
8238 path.moveTo(SkBits2Float(0x10190004), SkBits2Float(0x7272727a)); // 3.01739e-29f, 4.80216e+30f
8239 path.quadTo(SkBits2Float(0xf3db5e64), SkBits2Float(0x5b97fc16), SkBits2Float(0x000039fc), SkBits2Float(0x01008000)); // -3.47604e+31f, 8.55598e+16f, 2.08009e-41f, 2.36017e-38f
8240 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x41720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 15.1251f
8241 path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f
8242 path.lineTo(SkBits2Float(0x01000000), SkBits2Float(0x10010004)); // 2.35099e-38f, 2.54408e-29f
8243 path.conicTo(SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16), SkBits2Float(0x0000d07d), SkBits2Float(0x01008000)); // 4.80216e+30f, -3.47604e+31f, 3.58785e+06f, 7.47915e-41f, 2.36017e-38f
8244 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x63720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 4.46415e+21f
8245 path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f
8246 path.lineTo(SkBits2Float(0x72000000), SkBits2Float(0x5b5e72b4)); // 2.5353e+30f, 6.26136e+16f
8247 path.quadTo(SkBits2Float(0x05720089), SkBits2Float(0x05727272), SkBits2Float(0x7272727a), SkBits2Float(0x5b5e7272)); // 1.13789e-35f, 1.13998e-35f, 4.80216e+30f, 6.26133e+16f
8248 path.cubicTo(SkBits2Float(0x03000074), SkBits2Float(0x4aff00e8), SkBits2Float(0x397d3972), SkBits2Float(0x01727200), SkBits2Float(0x72727a00), SkBits2Float(0x5e8d7272)); // 3.76163e-37f, 8.35596e+06f, 0.000241494f, 4.45302e-38f, 4.80274e+30f, 5.09617e+18f
8249 path.moveTo(SkBits2Float(0x72008972), SkBits2Float(0x458fe705)); // 2.54594e+30f, 4604.88f
8250 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0xe8727272), SkBits2Float(0xba5b5e03), SkBits2Float(0x03000074)); // 1.73224e+35f, -4.5797e+24f, -0.00083682f, 3.76163e-37f
8251 path.lineTo(SkBits2Float(0xf3dbff00), SkBits2Float(0x00397d16)); // -3.48598e+31f, 5.2795e-39f
8252 path.cubicTo(SkBits2Float(0x7a101900), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x0197fc16), SkBits2Float(0x200c2010), SkBits2Float(0x20203620)); // 1.87049e+35f, 4.80216e+30f, -3.47604e+31f, 5.58304e-38f, 1.18691e-19f, 1.35704e-19f
8254 SkPath path2(path);
8259 SkPath path;
8260 path.setFillType((SkPath::FillType) 0);
8262 SkPath path1(path);
8263 path.reset();
8264 path.setFillType((SkPath::FillType) 0);
8265 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8266 path.quadTo(SkBits2Float(0x7a057c72), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x055f0089)); // 1.73275e+35f, 4.80216e+30f, 4.34505e+30f, 1.04855e-35f
8267 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xba405e72), SkBits2Float(0x03000074)); // 1.73224e+35f, 4.80216e+30f, -0.000733829f, 3.76163e-37f
8268 path.lineTo(SkBits2Float(0x664aff00), SkBits2Float(0x56397d39)); // 2.39655e+23f, 5.09869e+13f
8269 path.quadTo(SkBits2Float(0x7a057273), SkBits2Float(0x057300ff), SkBits2Float(0x257c0c9f), SkBits2Float(0x72787257)); // 1.73224e+35f, 1.1426e-35f, 2.18618e-16f, 4.92099e+30f
8270 path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x03000093), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8ecff00)); // -0.000836826f, 3.76165e-37f, 1.17894e+32f, -8.95346e+24f
8271 path.moveTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d)); // 0.000231069f, 2.53975e+30f
8272 path.quadTo(SkBits2Float(0x827a0572), SkBits2Float(0x72727272), SkBits2Float(0x724adf00), SkBits2Float(0x00397d39)); // -1.83687e-37f, 4.80216e+30f, 4.01828e+30f, 5.27954e-39f
8273 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x16f3abab), SkBits2Float(0xfc5b97fc), SkBits2Float(0x47440039)); // 1.73224e+35f, 3.93671e-25f, -4.56078e+36f, 50176.2f
8274 path.lineTo(SkBits2Float(0x00710000), SkBits2Float(0x62767201)); // 1.03774e-38f, 1.13653e+21f
8275 path.quadTo(SkBits2Float(0x7a05726e), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f
8277 SkPath path2(path);
8283 SkPath path;
8284 path.setFillType((SkPath::FillType) 0);
8286 SkPath path1(path);
8287 path.reset();
8288 path.setFillType((SkPath::FillType) 0);
8289 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8290 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x05720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 1.13789e-35f
8291 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xba405e72), SkBits2Float(0x03000074)); // 1.73224e+35f, 4.80216e+30f, -0.000733829f, 3.76163e-37f
8292 path.lineTo(SkBits2Float(0x724aff00), SkBits2Float(0x56397d39)); // 4.02075e+30f, 5.09869e+13f
8293 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0xfa8d00ff), SkBits2Float(0x25727272), SkBits2Float(0x7272727a)); // 1.73224e+35f, -3.66067e+35f, 2.10289e-16f, 4.80216e+30f
8294 path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x03000093), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8e0ff00)); // -0.000836826f, 3.76165e-37f, 1.17894e+32f, -8.50011e+24f
8295 path.conicTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d), SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x4aff0072)); // 0.000231069f, 2.53975e+30f, 1.73224e+35f, 4.80216e+30f, 8.3559e+06f
8296 path.quadTo(SkBits2Float(0x00397d39), SkBits2Float(0x05727272), SkBits2Float(0x7272727a), SkBits2Float(0x385e7272)); // 5.27954e-39f, 1.13998e-35f, 4.80216e+30f, 5.30355e-05f
8297 path.quadTo(SkBits2Float(0x057200ff), SkBits2Float(0x25727272), SkBits2Float(0x7272727a), SkBits2Float(0x5b5e7272)); // 1.1379e-35f, 2.10289e-16f, 4.80216e+30f, 6.26133e+16f
8298 path.cubicTo(SkBits2Float(0x03000074), SkBits2Float(0x4aff00e8), SkBits2Float(0x397d3972), SkBits2Float(0x01000400), SkBits2Float(0x72727a10), SkBits2Float(0x5e647272)); // 3.76163e-37f, 8.35596e+06f, 0.000241494f, 2.35128e-38f, 4.80275e+30f, 4.11534e+18f
8299 path.quadTo(SkBits2Float(0x2b2d16f3), SkBits2Float(0x0039fc4d), SkBits2Float(0x68800000), SkBits2Float(0x0100fafa)); // 6.14938e-13f, 5.32513e-39f, 4.8357e+24f, 2.369e-38f
8300 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x63720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 4.46415e+21f
8301 path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f
8302 path.lineTo(SkBits2Float(0x72720000), SkBits2Float(0xff725b5e)); // 4.7933e+30f, -3.22148e+38f
8303 path.moveTo(SkBits2Float(0x72720572), SkBits2Float(0x5b5e2572)); // 4.79373e+30f, 6.25286e+16f
8304 path.quadTo(SkBits2Float(0x05720089), SkBits2Float(0x25727272), SkBits2Float(0x72728c7a), SkBits2Float(0x5b5e7272)); // 1.13789e-35f, 2.10289e-16f, 4.80417e+30f, 6.26133e+16f
8305 path.cubicTo(SkBits2Float(0x03000074), SkBits2Float(0x4aff00e8), SkBits2Float(0x397d3972), SkBits2Float(0x01000400), SkBits2Float(0x72727a10), SkBits2Float(0x5e827272)); // 3.76163e-37f, 8.35596e+06f, 0.000241494f, 2.35128e-38f, 4.80275e+30f, 4.69985e+18f
8306 path.quadTo(SkBits2Float(0x97fc16f3), SkBits2Float(0x0039fc5b), SkBits2Float(0x00f6472e), SkBits2Float(0x01008000)); // -1.62909e-24f, 5.32515e-39f, 2.26171e-38f, 2.36017e-38f
8307 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f
8309 SkPath path2(path);
8314 SkPath path;
8315 path.setFillType((SkPath::FillType) 1);
8317 SkPath path1(path);
8318 path.reset();
8319 path.setFillType((SkPath::FillType) 0);
8320 path.moveTo(SkBits2Float(0x5c386c3a), SkBits2Float(0x4e691a3e)); // 2.07642e+17f, 9.77703e+08f
8321 path.cubicTo(SkBits2Float(0x6f69f9f5), SkBits2Float(0x18ff8791), SkBits2Float(0x2492263c), SkBits2Float(0xbc6fdb48), SkBits2Float(0xc2f82107), SkBits2Float(0x729a18e1)); // 7.24122e+28f, 6.60528e-24f, 6.33822e-17f, -0.0146397f, -124.065f, 6.10442e+30f
8322 path.cubicTo(SkBits2Float(0x07d729d1), SkBits2Float(0xdea6db48), SkBits2Float(0xcd1dfb88), SkBits2Float(0x90826769), SkBits2Float(0x1c20e5a4), SkBits2Float(0xa4c3ba9b)); // 3.23742e-34f, -6.01164e+18f, -1.65657e+08f, -5.14353e-29f, 5.32364e-22f, -8.48839e-17f
8323 path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f
8324 path.close();
8325 path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f
8326 path.cubicTo(SkBits2Float(0xdeea1d6e), SkBits2Float(0xc7774804), SkBits2Float(0x27cf0dcf), SkBits2Float(0x6ae8b99f), SkBits2Float(0x24ac3260), SkBits2Float(0x062fa93c)); // -8.43488e+18f, -63304, 5.7469e-15f, 1.40674e+26f, 7.46784e-17f, 3.30382e-35f
8327 path.lineTo(SkBits2Float(0x438a0b9c), SkBits2Float(0x60a1d2c8)); // 276.091f, 9.32848e+19f
8328 path.quadTo(SkBits2Float(0xe13fb902), SkBits2Float(0x07ee536f), SkBits2Float(0x971d8ac1), SkBits2Float(0x2f9f174b)); // -2.21041e+20f, 3.58593e-34f, -5.09046e-25f, 2.89385e-10f
8329 path.lineTo(SkBits2Float(0x0f2cf5d8), SkBits2Float(0xe271654c)); // 8.5276e-30f, -1.11324e+21f
8330 path.lineTo(SkBits2Float(0xe6cf24d2), SkBits2Float(0xd9537742)); // -4.89105e+23f, -3.72015e+15f
8331 path.cubicTo(SkBits2Float(0x1aaaee04), SkBits2Float(0x9e3b804c), SkBits2Float(0x84cba87d), SkBits2Float(0x4e0e8ccc), SkBits2Float(0x2aec611a), SkBits2Float(0x7ae4b639)); // 7.06949e-23f, -9.92623e-21f, -4.78798e-36f, 5.97898e+08f, 4.19894e-13f, 5.9377e+35f
8332 path.conicTo(SkBits2Float(0x73357921), SkBits2Float(0x6f163021), SkBits2Float(0x70ea542c), SkBits2Float(0xe008f404), SkBits2Float(0x1f6c5e52)); // 1.43778e+31f, 4.64809e+28f, 5.8017e+29f, -3.94741e+19f, 5.0053e-20f
8333 path.lineTo(SkBits2Float(0xda45ad4e), SkBits2Float(0xedce4a04)); // -1.39103e+16f, -7.98042e+27f
8334 path.lineTo(SkBits2Float(0xac0e45da), SkBits2Float(0x8f632841)); // -2.02182e-12f, -1.11997e-29f
8335 path.lineTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f
8336 path.close();
8337 path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f
8338 path.quadTo(SkBits2Float(0xf35c4ad5), SkBits2Float(0x0692f251), SkBits2Float(0x69632126), SkBits2Float(0xb927af67)); // -1.74534e+31f, 5.52751e-35f, 1.71614e+25f, -0.000159917f
8339 path.moveTo(SkBits2Float(0x6534bff9), SkBits2Float(0x434a9986)); // 5.3348e+22f, 202.6f
8340 path.quadTo(SkBits2Float(0x37c603e5), SkBits2Float(0xa0683953), SkBits2Float(0x751915e4), SkBits2Float(0x831c911a)); // 2.36053e-05f, -1.96701e-19f, 1.94059e+32f, -4.60108e-37f
8341 path.cubicTo(SkBits2Float(0xba4f10f1), SkBits2Float(0x5a7571df), SkBits2Float(0x4ec67459), SkBits2Float(0x33c58827), SkBits2Float(0x10b78ccb), SkBits2Float(0xedbd2748)); // -0.000789895f, 1.72716e+16f, 1.66476e+09f, 9.19829e-08f, 7.23977e-29f, -7.31752e+27f
8342 path.cubicTo(SkBits2Float(0x6d06f06a), SkBits2Float(0xe30465cf), SkBits2Float(0xc5458fe7), SkBits2Float(0xca488dc4), SkBits2Float(0x38f9021c), SkBits2Float(0x3e8d58db)); // 2.6101e+27f, -2.44231e+21f, -3160.99f, -3.28587e+06f, 0.000118736f, 0.276069f
8344 SkPath path2(path);
8349 SkPath path;
8350 path.setFillType((SkPath::FillType) 1);
8351 path.moveTo(SkBits2Float(0x7c223bab), SkBits2Float(0x7cf35966)); // 3.36945e+36f, 1.01083e+37f
8352 path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0x7ccaca6d), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 8.4236e+36f, 0, 0
8353 path.lineTo(SkBits2Float(0x7d7d7d7d), SkBits2Float(0x00000000)); // 2.10591e+37f, 0
8354 path.quadTo(SkBits2Float(0x7ccacab0), SkBits2Float(0x7d1817f4), SkBits2Float(0x7c223bab), SkBits2Float(0x7cf35966)); // 8.42364e+36f, 1.26354e+37f, 3.36945e+36f, 1.01083e+37f
8355 path.close();
8357 SkPath path1(path);
8358 path.reset();
8359 path.setFillType((SkPath::FillType) 0);
8360 path.moveTo(SkBits2Float(0x109d0000), SkBits2Float(0xff7bc000)); // 6.19256e-29f, -3.34633e+38f
8361 path.conicTo(SkBits2Float(0x979797ed), SkBits2Float(0x3a214797), SkBits2Float(0x28aa217a), SkBits2Float(0x01007272), SkBits2Float(0x00000072)); // -9.7965e-25f, 0.000615233f, 1.88883e-14f, 2.3592e-38f, 1.59748e-43f
8362 path
8363 path.conicTo(SkBits2Float(0x7f52753a), SkBits2Float(0x8072ffff), SkBits2Float(0x67af2103), SkBits2Float(0x7d2a6847), SkBits2Float(0x7d7d7d7d)); // 2.79747e+38f, -1.05611e-38f, 1.65405e+24f, 1.41569e+37f, 2.10591e+37f
8365 SkPath path2(path);
8370 SkPath path;
8371 path.setFillType((SkPath::FillType) 0);
8373 SkPath path1(path);
8374 path.reset();
8375 path.setFillType((SkPath::FillType) 0);
8376 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8377 path.cubicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a303030), SkBits2Float(0x7a303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 2.28705e+35f, 2.28705e+35f, 6.40969e-10f
8378 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x74303030), SkBits2Float(0x74303030), SkBits2Float(0x30303030), SkBits2Float(0x74303030)); // 6.40969e-10f, 5.58363e+31f, 5.58363e+31f, 6.40969e-10f, 5.58363e+31f
8379 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
8380 path.moveTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8381 path.moveTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f
8382 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a743030), SkBits2Float(0x74303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 3.16974e+35f, 5.58363e+31f, 6.40969e-10f
8383 path.lineTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f
8384 path.close();
8385 path.moveTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f
8386 path.lineTo(SkBits2Float(0x7f303030), SkBits2Float(0x7a303030)); // 2.34194e+38f, 2.28705e+35f
8387 path.conicTo(SkBits2Float(0x77303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0xf9303030), SkBits2Float(0x7a303030)); // 3.57352e+33f, 6.40969e-10f, 6.40969e-10f, -5.71764e+34f, 2.28705e+35f
8388 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
8389 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
8390 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
8391 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
8392 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 2.28705e+35f, 6.40969e-10f
8393 path.cubicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 2.28705e+35f, 6.40969e-10f
8394 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
8395 path.moveTo(SkBits2Float(0x77303030), SkBits2Float(0xff303030)); // 3.57352e+33f, -2.34194e+38f
8396 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7f773030), SkBits2Float(0x7a7a3030), SkBits2Float(0x7a303030)); // 6.40969e-10f, 6.40969e-10f, 3.2857e+38f, 3.24763e+35f, 2.28705e+35f
8397 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x77303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 3.57352e+33f, 6.40969e-10f
8398 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7b303030), SkBits2Float(0x73303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 9.14822e+35f, 1.39591e+31f, 6.40969e-10f
8399 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a7a3030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 3.24763e+35f
8400 SkPath path2(path);
8405 SkPath path;
8406 path.setFillType((SkPath::FillType) 0);
8408 SkPath path1(path);
8409 path.reset();
8410 path.setFillType((SkPath::FillType) 0);
8411 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8412 path.conicTo(SkBits2Float(0x44444444), SkBits2Float(0x44444444), SkBits2Float(0x44263030), SkBits2Float(0x44304430), SkBits2Float(0x4c444430)); // 785.067f, 785.067f, 664.753f, 705.065f, 5.145e+07f
8413 path.moveTo(SkBits2Float(0x44444444), SkBits2Float(0x44444444)); // 785.067f, 785.067f
8414 path.cubicTo(SkBits2Float(0x30303030), SkBits2Float(0x44444444), SkBits2Float(0x30303030), SkBits2Float(0x44444444), SkBits2Float(0x44444444), SkBits2Float(0x4444444c)); // 6.40969e-10f, 785.067f, 6.40969e-10f, 785.067f, 785.067f, 785.067f
8415 SkPath path2(path);
8420 SkPath path;
8421 path.setFillType((SkPath::FillType) 1);
8423 SkPath path1(path);
8424 path.reset();
8425 path.setFillType((SkPath::FillType) 0);
8426 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8427 path.cubicTo(SkBits2Float(0x7272728e), SkBits2Float(0x52527272), SkBits2Float(0x2d555252), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29), SkBits2Float(0x2a212a8c)); // 4.80217e+30f, 2.25966e+11f, 1.21259e-11f, 4.03114e+24f, 1.50617e+13f, 1.43144e-13f
8428 path.conicTo(SkBits2Float(0x00296808), SkBits2Float(0x00000002), SkBits2Float(0x52525252), SkBits2Float(0x72007272), SkBits2Float(0x52527272)); // 3.80257e-39f, 2.8026e-45f, 2.25831e+11f, 2.54416e+30f, 2.25966e+11f
8429 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8430 path.close();
8431 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8432 path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x7272081f)); // 1.43144e-13f, 4.79393e+30f
8433 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x5974fa80), SkBits2Float(0x00747474), SkBits2Float(0x59585264)); // 4.80216e+30f, 4.30971e+15f, 1.06947e-38f, 3.80557e+15f
8434 path.cubicTo(SkBits2Float(0x64007474), SkBits2Float(0x088c5852), SkBits2Float(0x80808021), SkBits2Float(0x8c808080), SkBits2Float(0x80802108), SkBits2Float(0x80808080)); // 9.4783e+21f, 8.44671e-34f, -1.18009e-38f, -1.97989e-31f, -1.17668e-38f, -1.1801e-38f
8435 path.quadTo(SkBits2Float(0x80807d80), SkBits2Float(0x80808080), SkBits2Float(0xff7f0000), SkBits2Float(0x80808080)); // -1.18e-38f, -1.1801e-38f, -3.38953e+38f, -1.1801e-38f
8436 path.quadTo(SkBits2Float(0x80808080), SkBits2Float(0x80808080), SkBits2Float(0xed842b00), SkBits2Float(0x7252ff6d)); // -1.1801e-38f, -1.1801e-38f, -5.113e+27f, 4.17924e+30f
8437 path.quadTo(SkBits2Float(0x72577200), SkBits2Float(0x55525352), SkBits2Float(0x2a212a8c), SkBits2Float(0x7272081f)); // 4.26733e+30f, 1.44535e+13f, 1.43144e-13f, 4.79393e+30f
8438 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x6f740080), SkBits2Float(0x8c556874), SkBits2Float(0x2982ffff)); // 4.80216e+30f, 7.55149e+28f, -1.64404e-31f, 5.81757e-14f
8440 SkPath path2(path);
8445 SkPath path;
8446 path.setFillType((SkPath::FillType) 1);
8448 SkPath path1(path);
8449 path.reset();
8450 path.setFillType((SkPath::FillType) 0);
8451 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8452 path.lineTo(SkBits2Float(0xed0081bc), SkBits2Float(0x1b2d8040)); // -2.48568e+27f, 1.43517e-22f
8453 path.moveTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f
8454 path.close();
8455 path.moveTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f
8456 path.conicTo(SkBits2Float(0x662d5576), SkBits2Float(0x2d804066), SkBits2Float(0x8068291b), SkBits2Float(0x740315ff), SkBits2Float(0x74747474)); // 2.04636e+23f, 1.45805e-11f, -9.56564e-39f, 4.15428e+31f, 7.74708e+31f
8457 path.cubicTo(SkBits2Float(0x762d0529), SkBits2Float(0x72525252), SkBits2Float(0x007b7272), SkBits2Float(0x525adada), SkBits2Float(0x52525252), SkBits2Float(0x52727252)); // 8.77316e+32f, 4.16585e+30f, 1.13368e-38f, 2.34994e+11f, 2.25831e+11f, 2.60325e+11f
8458 path.lineTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f
8459 path.close();
8460 path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
8461 path.close();
8462 path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
8463 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52524872), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.2579e+11f, 4.16585e+30f, 4.80216e+30f
8464 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0x80406666), SkBits2Float(0x68291b2d), SkBits2Float(0x0315ff80)); // 4.80215e+30f, -5.91421e-39f, 3.19432e+24f, 4.40805e-37f
8465 path.cubicTo(SkBits2Float(0x74747474), SkBits2Float(0x7b722974), SkBits2Float(0x5adada00), SkBits2Float(0x52525252), SkBits2Float(0x72720052), SkBits2Float(0x72727272)); // 7.74708e+31f, 1.25738e+36f, 3.08006e+16f, 2.25831e+11f, 4.79333e+30f, 4.80216e+30f
8466 path.lineTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
8467 path.close();
8468 path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
8469 path.quadTo(SkBits2Float(0x72727227), SkBits2Float(0x72727272), SkBits2Float(0x74727272), SkBits2Float(0x55747421)); // 4.80214e+30f, 4.80216e+30f, 7.68345e+31f, 1.67987e+13f
8470 path.lineTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
8471 path.close();
8472 path.moveTo(SkBits2Float(0x724b0000), SkBits2Float(0x00725f72)); // 4.02083e+30f, 1.05035e-38f
8473 path.lineTo(SkBits2Float(0x52525252), SkBits2Float(0x72725252)); // 2.25831e+11f, 4.79967e+30f
8474 path.quadTo(SkBits2Float(0x26727272), SkBits2Float(0x0303a525), SkBits2Float(0x52005c03), SkBits2Float(0x72525252)); // 8.41157e-16f, 3.8687e-37f, 1.37825e+11f, 4.16585e+30f
8475 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x1ff07255), SkBits2Float(0x2a8c5572), SkBits2Float(0x21082a21)); // 4.80216e+30f, 1.01833e-19f, 2.49283e-13f, 4.61343e-19f
8476 path.lineTo(SkBits2Float(0x2a2a3a21), SkBits2Float(0x29212828)); // 1.51192e-13f, 3.5784e-14f
8478 SkPath path2(path);
8483 SkPath path;
8484 path.setFillType((SkPath::FillType) 0);
8486 SkPath path1(path);
8487 path.reset();
8488 path.setFillType((SkPath::FillType) 0);
8489 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8490 path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x78303030), SkBits2Float(0x78787881), SkBits2Float(0x78787878), SkBits2Float(0x30303030)); // 6.40969e-10f, 1.42941e+34f, 2.01583e+34f, 2.01583e+34f, 6.40969e-10f
8491 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
8492 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
8493 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
8494 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x78787878), SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 6.40969e-10f, 2.01583e+34f, 2.01583e+34f, 2.01583e+34f
8495 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8496 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8497 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8498 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8499 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8500 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8501 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8502 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8503 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8504 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8505 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8506 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8507 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8508 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x7878788d)); // 2.01583e+34f, 2.01584e+34f
8509 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x30303030)); // 2.01583e+34f, 6.40969e-10f
8511 SkPath path2(path);
8516 SkPath path;
8517 path.setFillType((SkPath::FillType) 1);
8518 path.moveTo(SkBits2Float(0x70621ede), SkBits2Float(0x00000000)); // 2.79924e+29f, 0
8519 path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x74fc5b97), SkBits2Float(0x7d458fe4)); // 0, 0, 0, 1.59951e+32f, 1.64128e+37f
8520 path.lineTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0
8521 path.lineTo(SkBits2Float(0x70621ede), SkBits2Float(0x00000000)); // 2.79924e+29f, 0
8522 path.close();
8523 path.moveTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0
8524 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8525 path.lineTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0
8526 path.close();
8528 SkPath path1(path);
8529 path.reset();
8530 path.setFillType((SkPath::FillType) 0);
8532 SkPath path2(path);
8537 SkPath path;
8538 path.setFillType((SkPath::FillType) 1);
8540 SkPath path1(path);
8541 path.reset();
8542 path.setFillType((SkPath::FillType) 0);
8543 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8544 path.quadTo(SkBits2Float(0x868b5aae), SkBits2Float(0x626c45ab), SkBits2Float(0xefea1ffe), SkBits2Float(0x0029fc76)); // -5.24192e-35f, 1.08961e+21f, -1.44916e+29f, 3.85582e-39f
8545 path.moveTo(SkBits2Float(0xfacbff01), SkBits2Float(0x56fc5b97)); // -5.29604e+35f, 1.38735e+14f
8546 path.cubicTo(SkBits2Float(0x7d4559c9), SkBits2Float(0xad801c39), SkBits2Float(0xfbe2091a), SkBits2Float(0x7268e394), SkBits2Float(0x7c800079), SkBits2Float(0xa1d75590)); // 1.63953e+37f, -1.45644e-11f, -2.34729e+36f, 4.61284e+30f, 5.31699e+36f, -1.45916e-18f
8548 SkPath path2(path);
8553 SkPath path;
8554 path.setFillType((SkPath::FillType) 1);
8556 SkPath path1(path);
8557 path.reset();
8558 path.setFillType((SkPath::FillType) 0);
8559 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8560 path.quadTo(SkBits2Float(0x29ff4bae), SkBits2Float(0xa1d75590), SkBits2Float(0x9fd6f6c3), SkBits2Float(0x70621ede)); // 1.13374e-13f, -1.45916e-18f, -9.10408e-20f, 2.79924e+29f
8561 path.quadTo(SkBits2Float(0x57a839d3), SkBits2Float(0x1a80d34b), SkBits2Float(0x0147a31b), SkBits2Float(0xff7fffff)); // 3.69933e+14f, 5.32809e-23f, 3.66675e-38f, -3.40282e+38f
8562 path
8563 path.close();
8564 path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
8565 path.conicTo(SkBits2Float(0x75757568), SkBits2Float(0x7575755e), SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x75756575)); // 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 3.11077e+32f
8566 path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
8567 path.close();
8568 path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
8569 path.conicTo(SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x75917575), SkBits2Float(0x75757575)); // 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 3.68782e+32f, 3.11156e+32f
8570 path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
8571 path.close();
8572 path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
8573 path.conicTo(SkBits2Float(0x75757575), SkBits2Float(0x7575758f), SkBits2Float(0x7f757575), SkBits2Float(0x75757575), SkBits2Float(0x75757575)); // 3.11156e+32f, 3.11157e+32f, 3.26271e+38f, 3.11156e+32f, 3.11156e+32f
8574 path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
8575 path.close();
8577 SkPath path2(path);
8582 SkPath path;
8583 path.setFillType((SkPath::FillType) 1);
8584 path.moveTo(SkBits2Float(0x7644b829), SkBits2Float(0x00000000)); // 9.97486e+32f, 0
8585 path.lineTo(SkBits2Float(0x74fc5b97), SkBits2Float(0x77df944a)); // 1.59951e+32f, 9.06945e+33f
8586 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf8fbe3ff)); // 0, -4.08716e+34f
8587 path.lineTo(SkBits2Float(0x7644b829), SkBits2Float(0x00000000)); // 9.97486e+32f, 0
8588 path.close();
8590 SkPath path1(path);
8591 path.reset();
8592 path.setFillType((SkPath::FillType) 0);
8593 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8594 path.quadTo(SkBits2Float(0x45ab86ae), SkBits2Float(0xd6d6626c), SkBits2Float(0xd6d6d6d6), SkBits2Float(0x7644d6d6)); // 5488.83f, -1.17859e+14f, -1.18109e+14f, 9.98093e+32f
8595 path.moveTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0xd6d6d6d6)); // -1.18109e+14f, -1.18109e+14f
8596 path.cubicTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0x64fed6d6), SkBits2Float(0x7644ef40), SkBits2Float(0x290877fc), SkBits2Float(0x447644b8), SkBits2Float(0x80fafc76)); // -1.18109e+14f, 3.76076e+22f, 9.98577e+32f, 3.03021e-14f, 985.074f, -2.30494e-38f
8597 path.conicTo(SkBits2Float(0x87808080), SkBits2Float(0x764400ae), SkBits2Float(0x764400fc), SkBits2Float(0x450080fc), SkBits2Float(0x3636366c)); // -1.93348e-34f, 9.93852e+32f, 9.93858e+32f, 2056.06f, 2.71518e-06f
8598 path.lineTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0xd6d6d6d6)); // -1.18109e+14f, -1.18109e+14f
8599 path.close();
8600 path.moveTo(SkBits2Float(0xef08a412), SkBits2Float(0x5aaeff7f)); // -4.22883e+28f, 2.46288e+16f
8601 path.conicTo(SkBits2Float(0x7644626c), SkBits2Float(0x088912fc), SkBits2Float(0xae8744ef), SkBits2Float(0x76571f5a), SkBits2Float(0x45ab86fc)); // 9.95788e+32f, 8.24985e-34f, -6.15133e-11f, 1.0908e+33f, 5488.87f
8602 path.conicTo(SkBits2Float(0x4064fe62), SkBits2Float(0x290877ef), SkBits2Float(0x780080b8), SkBits2Float(0x553c7644), SkBits2Float(0x644eae87)); // 3.57803f, 3.03021e-14f, 1.04254e+34f, 1.2951e+13f, 1.52504e+22f
8603 path.lineTo(SkBits2Float(0xef08a412), SkBits2Float(0x5aaeff7f)); // -4.22883e+28f, 2.46288e+16f
8604 path.close();
8606 SkPath path2(path);
8612 SkPath path;
8613 path.setFillType((SkPath::FillType) 0);
8614 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8615 path.conicTo(SkBits2Float(0x5b682968), SkBits2Float(0xb3b32d11), SkBits2Float(0xb3b3b3b3), SkBits2Float(0x5b29b3b3), SkBits2Float(0x212a8c55)); // 6.53477e+16f, -8.34353e-08f, -8.36802e-08f, 4.77669e+16f, 5.7784e-19f
8616 path.conicTo(SkBits2Float(0x68555b2d), SkBits2Float(0x28296869), SkBits2Float(0x5b252a08), SkBits2Float(0x5d68392a), SkBits2Float(0x29282780)); // 4.03018e+24f, 9.40402e-15f, 4.64896e+16f, 1.04584e+18f, 3.73378e-14f
8617 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8618 path.close();
8619 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8620 path.cubicTo(SkBits2Float(0x52727272), SkBits2Float(0x72727252), SkBits2Float(0x525252c7), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255)); // 2.60326e+11f, 4.80215e+30f, 2.25833e+11f, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f
8621 path.quadTo(SkBits2Float(0xd7da0000), SkBits2Float(0x5252525a), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // -4.79387e+14f, 2.25831e+11f, 4.16585e+30f, 4.80216e+30f
8622 path.quadTo(SkBits2Float(0x48525252), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255)); // 215369, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f
8623 path.quadTo(SkBits2Float(0xdada007b), SkBits2Float(0x5252525a), SkBits2Float(0x72675252), SkBits2Float(0x72727272)); // -3.0681e+16f, 2.25831e+11f, 4.5818e+30f, 4.80216e+30f
8624 path.quadTo(SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272), SkBits2Float(0x72727272)); // 2.25831e+11f, 3.36289e-15f, 4.80216e+30f, 4.80216e+30f
8625 path.quadTo(SkBits2Float(0x1c292172), SkBits2Float(0x7bc00321), SkBits2Float(0x9aaaaaaa), SkBits2Float(0x8c556a4b)); // 5.59606e-22f, 1.99397e+36f, -7.05861e-23f, -1.64409e-31f
8626 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f
8627 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8628 path.close();
8629 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
8630 path.close();
8631 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
8632 path.quadTo(SkBits2Float(0x72725570), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.79991e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
8633 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0x555bb672), SkBits2Float(0x29686968), SkBits2Float(0x252a081f)); // 4.80215e+30f, 1.50985e+13f, 5.16058e-14f, 1.47479e-16f
8634 path.moveTo(SkBits2Float(0x5d68392a), SkBits2Float(0x01002780)); // 1.04584e+18f, 2.35382e-38f
8635 path.moveTo(SkBits2Float(0x72727200), SkBits2Float(0x72725252)); // 4.80212e+30f, 4.79967e+30f
8636 path.quadTo(SkBits2Float(0x5adada00), SkBits2Float(0xa5252652), SkBits2Float(0x727272ad), SkBits2Float(0xda007b72)); // 3.08006e+16f, -1.43245e-16f, 4.80218e+30f, -9.04113e+15f
8637 path.lineTo(SkBits2Float(0x5252525a), SkBits2Float(0x72525252)); // 2.25831e+11f, 4.16585e+30f
8638 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
8639 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x74217472), SkBits2Float(0x005b5574), SkBits2Float(0x72680000)); // 4.80216e+30f, 5.11671e+31f, 8.38768e-39f, 4.59523e+30f
8640 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x007b7272), SkBits2Float(0x525adada)); // 4.80216e+30f, 2.25831e+11f, 1.13368e-38f, 2.34994e+11f
8641 path.lineTo(SkBits2Float(0x72727200), SkBits2Float(0x72725252)); // 4.80212e+30f, 4.79967e+30f
8642 path.close();
8644 SkPath path1(path);
8645 path.reset();
8646 path.setFillType((SkPath::FillType) 0);
8648 SkPath path2(path);
8655 SkPath path;
8656 path.setFillType((SkPath::FillType) 0);
8657 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f
8658 path.lineTo(SkBits2Float(0x55555568), SkBits2Float(0x55555555)); // 1.46602e+13f, 1.46602e+13f
8659 path.lineTo(SkBits2Float(0x98989898), SkBits2Float(0x55989898)); // -3.94452e-24f, 2.09726e+13f
8660 path.lineTo(SkBits2Float(0xf6f65555), SkBits2Float(0x101006f6)); // -2.49812e+33f, 2.84044e-29f
8661 path.quadTo(SkBits2Float(0xdca33f10), SkBits2Float(0xf6f6f6f6), SkBits2Float(0xf621f6f6), SkBits2Float(0xf70ff6f6)); // -3.67598e+17f, -2.50452e+33f, -8.21259e+32f, -2.91995e+33f
8662 path.lineTo(SkBits2Float(0x9400f6f6), SkBits2Float(0x10530000)); // -6.51105e-27f, 4.16124e-29f
8663 path.quadTo(SkBits2Float(0x0f101010), SkBits2Float(0x00101010), SkBits2Float(0xf610f720), SkBits2Float(0xf6f6f6f6)); // 7.10284e-30f, 1.47513e-39f, -7.35062e+32f, -2.50452e+33f
8664 path.lineTo(SkBits2Float(0x105352f6), SkBits2Float(0x1cf6ff10)); // 4.16763e-29f, 1.63448e-21f
8665 path.lineTo(SkBits2Float(0xf6f6220a), SkBits2Float(0x003700f6)); // -2.49608e+33f, 5.0513e-39f
8666 path.cubicTo(SkBits2Float(0x0000001e), SkBits2Float(0x00fff4f6), SkBits2Float(0xff101064), SkBits2Float(0xf6b6ac7f), SkBits2Float(0xf6f629f6), SkBits2Float(0x10f6f6f6)); // 4.2039e-44f, 2.35059e-38f, -1.91494e+38f, -1.85253e+33f, -2.4964e+33f, 9.74104e-29f
8667 path.quadTo(SkBits2Float(0x10101007), SkBits2Float(0x10f7fd10), SkBits2Float(0xf6f6f6f6), SkBits2Float(0xf6f645e0)); // 2.84113e-29f, 9.78142e-29f, -2.50452e+33f, -2.4975e+33f
8668 path.lineTo(SkBits2Float(0xed9ef6f6), SkBits2Float(0x53535353)); // -6.14965e+27f, 9.07636e+11f
8669 path.lineTo(SkBits2Float(0x53006cf6), SkBits2Float(0x53295353)); // 5.51584e+11f, 7.27247e+11f
8670 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f
8671 path.close();
8672 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f
8673 path.lineTo(SkBits2Float(0xf6f6f6f6), SkBits2Float(0x5353d9f6)); // -2.50452e+33f, 9.09895e+11f
8675 SkPath path1(path);
8676 path.reset();
8677 path.setFillType((SkPath::FillType) 0);
8679 SkPath path2(path);
8685 SkPath path;
8686 path.setFillType((SkPath::FillType) 0);
8687 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8688 path.conicTo(SkBits2Float(0x5b682968), SkBits2Float(0xb3b32d11), SkBits2Float(0xb3b3b3b3), SkBits2Float(0x5b29b3b3), SkBits2Float(0x72725255)); // 6.53477e+16f, -8.34353e-08f, -8.36802e-08f, 4.77669e+16f, 4.79967e+30f
8689 path.quadTo(SkBits2Float(0x525252c7), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255)); // 2.25833e+11f, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f
8690 path.quadTo(SkBits2Float(0xd7da0000), SkBits2Float(0x5adada00), SkBits2Float(0x52525252), SkBits2Float(0x00005252)); // -4.79387e+14f, 3.08006e+16f, 2.25831e+11f, 2.9531e-41f
8691 path.conicTo(SkBits2Float(0xadada525), SkBits2Float(0x52525ab4), SkBits2Float(0x52525252), SkBits2Float(0x72727272), SkBits2Float(0x52527272)); // -1.97412e-11f, 2.25866e+11f, 2.25831e+11f, 4.80216e+30f, 2.25966e+11f
8692 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8693 path.close();
8694 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8695 path.quadTo(SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255), SkBits2Float(0xda007b72)); // 4.79967e+30f, 4.80216e+30f, 4.80215e+30f, -9.04113e+15f
8696 path.lineTo(SkBits2Float(0x5252525a), SkBits2Float(0x72525252)); // 2.25831e+11f, 4.16585e+30f
8697 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
8698 path.lineTo(SkBits2Float(0x7bc00321), SkBits2Float(0x9aaaaaaa)); // 1.99397e+36f, -7.05861e-23f
8699 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f
8700 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8701 path.close();
8702 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
8703 path.close();
8704 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
8705 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
8706 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x26525ada), SkBits2Float(0x72ada525)); // 4.80215e+30f, -9.04113e+15f, 7.29815e-16f, 6.87879e+30f
8707 path.quadTo(SkBits2Float(0x007b7272), SkBits2Float(0x525adada), SkBits2Float(0x52525252), SkBits2Float(0x72727252)); // 1.13368e-38f, 2.34994e+11f, 2.25831e+11f, 4.80215e+30f
8708 path.quadTo(SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72722772), SkBits2Float(0x72727272)); // 2.25966e+11f, 2.25831e+11f, 4.79636e+30f, 4.80216e+30f
8709 path.quadTo(SkBits2Float(0x74727272), SkBits2Float(0x55747421), SkBits2Float(0x0000005b), SkBits2Float(0x72727268)); // 7.68345e+31f, 1.67987e+13f, 1.27518e-43f, 4.80216e+30f
8710 path.quadTo(SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72727272), SkBits2Float(0x72557272)); // 2.25966e+11f, 2.25831e+11f, 4.80216e+30f, 4.22775e+30f
8711 path.quadTo(SkBits2Float(0x5adada72), SkBits2Float(0x52525252), SkBits2Float(0x72725252), SkBits2Float(0x72727272)); // 3.08009e+16f, 2.25831e+11f, 4.79967e+30f, 4.80216e+30f
8713 SkPath path1(path);
8714 path.reset();
8715 path.setFillType((SkPath::FillType) 0);
8717 SkPath path2(path);
8722 SkPath path;
8723 path.setFillType((SkPath::FillType) 0);
8725 SkPath path1(path);
8726 path.reset();
8727 path.setFillType((SkPath::FillType) 0);
8728 path.moveTo(SkBits2Float(0x68546829), SkBits2Float(0x555b2d29)); // 4.01225e+24f, 1.50617e+13f
8729 path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0x4b7b2108)); // 3.60404e-20f, 1.6458e+07f
8730 path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 9.43289e-15f, 4.8745e+16f
8731 path.moveTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f
8732 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2a8cef2a), SkBits2Float(0x682d2953), SkBits2Float(0xce682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 2.50349e-13f, 3.27093e+24f, -9.73619e+08f, 1.64988e+07f
8733 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x3b2a8c55)); // 4.85282e+16f, 0.00260236f
8734 path.lineTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f
8735 path.close();
8736 path.moveTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f
8737 path.conicTo(SkBits2Float(0xd2c00321), SkBits2Float(0xc0394b7b), SkBits2Float(0x8c08ed7a), SkBits2Float(0x211f2f2a), SkBits2Float(0x704b7b03)); // -4.12343e+11f, -2.89523f, -1.05485e-31f, 5.39337e-19f, 2.51897e+29f
8738 path.cubicTo(SkBits2Float(0x2d6829ed), SkBits2Float(0x5b2d555b), SkBits2Float(0x68275b2d), SkBits2Float(0x21685527), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 1.3197e-11f, 4.8789e+16f, 3.16127e+24f, 7.87174e-19f, 4.7323e-37f, 6.14991e+25f
8739 path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 4.8745e+16f
8740 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
8741 path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x228cef2a), SkBits2Float(0x682d2953), SkBits2Float(0xee682103), SkBits2Float(0x287bc055)); // 5.76397e-19f, 3.82003e-18f, 3.27093e+24f, -1.79601e+28f, 1.3975e-14f
8742 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
8743 path.conicTo(SkBits2Float(0x4b03213b), SkBits2Float(0xc07b2a08), SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556830), SkBits2Float(0x2a8c555b)); // 8.59372e+06f, -3.92444f, 4.88298e+16f, -2.64185e+29f, 2.49282e-13f
8744 path.conicTo(SkBits2Float(0x0321212a), SkBits2Float(0x4b7bd2c0), SkBits2Float(0xed7ac039), SkBits2Float(0x2f2a8c08), SkBits2Float(0x7b03211f)); // 4.73517e-37f, 1.65035e+07f, -4.85023e+27f, 1.55112e-10f, 6.80863e+35f
8745 path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
8746 path
8747 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
8748 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f
8749 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8750 path.conicTo(SkBits2Float(0x721f2a5b), SkBits2Float(0x212a8c55), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7b28), SkBits2Float(0x4797ed7a)); // 3.1526e+30f, 5.7784e-19f, 4.7323e-37f, 6.14984e+25f, 77787
8751 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8752 path.close();
8753 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8754 path.quadTo(SkBits2Float(0x2828102a), SkBits2Float(0x2c682921), SkBits2Float(0x8c555bf6), SkBits2Float(0x6d03de30)); // 9.32938e-15f, 3.2992e-12f, -1.64366e-31f, 2.5507e+27f
8755 path.cubicTo(SkBits2Float(0x683f2d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x211f2a21)); // 3.61123e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 5.39271e-19f
8756 path.lineTo(SkBits2Float(0x3a803adf), SkBits2Float(0x8a294f1a)); // 0.000978317f, -8.15193e-33f
8757 path.quadTo(SkBits2Float(0x291d9628), SkBits2Float(0x2a43e62b), SkBits2Float(0x093a2a81), SkBits2Float(0x5c5c8ced)); // 3.49912e-14f, 1.73993e-13f, 2.24089e-33f, 2.48318e+17f
8758 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8759 path.close();
8760 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8761 path.cubicTo(SkBits2Float(0x3ac2213a), SkBits2Float(0x291d9628), SkBits2Float(0x2a43e62b), SkBits2Float(0x293a2a81), SkBits2Float(0x5c5c8ced), SkBits2Float(0x5c5c6e5c)); // 0.00148109f, 3.49912e-14f, 1.73993e-13f, 4.13372e-14f, 2.48318e+17f, 2.48183e+17f
8762 path.lineTo(SkBits2Float(0x1f212a8c), SkBits2Float(0xc0032108)); // 3.41283e-20f, -2.04889f
8763 path.lineTo(SkBits2Float(0xed847b4b), SkBits2Float(0x2d552829)); // -5.12513e+27f, 1.21166e-11f
8764 path.conicTo(SkBits2Float(0x552d5b5b), SkBits2Float(0x3b5a6839), SkBits2Float(0x5b2df068), SkBits2Float(0x2a212a1f), SkBits2Float(0x532a8cef)); // 1.1913e+13f, 0.00333263f, 4.89595e+16f, 1.43143e-13f, 7.32509e+11f
8766 SkPath path2(path);
8771 SkPath path;
8772 path.setFillType((SkPath::FillType) 1);
8773 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8774 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x668ece09), SkBits2Float(0x00000000), SkBits2Float(0x6751c81a), SkBits2Float(0x61c4b0fb)); // 0, 0, 3.37188e+23f, 0, 9.90666e+23f, 4.53539e+20f
8775 path.conicTo(SkBits2Float(0x66f837a9), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x3f823406)); // 5.86087e+23f, 0, 0, 0, 1.01721f
8776 path.close();
8777 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8778 path.quadTo(SkBits2Float(0x675b1bfe), SkBits2Float(0x00000000), SkBits2Float(0x67d76c42), SkBits2Float(0x6292c469)); // 1.03471e+24f, 0, 2.03461e+24f, 1.35369e+21f
8779 path.cubicTo(SkBits2Float(0x6a16df68), SkBits2Float(0x651a2f15), SkBits2Float(0x6c1e7f31), SkBits2Float(0x67a1f9b4), SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 4.55985e+25f, 4.55071e+22f, 7.66444e+26f, 1.52981e+24f, 0, 5.14279e+25f
8780 path.conicTo(SkBits2Float(0x680dcb75), SkBits2Float(0x68dd898d), SkBits2Float(0x681a434a), SkBits2Float(0x6871046b), SkBits2Float(0x3fea0440)); // 2.67843e+24f, 8.36944e+24f, 2.91394e+24f, 4.55269e+24f, 1.82825f
8781 path.quadTo(SkBits2Float(0x679e1b26), SkBits2Float(0x687703c4), SkBits2Float(0x00000000), SkBits2Float(0x687d2968)); // 1.49327e+24f, 4.66598e+24f, 0, 4.78209e+24f
8782 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8783 path.close();
8785 SkPath path1(path);
8786 path.reset();
8787 path.setFillType((SkPath::FillType) 0);
8788 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8789 path.cubicTo(SkBits2Float(0x535353ec), SkBits2Float(0x98989898), SkBits2Float(0x98989898), SkBits2Float(0xf207f36e), SkBits2Float(0xf3f2f2f2), SkBits2Float(0xed3a9781)); // 9.07646e+11f, -3.94452e-24f, -3.94452e-24f, -2.69278e+30f, -3.84968e+31f, -3.60921e+27f
8790 path.quadTo(SkBits2Float(0xf8f8c0ed), SkBits2Float(0xf8f8f8f8), SkBits2Float(0x9f9f9f9f), SkBits2Float(0x3014149f)); // -4.03626e+34f, -4.03981e+34f, -6.76032e-20f, 5.38714e-10f
8792 SkPath path2(path);
8797 SkPath path;
8798 path.setFillType((SkPath::FillType) 1);
8799 path.setFillType(SkPath::kEvenOdd_FillType);
8800 path.moveTo(SkBits2Float(0xd4438848), SkBits2Float(0xd488cf64)); // -3.35922e+12f, -4.70076e+12f
8801 path.lineTo(SkBits2Float(0xd43a056e), SkBits2Float(0xd4851696)); // -3.19582e+12f, -4.57288e+12f
8802 path.quadTo(SkBits2Float(0xd3d48e79), SkBits2Float(0xd49fb136), SkBits2Float(0x00000000), SkBits2Float(0xd4d4d4d4)); // -1.82585e+12f, -5.48698e+12f, 0, -7.31283e+12f
8803 path.quadTo(SkBits2Float(0xd3d06670), SkBits2Float(0xd4a0bb38), SkBits2Float(0xd41d628f), SkBits2Float(0xd472c531)); // -1.79014e+12f, -5.52269e+12f, -2.70385e+12f, -4.17076e+12f
8804 path.lineTo(SkBits2Float(0xd43a0559), SkBits2Float(0xd485168e)); // -3.19581e+12f, -4.57287e+12f
8805 path.lineTo(SkBits2Float(0xd446958b), SkBits2Float(0xd4810278)); // -3.41165e+12f, -4.43274e+12f
8806 path.lineTo(SkBits2Float(0xd443884a), SkBits2Float(0xd488cf65)); // -3.35922e+12f, -4.70076e+12f
8807 path.quadTo(SkBits2Float(0xd47efa09), SkBits2Float(0xd49fd72a), SkBits2Float(0xd4a63f0f), SkBits2Float(0xd4b83ab3)); // -4.38047e+12f, -5.49208e+12f, -5.71218e+12f, -6.33007e+12f
8808 path.lineTo(SkBits2Float(0xd497ca70), SkBits2Float(0xd4c4d4ae)); // -5.21549e+12f, -6.76305e+12f
8809 path.lineTo(SkBits2Float(0xd459d4d4), SkBits2Float(0xd4c4d4d4)); // -3.74231e+12f, -6.76307e+12f
8810 path.lineTo(SkBits2Float(0xd440daf9), SkBits2Float(0xd4c632d3)); // -3.31323e+12f, -6.81005e+12f
8811 path.lineTo(SkBits2Float(0xd4438848), SkBits2Float(0xd488cf64)); // -3.35922e+12f, -4.70076e+12f
8812 path.close();
8813 path.moveTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f
8814 path.lineTo(SkBits2Float(0xd4422174), SkBits2Float(0xd4d02069)); // -3.33514e+12f, -7.15118e+12f
8815 path.lineTo(SkBits2Float(0xd440daa3), SkBits2Float(0xd4c632d9)); // -3.31321e+12f, -6.81005e+12f
8816 path.lineTo(SkBits2Float(0xd41017bc), SkBits2Float(0xd4cb99b6)); // -2.47549e+12f, -6.99566e+12f
8817 path.lineTo(SkBits2Float(0xd442213b), SkBits2Float(0xd4d02067)); // -3.33512e+12f, -7.15117e+12f
8818 path.lineTo(SkBits2Float(0xd442d4d4), SkBits2Float(0xd4d4d4d4)); // -3.34718e+12f, -7.31283e+12f
8819 path.lineTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f
8820 path.close();
8821 path.moveTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f
8822 path.lineTo(SkBits2Float(0xd484e02c), SkBits2Float(0xd45fafcd)); // -4.56557e+12f, -3.84291e+12f
8823 path.lineTo(SkBits2Float(0xd462c867), SkBits2Float(0xd45655f7)); // -3.8961e+12f, -3.68226e+12f
8824 path.lineTo(SkBits2Float(0xd45ac463), SkBits2Float(0xd45ac505)); // -3.75839e+12f, -3.75843e+12f
8825 path.lineTo(SkBits2Float(0xd43d2fa9), SkBits2Float(0xd43d2fb5)); // -3.25019e+12f, -3.2502e+12f
8826 path.lineTo(SkBits2Float(0xd41d6287), SkBits2Float(0xd472c52a)); // -2.70385e+12f, -4.17076e+12f
8827 path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0xd3db1b95), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, -1.88212e+12f, 0, 0
8828 path.quadTo(SkBits2Float(0xd4b7efac), SkBits2Float(0x00000000), SkBits2Float(0xd4d0e88f), SkBits2Float(0xd40b8b46)); // -6.32e+12f, 0, -7.17804e+12f, -2.39735e+12f
8829 path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0x00000000)); // -7.31283e+12f, 0
8830 path.lineTo(SkBits2Float(0xdcdc154b), SkBits2Float(0x00000000)); // -4.95583e+17f, 0
8831 path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4c4d477)); // -7.31283e+12f, -6.76303e+12f
8832 path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d442)); // -7.31283e+12f, -7.31275e+12f
8833 path.lineTo(SkBits2Float(0xd4d4a691), SkBits2Float(0xd4d4d442)); // -7.30662e+12f, -7.31275e+12f
8834 path.lineTo(SkBits2Float(0xd454d4d4), SkBits2Float(0xd4d4aa30)); // -3.65641e+12f, -7.30711e+12f
8835 path.lineTo(SkBits2Float(0xd4bd9def), SkBits2Float(0xd4d43df0)); // -6.51519e+12f, -7.29258e+12f
8836 path.lineTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f
8837 path.lineTo(SkBits2Float(0xd497ca70), SkBits2Float(0xd4c4d4ae)); // -5.21549e+12f, -6.76305e+12f
8838 path.lineTo(SkBits2Float(0xd4bab953), SkBits2Float(0xd4c4d48e)); // -6.41579e+12f, -6.76304e+12f
8839 path.lineTo(SkBits2Float(0xd4a63f0f), SkBits2Float(0xd4b83ab3)); // -5.71218e+12f, -6.33007e+12f
8840 path.lineTo(SkBits2Float(0xd4ae61eb), SkBits2Float(0xd4ae61f4)); // -5.99174e+12f, -5.99174e+12f
8841 path.lineTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f
8842 path.close();
8843 path.moveTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f
8844 path.lineTo(SkBits2Float(0xd446965c), SkBits2Float(0xd4810237)); // -3.4117e+12f, -4.4327e+12f
8845 path.lineTo(SkBits2Float(0xd45ac549), SkBits2Float(0xd45ac55f)); // -3.75845e+12f, -3.75846e+12f
8846 path.lineTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f
8847 path.close();
8848 path.moveTo(SkBits2Float(0xd4b46028), SkBits2Float(0xd41e572a)); // -6.19766e+12f, -2.72027e+12f
8849 path.lineTo(SkBits2Float(0xd4cde20a), SkBits2Float(0xd434bb57)); // -7.07408e+12f, -3.10495e+12f
8850 path.lineTo(SkBits2Float(0xd4c75ffe), SkBits2Float(0xd46f215d)); // -6.85047e+12f, -4.10823e+12f
8851 path.lineTo(SkBits2Float(0xd4b46028), SkBits2Float(0xd41e572a)); // -6.19766e+12f, -2.72027e+12f
8852 path.close();
8854 SkPath path1(path);
8855 path.reset();
8856 path.setFillType((SkPath::FillType) 0);
8857 path.setFillType(SkPath::kWinding_FillType);
8858 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8859 path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0xa5a50000), SkBits2Float(0xd4d4a5a5), SkBits2Float(0xd4d4d4d4)); // 0, -2.86229e-16f, -7.3065e+12f, -7.31283e+12f
8860 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4cfd4d4), SkBits2Float(0xd4d41dd4)); // -7.31283e+12f, -7.31283e+12f, -7.14103e+12f, -7.28827e+12f
8861 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d432d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4a5a5d4)); // -7.31283e+12f, -7.29109e+12f, -7.31283e+12f, -5.69161e+12f
8862 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0x00000000)); // -7.31283e+12f, -7.31283e+12f, -7.31283e+12f, 0
8863 path.moveTo(SkBits2Float(0xa5a5a500), SkBits2Float(0xd4d4d4a5)); // -2.87347e-16f, -7.31281e+12f
8864 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0x2ad4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4cfd4d4)); // -7.31283e+12f, 3.78064e-13f, -7.31283e+12f, -7.14103e+12f
8865 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4)); // -7.31283e+12f, -7.31283e+12f, -7.31283e+12f, -7.31283e+12f
8866 path.quadTo(SkBits2Float(0xd4d40000), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4)); // -7.28426e+12f, -7.31283e+12f, -7.31283e+12f, -7.31283e+12f
8868 SkPath path2(path);
8873 SkPath path;
8874 path.setFillType((SkPath::FillType) 0);
8875 path.setFillType(SkPath::kWinding_FillType);
8876 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8877 path.quadTo(SkBits2Float(0xe0e02972), SkBits2Float(0xe0e060e0), SkBits2Float(0x728e4603), SkBits2Float(0x72727272)); // -1.29221e+20f, -1.29345e+20f, 5.63603e+30f, 4.80216e+30f
8878 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8879 path.close();
8880 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8881 path.quadTo(SkBits2Float(0x68720052), SkBits2Float(0x52527372), SkBits2Float(0x00527252), SkBits2Float(0x728e4601)); // 4.57127e+24f, 2.2597e+11f, 7.57152e-39f, 5.63603e+30f
8882 path.quadTo(SkBits2Float(0x52ec7272), SkBits2Float(0x6265527f), SkBits2Float(0x8e460152), SkBits2Float(0x72ff8072)); // 5.07766e+11f, 1.05756e+21f, -2.4406e-30f, 1.01215e+31f
8883 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8884 path.close();
8885 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8886 path.lineTo(SkBits2Float(0x52626552), SkBits2Float(0x72727272)); // 2.43091e+11f, 4.80216e+30f
8887 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x62727272), SkBits2Float(0x39393939), SkBits2Float(0x728bc739)); // 4.80216e+30f, 1.11809e+21f, 0.000176643f, 5.53719e+30f
8888 path.cubicTo(SkBits2Float(0x72728092), SkBits2Float(0x72727260), SkBits2Float(0x4d727272), SkBits2Float(0x5252522a), SkBits2Float(0x72735252), SkBits2Float(0x72707272)); // 4.80325e+30f, 4.80215e+30f, 2.54224e+08f, 2.2583e+11f, 4.81948e+30f, 4.76254e+30f
8889 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x56727272), SkBits2Float(0x72720152), SkBits2Float(0x72727270)); // 4.80216e+30f, 6.66433e+13f, 4.79341e+30f, 4.80216e+30f
8890 path.quadTo(SkBits2Float(0x52526172), SkBits2Float(0x8e460300), SkBits2Float(0x72727272), SkBits2Float(0x52525272)); // 2.25894e+11f, -2.44068e-30f, 4.80216e+30f, 2.25832e+11f
8891 path.conicTo(SkBits2Float(0xb5727272), SkBits2Float(0x7f2b727f), SkBits2Float(0x607272ff), SkBits2Float(0x72727276), SkBits2Float(0x2a527272)); // -9.03186e-07f, 2.27892e+38f, 6.98812e+19f, 4.80216e+30f, 1.86915e-13f
8892 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8893 path.close();
8894 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8895 path.lineTo(SkBits2Float(0x72727272), SkBits2Float(0x52525f72)); // 4.80216e+30f, 2.25886e+11f
8896 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8897 path.close();
8898 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8899 path.quadTo(SkBits2Float(0x52727272), SkBits2Float(0x64655252), SkBits2Float(0x72c1c152), SkBits2Float(0x72727272)); // 2.60326e+11f, 1.69209e+22f, 7.67543e+30f, 4.80216e+30f
8901 SkPath path1(path);
8902 path.reset();
8903 path.setFillType((SkPath::FillType) 0);
8904 path.setFillType(SkPath::kWinding_FillType);
8906 SkPath path2(path);
8911 SkPath path;
8912 path.setFillType((SkPath::FillType) 0);
8913 path.setFillType(SkPath::kWinding_FillType);
8915 SkPath path1(path);
8916 path.reset();
8917 path.setFillType((SkPath::FillType) 0);
8918 path.setFillType(SkPath::kWinding_FillType);
8919 path.moveTo(SkBits2Float(0x46090052), SkBits2Float(0x7270726c)); // 8768.08f, 4.76254e+30f
8920 path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
8921 path.close();
8922 path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
8923 path.lineTo(SkBits2Float(0x77727272), SkBits2Float(0x52520072)); // 4.91741e+33f, 2.25488e+11f
8924 path.lineTo(SkBits2Float(0x46090052), SkBits2Float(0x727272ce)); // 8768.08f, 4.80219e+30f
8925 path.quadTo(SkBits2Float(0x725252ec), SkBits2Float(0x72727272), SkBits2Float(0x72727272), SkBits2Float(0x39393962)); // 4.16589e+30f, 4.80216e+30f, 4.80216e+30f, 0.000176644f
8926 path.lineTo(SkBits2Float(0x6c460900), SkBits2Float(0x72727072)); // 9.57639e+26f, 4.802e+30f
8927 path.cubicTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x72943603), SkBits2Float(0x72777272), SkBits2Float(0x5c525200), SkBits2Float(0x46090052), SkBits2Float(0x727272ce)); // -1.29345e+20f, 5.87124e+30f, 4.90119e+30f, 2.368e+17f, 8768.08f, 4.80219e+30f
8928 path.quadTo(SkBits2Float(0x725252ec), SkBits2Float(0x72727272), SkBits2Float(0x72727272), SkBits2Float(0x39393962)); // 4.16589e+30f, 4.80216e+30f, 4.80216e+30f, 0.000176644f
8929 path
8930 path.quadTo(SkBits2Float(0xff727272), SkBits2Float(0x52527272), SkBits2Float(0x39392072), SkBits2Float(0xe0393939)); // -3.22267e+38f, 2.25966e+11f, 0.000176551f, -5.3387e+19f
8931 path.lineTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
8932 path.close();
8933 path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
8934 path.cubicTo(SkBits2Float(0xdada7272), SkBits2Float(0x2dff7272), SkBits2Float(0x767272f0), SkBits2Float(0x72727272), SkBits2Float(0x21727f72), SkBits2Float(0x0b210929)); // -3.07437e+16f, 2.9041e-11f, 1.22936e+33f, 4.80216e+30f, 8.21615e-19f, 3.10144e-32f
8935 path.cubicTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0x72a5d6d6), SkBits2Float(0x72553872), SkBits2Float(0xdada7072), SkBits2Float(0x5252525a), SkBits2Float(0x72727252)); // -1.18109e+14f, 6.56957e+30f, 4.22327e+30f, -3.07426e+16f, 2.25831e+11f, 4.80215e+30f
8936 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0xdada0072), SkBits2Float(0x52524b5a), SkBits2Float(0x72528000)); // 4.79991e+30f, -3.0681e+16f, 2.25802e+11f, 4.16938e+30f
8937 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0xca005252), SkBits2Float(0x46030052), SkBits2Float(0x7272728e)); // 4.80216e+30f, -2.10242e+06f, 8384.08f, 4.80217e+30f
8938 path.quadTo(SkBits2Float(0x7272ff72), SkBits2Float(0x20725252), SkBits2Float(0x39393939), SkBits2Float(0xd76ee039)); // 4.81307e+30f, 2.05254e-19f, 0.000176643f, -2.62647e+14f
8939 path.cubicTo(SkBits2Float(0xdada7272), SkBits2Float(0x2dff7272), SkBits2Float(0x767272f0), SkBits2Float(0x72727272), SkBits2Float(0x21727f72), SkBits2Float(0x0b210929)); // -3.07437e+16f, 2.9041e-11f, 1.22936e+33f, 4.80216e+30f, 8.21615e-19f, 3.10144e-32f
8940 path.cubicTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0x72a5d6d6), SkBits2Float(0x72553872), SkBits2Float(0xdada7072), SkBits2Float(0x5252525a), SkBits2Float(0x72727252)); // -1.18109e+14f, 6.56957e+30f, 4.22327e+30f, -3.07426e+16f, 2.25831e+11f, 4.80215e+30f
8941 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0xdada0072), SkBits2Float(0x52524b5a), SkBits2Float(0x72528000)); // 4.79991e+30f, -3.0681e+16f, 2.25802e+11f, 4.16938e+30f
8942 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
8943 path.quadTo(SkBits2Float(0x72667254), SkBits2Float(0x00000040), SkBits2Float(0x00a70155), SkBits2Float(0x726800ff)); // 4.56447e+30f, 8.96831e-44f, 1.5337e-38f, 4.59531e+30f
8944 path.quadTo(SkBits2Float(0x7b727272), SkBits2Float(0xad000c52), SkBits2Float(0x1c10adad), SkBits2Float(0x72728d8a)); // 1.25886e+36f, -7.27869e-12f, 4.78701e-22f, 4.80425e+30f
8945 path.quadTo(SkBits2Float(0xff056546), SkBits2Float(0x727205ff), SkBits2Float(0x524b5aff), SkBits2Float(0x64005252)); // -1.77313e+38f, 4.79377e+30f, 2.18351e+11f, 9.46846e+21f
8946 path.quadTo(SkBits2Float(0x72524872), SkBits2Float(0xdada7272), SkBits2Float(0x5252525a), SkBits2Float(0x72727252)); // 4.16508e+30f, -3.07437e+16f, 2.25831e+11f, 4.80215e+30f
8947 path.quadTo(SkBits2Float(0x72724172), SkBits2Float(0xdad10072), SkBits2Float(0x52524b5a), SkBits2Float(0x725b8000)); // 4.79837e+30f, -2.94144e+16f, 2.25802e+11f, 4.34765e+30f
8948 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
8949 path.quadTo(SkBits2Float(0x72728372), SkBits2Float(0x00000040), SkBits2Float(0xf6a70147), SkBits2Float(0xc2c2c256)); // 4.80347e+30f, 8.96831e-44f, -1.69363e+33f, -97.3796f
8950 path.lineTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
8951 path.close();
8952 path.moveTo(SkBits2Float(0x7a787a7a), SkBits2Float(0x7a3a7a7a)); // 3.22543e+35f, 2.42063e+35f
8953 path.lineTo(SkBits2Float(0x8f4603e0), SkBits2Float(0x72727272)); // -9.7629e-30f, 4.80216e+30f
8954 path.quadTo(SkBits2Float(0x00807272), SkBits2Float(0x46090052), SkBits2Float(0x7270726c), SkBits2Float(0x60e04372)); // 1.1796e-38f, 8768.08f, 4.76254e+30f, 1.29279e+20f
8955 path.moveTo(SkBits2Float(0x943603e0), SkBits2Float(0x77727272)); // -9.18942e-27f, 4.91741e+33f
8956 path.quadTo(SkBits2Float(0x5c525200), SkBits2Float(0x46090052), SkBits2Float(0x727272ce), SkBits2Float(0x5252ec72)); // 2.368e+17f, 8768.08f, 4.80219e+30f, 2.26478e+11f
8958 SkPath path2(path);
8963 SkPath path;
8964 path.setFillType((SkPath::FillType) 0);
8965 path.setFillType(SkPath::kWinding_FillType);
8967 SkPath path1(path);
8968 path.reset();
8969 path.setFillType((SkPath::FillType) 0);
8970 path.setFillType(SkPath::kWinding_FillType);
8971 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8972 path.cubicTo(SkBits2Float(0x535e5372), SkBits2Float(0x53536153), SkBits2Float(0x79530f53), SkBits2Float(0x101b6c88), SkBits2Float(0x5353735e), SkBits2Float(0x006df653)); // 9.54883e+11f, 9.07871e+11f, 6.84928e+34f, 3.0652e-29f, 9.08174e+11f, 1.00984e-38f
8973 path.cubicTo(SkBits2Float(0xf26df46d), SkBits2Float(0xf6f6f6f6), SkBits2Float(0x5656f666), SkBits2Float(0x5a565656), SkBits2Float(0x00000056), SkBits2Float(0xf66e5600)); // -4.71318e+30f, -2.50452e+33f, 5.90884e+13f, 1.50826e+16f, 1.20512e-43f, -1.20851e+33f
8974 path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00faf6f6)); // -1.71467e+38f, 2.30475e-38f
8975 path.moveTo(SkBits2Float(0x60576bfa), SkBits2Float(0x006df653)); // 6.20911e+19f, 1.00984e-38f
8976 path.cubicTo(SkBits2Float(0xf26df46d), SkBits2Float(0xf653f6f6), SkBits2Float(0x563ef666), SkBits2Float(0x56565656), SkBits2Float(0x65565656), SkBits2Float(0xf6765656)); // -4.71318e+30f, -1.07479e+33f, 5.24914e+13f, 5.89166e+13f, 6.32612e+22f, -1.24908e+33f
8978 SkPath path2(path);
8983 SkPath path;
8984 path.setFillType((SkPath::FillType) 1);
8985 path.setFillType(SkPath::kEvenOdd_FillType);
8986 path.moveTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0
8987 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf66e5600)); // 0, -1.20851e+33f
8988 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf629168b)); // 0, -8.57378e+32f
8989 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8990 path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0
8991 path.close();
8993 SkPath path1(path);
8994 path.reset();
8995 path.setFillType((SkPath::FillType) 0);
8996 path.setFillType(SkPath::kWinding_FillType);
8997 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8998 path.lineTo(SkBits2Float(0x03e8f6f6), SkBits2Float(0xf7060000)); // 1.36924e-36f, -2.71784e+33f
8999 path.lineTo(SkBits2Float(0x4ff6f6f6), SkBits2Float(0x3e3e3e2a)); // 8.28676e+09f, 0.185784f
9000 path.conicTo(SkBits2Float(0x6c8879ff), SkBits2Float(0x08761b1b), SkBits2Float(0x7066662d), SkBits2Float(0x70707070), SkBits2Float(0x70707070)); // 1.31992e+27f, 7.40598e-34f, 2.8522e+29f, 2.97649e+29f, 2.97649e+29f
9002 SkPath path2(path);
9007 SkPath path;
9008 path.setFillType((SkPath::FillType) 0);
9009 path.setFillType(SkPath::kWinding_FillType);
9011 SkPath path1(path);
9012 path.reset();
9013 path.setFillType((SkPath::FillType) 0);
9014 path.setFillType(SkPath::kWinding_FillType);
9015 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
9016 path.cubicTo(SkBits2Float(0x535e5372), SkBits2Float(0x53536153), SkBits2Float(0x79530f53), SkBits2Float(0x101b6c88), SkBits2Float(0x5353735e), SkBits2Float(0x006df653)); // 9.54883e+11f, 9.07871e+11f, 6.84928e+34f, 3.0652e-29f, 9.08174e+11f, 1.00984e-38f
9017 path.cubicTo(SkBits2Float(0xf26df46d), SkBits2Float(0xf6f6f6f6), SkBits2Float(0x5656f666), SkBits2Float(0x5a565656), SkBits2Float(0x00000056), SkBits2Float(0xf66e5600)); // -4.71318e+30f, -2.50452e+33f, 5.90884e+13f, 1.50826e+16f, 1.20512e-43f, -1.20851e+33f
9018 path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00faf6f6)); // -1.71467e+38f, 2.30475e-38f
9019 path.moveTo(SkBits2Float(0x60576bfa), SkBits2Float(0x006df653)); // 6.20911e+19f, 1.00984e-38f
9020 path.cubicTo(SkBits2Float(0xf26df46d), SkBits2Float(0xf653f6f6), SkBits2Float(0x563ef666), SkBits2Float(0x56565656), SkBits2Float(0x65565656), SkBits2Float(0xf6765656)); // -4.71318e+30f, -1.07479e+33f, 5.24914e+13f, 5.89166e+13f, 6.32612e+22f, -1.24908e+33f
9022 SkPath path2(path);
9027 SkPath path;
9028 path.setFillType((SkPath::FillType) 1);
9029 path.setFillType(SkPath::kEvenOdd_FillType);
9030 path.moveTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0
9031 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf66e5600)); // 0, -1.20851e+33f
9032 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf629168b)); // 0, -8.57378e+32f
9033 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
9034 path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0
9035 path.close();
9037 SkPath path1(path);
9038 path.reset();
9039 path.setFillType((SkPath::FillType) 0);
9040 path.setFillType(SkPath::kWinding_FillType);
9041 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
9042 path.lineTo(SkBits2Float(0x03e8f6f6), SkBits2Float(0xf7060000)); // 1.36924e-36f, -2.71784e+33f
9043 path.lineTo(SkBits2Float(0x4ff6f6f6), SkBits2Float(0x3e3e3e2a)); // 8.28676e+09f, 0.185784f
9044 path.conicTo(SkBits2Float(0x6c8879ff), SkBits2Float(0x08761b1b), SkBits2Float(0x7066662d), SkBits2Float(0x70707070), SkBits2Float(0x70707070)); // 1.31992e+27f, 7.40598e-34f, 2.8522e+29f, 2.97649e+29f, 2.97649e+29f
9046 SkPath path2(path);
