Lines Matching refs:path

13     PathTest_Private(SkPath* path)
14         : fPath(path) {}
23 static void path_edit(const SkPoint& from, const SkPoint& to, SkPath* path) {
24     PathTest_Private testPath(path);
25     for (int index = 0; index < path->countPoints(); ++index) {
26         if (SkDPoint::ApproximatelyEqual(path->getPoint(index), from)) {
34     SkPath path, pathB;
35     path.setFillType(SkPathFillType::kWinding);
36     path.moveTo(0,1);
37     path.cubicTo(0,2, 1,0, 1,0);
38     path.close();
43     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
47     SkPath path, pathB;
48     path.setFillType(SkPathFillType::kWinding);
49     path.moveTo(0,2);
50     path.cubicTo(0,1, 1,0, 1,0);
51     path.close();
56     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
60     SkPath path, pathB;
61     path.setFillType(SkPathFillType::kWinding);
62     path.moveTo(0,1);
63     path.cubicTo(2,3, 1,0, 1,0);
64     path.close();
69     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
73     SkPath path, pathB;
74     path.setFillType(SkPathFillType::kWinding);
75     path.moveTo(0,1);
76     path.cubicTo(0,2, 1,0, 2,0);
77     path.close();
82     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
86     SkPath path, pathB;
87     path.setFillType(SkPathFillType::kWinding);
88     path.moveTo(0,1);
89     path.cubicTo(0,6, 1,0, 3,0);
90     path.close();
95     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
99     SkPath path, pathB;
100     path.setFillType(SkPathFillType::kWinding);
101     path.moveTo(0,1);
102     path.cubicTo(3,4, 1,0, 3,0);
103     path.close();
108     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
112     SkPath path, pathB;
113     path.setFillType(SkPathFillType::kWinding);
114     path.moveTo(0,1);
115     path.cubicTo(0,5, 1,0, 4,0);
116     path.close();
121     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
125     SkPath path, pathB;
126     path.setFillType(SkPathFillType::kWinding);
127     path.moveTo(0,1);
128     path.cubicTo(1,6, 1,0, 2,1);
129     path.close();
134     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
138     SkPath path, pathB;
139     path.setFillType(SkPathFillType::kWinding);
140     path.moveTo(0,1);
141     path.quadTo(1,6, 1.5f,1);
142     path.quadTo(1.5f,0.5f, 2,1);
143     path.close();
149     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
153     SkPath path, pathB;
154     path.setFillType(SkPathFillType::kWinding);
155     path.moveTo(0,1);
156     path.lineTo(1,6);
157     path.lineTo(1.5f,1);
158     path.lineTo(1.8f,0.8f);
159     path.lineTo(2,1);
160     path.close();
168     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
172     SkPath path, pathB;
173     path.setFillType(SkPathFillType::kWinding);
174     path.moveTo(0,1);
175     path.cubicTo(1,2, 1,0, 2,1);
176     path.close();
181     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
185     SkPath path, pathB;
186     path.setFillType(SkPathFillType::kWinding);
187     path.moveTo(0,1);
188     path.cubicTo(1,3, 1,0, 4,1);
189     path.close();
194     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
198     SkPath path, pathB;
199     path.setFillType(SkPathFillType::kWinding);
200     path.moveTo(0,1);
201     path.cubicTo(3,4, 1,0, 5,1);
202     path.close();
207     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
211     SkPath path, pathB;
212     path.setFillType(SkPathFillType::kWinding);
213     path.moveTo(0,1);
214     path.cubicTo(1,6, 1,0, 1,0);
215     path.close();
220     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
224     SkPath path, pathB;
225     path.setFillType(SkPathFillType::kWinding);
226     path.moveTo(0,1);
227     path.cubicTo(4,5, 1,0, 5,3);
228     path.close();
233     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
237     SkPath path, pathB;
238     path.setFillType(SkPathFillType::kWinding);
239     path.moveTo(0,1);
240     path.cubicTo(0,2, 2,0, 2,1);
241     path.close();
246     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
250     SkPath path, pathB;
251     path.setFillType(SkPathFillType::kWinding);
252     path.moveTo(0,1);
253     path.cubicTo(3,6, 2,0, 2,1);
254     path.close();
259     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
263     SkPath path, pathB;
264     path.setFillType(SkPathFillType::kWinding);
265     path.moveTo(0,2);
266     path.cubicTo(0,1, 3,0, 1,0);
267     path.close();
272     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
276     SkPath path, pathB;
277     path.setFillType(SkPathFillType::kWinding);
278     path.moveTo(0,2);
279     path.cubicTo(0,2, 4,0, 2,1);
280     path.close();
285     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
289     SkPath path, pathB;
290     path.setFillType(SkPathFillType::kWinding);
291     path.moveTo(0,1);
292     path.cubicTo(3,5, 2,0, 2,1);
293     path.close();
298     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
302     SkPath path, pathB;
303     path.setFillType(SkPathFillType::kWinding);
304     path.moveTo(0,2);
305     path.cubicTo(0,1, 2,1, 6,2);
306     path.close();
311     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
315     SkPath path, pathB;
316     path.setFillType(SkPathFillType::kWinding);
317     path.moveTo(0,1);
318     path.cubicTo(0,1, 6,0, 2,1);
319     path.close();
324     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
328     SkPath path, pathB;
329     path.setFillType(SkPathFillType::kWinding);
330     path.moveTo(0,1);
331     path.cubicTo(0,1, 2,1, 6,5);
332     path.close();
337     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
341     SkPath path, pathB;
342     path.setFillType(SkPathFillType::kWinding);
343     path.moveTo(0,1);
344     path.cubicTo(2,3, 3,0, 2,1);
345     path.close();
350     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
354     SkPath path, pathB;
355     path.setFillType(SkPathFillType::kWinding);
356     path.moveTo(0,1);
357     path.cubicTo(1,2, 4,0, 2,1);
358     path.close();
363     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
367     SkPath path, pathB;
368     path.setFillType(SkPathFillType::kWinding);
369     path.moveTo(0,1);
370     path.cubicTo(1,2, 2,0, 3,2);
371     path.close();
376     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
436     SkPath path, pathB;
437     path.setFillType(SkPathFillType::kWinding);
438     path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
439     path.addRect(0, 0, 2, 2, SkPathDirection::kCW);
443     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
447     SkPath path, pathB;
448     path.setFillType(SkPathFillType::kWinding);
449     path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
450     path.addRect(0, 0, 2, 2, SkPathDirection::kCW);
454     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
458     SkPath path, pathB;
459     path.setFillType(SkPathFillType::kWinding);
460     path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
461     path.addRect(1, 1, 2, 2, SkPathDirection::kCW);
465     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
469     SkPath path, pathB;
470     path.setFillType(SkPathFillType::kWinding);
471     path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
472     path.addRect(0, 0, 3, 3, SkPathDirection::kCW);
476     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
480     SkPath path, pathB;
481     path.setFillType(SkPathFillType::kWinding);
482     path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
483     path.addRect(2, 2, 4, 4, SkPathDirection::kCW);
487     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
491     SkPath path, pathB;
492     path.setFillType(SkPathFillType::kEvenOdd);
493     path.addRect(0, 0, 2, 2, SkPathDirection::kCW);
494     path.addRect(0, 0, 3, 3, SkPathDirection::kCW);
498     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
502     SkPath path, pathB;
503     path.setFillType(SkPathFillType::kEvenOdd);
504     path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
505     path.addRect(0, 0, 3, 3, SkPathDirection::kCW);
509     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
513     SkPath path, pathB;
514     path.setFillType(SkPathFillType::kEvenOdd);
515     path.addRect(0, 0, 2, 2, SkPathDirection::kCW);
516     path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
520     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
524     SkPath path, pathB;
525     path.setFillType(SkPathFillType::kEvenOdd);
526     path.addRect(0, 0, 2, 2, SkPathDirection::kCW);
527     path.addRect(0, 0, 2, 2, SkPathDirection::kCW);
531     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
535     SkPath path, pathB;
536     path.addRect(0, 0, 640, 480);
540     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
543     SkPath path, pathB;
544     path.setFillType(SkPathFillType::kWinding);
545     path.moveTo(0,1);
546     path.cubicTo(2,4, 5,0, 3,2);
547     path.close();
552     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
556     SkPath path, pathB;
557     path.setFillType(SkPathFillType::kWinding);
558     path.moveTo(0,1);
559     path.cubicTo(3,4, 4,0, 3,2);
560     path.close();
565     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
569     SkPath path, pathB;
570     path.setFillType(SkPathFillType::kWinding);
571     path.moveTo(0,1);
572     path.cubicTo(3,6, 1,0, 5,2);
573     path.close();
578     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
582     SkPath path, pathB;
583     path.setFillType(SkPathFillType::kWinding);
584     path.moveTo(0,1);
585     path.cubicTo(1,4, 6,0, 3,2);
586     path.close();
591     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
595     SkPath path, pathB;
596     path.setFillType(SkPathFillType::kWinding);
597     path.moveTo(0,1);
598     path.cubicTo(2,5, 6,0, 4,2);
599     path.close();
604     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
608     SkPath path, pathB;
609     path.setFillType(SkPathFillType::kWinding);
610     path.moveTo(0,1);
611     path.cubicTo(2,5, 6,0, 5,3);
612     path.close();
617     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
621     SkPath path, pathB;
622     path.setFillType(SkPathFillType::kWinding);
623     path.moveTo(0,2);
624     path.cubicTo(0,3, 2,1, 4,0);
625     path.close();
630     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
634     SkPath path, pathB;
635     path.setFillType(SkPathFillType::kWinding);
636     path.moveTo(0,2);
637     path.cubicTo(0,3, 2,1, 4,0);
638     path.close();
643     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
647     SkPath path, pathB;
648     path.setFillType(SkPathFillType::kWinding);
649     path.moveTo(0,2);
650     path.cubicTo(0,3, 2,1, 4,0);
651     path.close();
656     testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
660     SkPath path, pathB;
661     path.setFillType(SkPathFillType::kWinding);
662     path.moveTo(0,1);
663     path.cubicTo(1,2, 6,0, 3,1);
664     path.close();
669     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
673     SkPath path, pathB;
674     path.setFillType(SkPathFillType::kWinding);
675     path.moveTo(0,1);
676     path.cubicTo(1,2, 6,0, 3,1);
677     path.close();
682     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
686     SkPath path, pathB;
687     path.setFillType(SkPathFillType::kWinding);
688     path.moveTo(0,1);
689     path.cubicTo(3,5, 2,1, 3,1);
690     path.close();
695     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
699     SkPath path, pathB;
700     path.setFillType(SkPathFillType::kWinding);
701     path.moveTo(0,1);
702     path.cubicTo(1,5, 2,1, 4,0);
703     path.close();
708     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
712     SkPath path, pathB;
713     path.setFillType(SkPathFillType::kWinding);
714     path.moveTo(0,1);
715     path.cubicTo(1,6, 2,0, 5,1);
716     path.close();
721     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
725     SkPath path, pathB;
726     path.setFillType(SkPathFillType::kWinding);
727     path.moveTo(0,1);
728     path.cubicTo(2,6, 6,1, 4,3);
729     path.close();
734     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
738     SkPath path, pathB;
739     path.setFillType(SkPathFillType::kWinding);
740     path.moveTo(0,1);
741     path.cubicTo(0,6, 3,2, 4,1);
742     path.close();
747     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
751     SkPath path, pathB;
752     path.setFillType(SkPathFillType::kWinding);
753     path.moveTo(0,1);
754     path.cubicTo(2,3, 5,1, 4,3);
755     path.close();
760     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
764     SkPath path, pathB;
765     path.setFillType(SkPathFillType::kWinding);
766     path.moveTo(0,1);
767     path.cubicTo(1,5, 3,2, 4,2);
768     path.close();
773     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
777     SkPath path, pathB;
778     path.setFillType(SkPathFillType::kWinding);
779     path.moveTo(0,1);
780     path.cubicTo(2,6, 4,3, 6,4);
781     path.close();
786     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
790     SkPath path, pathB;
791     path.setFillType(SkPathFillType::kWinding);
792     path.moveTo(0,1);
793     path.cubicTo(1,2, 6,5, 5,4);
794     path.close();
799     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
803     SkPath path, pathB;
804     path.setFillType(SkPathFillType::kWinding);
805     path.moveTo(0,2);
806     path.cubicTo(1,2, 4,0, 3,1);
807     path.close();
812     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
816     SkPath path, pathB;
817     path.setFillType(SkPathFillType::kWinding);
818     path.moveTo(0,2);
819     path.cubicTo(3,6, 4,0, 3,2);
820     path.close();
825     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
829     SkPath path, pathB;
830     path.setFillType(SkPathFillType::kWinding);
831     path.moveTo(0,2);
832     path.cubicTo(2,4, 4,0, 3,2);
833     path.close();
838     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
842     SkPath path, pathB;
843     path.setFillType(SkPathFillType::kWinding);
844     path.moveTo(0,2);
845     path.cubicTo(3,5, 5,0, 4,2);
846     path.close();
851     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
855     SkPath path, pathB;
856     path.setFillType(SkPathFillType::kWinding);
857     path.moveTo(0,1);
858     path.cubicTo(1,6, 6,2, 5,4);
859     path.close();
864     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
868     SkPath path, pathB;
869     path.setFillType(SkPathFillType::kWinding);
870     path.moveTo(0,2);
871     path.cubicTo(2,3, 5,1, 3,2);
872     path.close();
877     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
881     SkPath path, pathB;
882     path.setFillType(SkPathFillType::kWinding);
883     path.moveTo(0,2);
884     path.cubicTo(1,5, 3,2, 4,1);
885     path.close();
890     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
894     SkPath path, pathB;
895     path.setFillType(SkPathFillType::kWinding);
896     path.moveTo(0,3);
897     path.cubicTo(1,6, 5,0, 5,1);
898     path.close();
903     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
907     SkPath path, pathB;
908     path.setFillType(SkPathFillType::kWinding);
909     path.moveTo(0,3);
910     path.cubicTo(1,2, 4,1, 6,0);
911     path.close();
916     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
920     SkPath path, pathB;
921     path.setFillType(SkPathFillType::kWinding);
922     path.moveTo(0,2);
923     path.cubicTo(1,2, 5,4, 4,3);
924     path.close();
929     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
933     SkPath path, pathB;
934     path.setFillType(SkPathFillType::kWinding);
935     path.moveTo(0,3);
936     path.cubicTo(1,2, 5,3, 2,1);
937     path.close();
942     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
946     SkPath path, pathB;
947     path.setFillType(SkPathFillType::kWinding);
948     path.moveTo(0,4);
949     path.cubicTo(1,3, 5,4, 4,2);
950     path.close();
955     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
959     SkPath path, pathB;
960     path.setFillType(SkPathFillType::kWinding);
961     path.moveTo(0,5);
962     path.cubicTo(1,3, 3,2, 5,0);
963     path.close();
968     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
972     SkPath path, pathB;
973     path.setFillType(SkPathFillType::kWinding);
974     path.moveTo(0,1);
975     path.cubicTo(2,6, 5,0, 2,1);
976     path.close();
981     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
985     SkPath path, pathB;
986     path.setFillType(SkPathFillType::kWinding);
987     path.moveTo(0,5);
988     path.cubicTo(0,5, 5,4, 6,4);
989     path.close();
994     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
998     SkPath path, pathB;
999     path.setFillType(SkPathFillType::kWinding);
1000     path.moveTo(0,5);
1001     path.cubicTo(3,4, 6,5, 5,3);
1002     path.close();
1007     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1011     SkPath path, pathB;
1012     path.setFillType(SkPathFillType::kWinding);
1013     path.moveTo(0,1);
1014     path.cubicTo(5,6, 4,0, 4,1);
1015     path.close();
1020     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1024     SkPath path, pathB;
1025     path.setFillType(SkPathFillType::kWinding);
1026     path.moveTo(0,2);
1027     path.cubicTo(4,6, 6,0, 5,2);
1028     path.close();
1033     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1037     SkPath path, pathB;
1038     path.setFillType(SkPathFillType::kWinding);
1039     path.moveTo(1,2);
1040     path.cubicTo(0,5, 3,2, 6,1);
1041     path.close();
1046     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1050     SkPath path, pathB;
1051     path.setFillType(SkPathFillType::kWinding);
1052     path.moveTo(1,3);
1053     path.cubicTo(5,6, 5,3, 5,4);
1054     path.close();
1059     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1063     SkPath path, pathB;
1064     path.setFillType(SkPathFillType::kWinding);
1065     path.moveTo(2,3);
1066     path.cubicTo(0,4, 3,2, 5,3);
1067     path.close();
1072     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1076     SkPath path, pathB;
1077     path.moveTo(0,1);
1078     path.cubicTo(0,1, 1,0, 3,0);
1079     path.lineTo(0,1);
1080     path.close();
1085     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1089     SkPath path, pathB;
1090     path.moveTo(0,1);
1091     path.cubicTo(1,5, 1,0, 1,0);
1092     path.lineTo(0,1);
1093     path.close();
1098     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1102     SkPath path, pathB;
1103     path.moveTo(0,1);
1104     path.cubicTo(0,1, 1,0, 3,0);
1105     path.lineTo(0,1);
1106     path.close();
1111     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1115     SkPath path, pathB;
1116     path.setFillType(SkPathFillType::kWinding);
1117     path.moveTo(0,1);
1118     path.cubicTo(2,6, 4,2, 5,3);
1119     path.close();
1124     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1128     SkPath path, pathB;
1129     path.moveTo(3,5);
1130     path.cubicTo(1,6, 5,0, 3,1);
1131     path.lineTo(3,5);
1132     path.close();
1137     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1141     SkPath path, pathB;
1142     path.moveTo(0,5);
1143     path.cubicTo(4,5, 4,1, 5,0);
1144     path.close();
1148     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1152     SkPath path, pathB;
1153     path.moveTo(1,3);
1154     path.cubicTo(0,1, 3,1, 2,0);
1155     path.close();
1159     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1196     SkPath path;
1197     path.setFillType(SkPathFillType::kInverseEvenOdd);
1201         testPathOp(reporter, path, paths[index], ops[index], uniqueName.c_str());
1202         REPORTER_ASSERT(reporter, Op(path, paths[index], ops[index], &path));
1207     SkPath path;
1208     path.setFillType(SkPathFillType::kEvenOdd);
1209     path.moveTo(189,7);
1210     path.cubicTo(189,5.34314585f, 190.34314f,4, 192,4);
1211     path.lineTo(243,4);
1212     path.cubicTo(244.65686f,4, 246,5.34314585f, 246,7);
1213     path.lineTo(246,21);
1214     path.cubicTo(246,22.6568546f, 244.65686f,24, 243,24);
1215     path.lineTo(192,24);
1216     path.cubicTo(190.34314f,24, 189,22.6568546f, 189,21);
1217     path.lineTo(189,7);
1218     path.close();
1219     path.moveTo(191,8);
1220     path.cubicTo(191,6.89543009f, 191.895432f,6, 193,6);
1221     path.lineTo(242,6);
1222     path.cubicTo(243.104568f,6, 244,6.89543009f, 244,8);
1223     path.lineTo(244,20);
1224     path.cubicTo(244,21.1045704f, 243.104568f,22, 242,22);
1225     path.lineTo(193,22);
1226     path.cubicTo(191.895432f,22, 191,21.1045704f, 191,20);
1227     path.lineTo(191,8);
1228     path.close();
1237     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1241     SkPath path;
1242     path.setFillType(SkPathFillType::kEvenOdd);
1243     path.moveTo(253.000000f, 11757.0000f);
1244     path.lineTo(253.000000f, 222.000000f);
1245     path.lineTo(823.000000f, 222.000000f);
1246     path.lineTo(823.000000f, 11757.0000f);
1247     path.lineTo(253.000000f, 11757.0000f);
1248     path.close();
1257     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1261     SkPath path;
1262     path.setFillType(SkPathFillType::kEvenOdd);
1263     path.moveTo(717.000000f, 507.000000f);
1264     path.lineTo(717.000000f, 425.000000f);
1265     path.lineTo(973.000000f, 425.000000f);
1266     path.lineTo(973.000000f, 507.000000f);
1267     path.quadTo(973.000000f, 508.242645f, 972.121582f, 509.121613f);
1268     path.quadTo(971.242615f, 510.000000f, 970.000000f, 510.000000f);
1269     path.lineTo(720.000000f, 510.000000f);
1270     path.quadTo(718.757385f, 510.000000f, 717.878418f, 509.121613f);
1271     path.quadTo(717.000000f, 508.242645f, 717.000000f, 507.000000f);
1272     path.close();
1273     path.moveTo(719.000000f, 426.000000f);
1274     path.lineTo(971.000000f, 426.000000f);
1275     path.lineTo(971.000000f, 506.000000f);
1276     path.cubicTo(971.000000f, 507.104584f, 970.104553f, 508.000000f, 969.000000f, 508.000000f);
1277     path.lineTo(721.000000f, 508.000000f);
1278     path.cubicTo(719.895447f, 508.000000f, 719.000000f, 507.104584f, 719.000000f, 506.000000f);
1279     path.lineTo(719.000000f, 426.000000f);
1280     path.close();
1289     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1293     SkPath path;
1294     path.setFillType(SkPathFillType::kEvenOdd);
1295     path.moveTo(230.756805f, 591.756775f);
1296     path.quadTo(232.514725f, 590.000000f, 235.000000f, 590.000000f);
1297     path.lineTo(300.000000f, 590.000000f);
1298     path.quadTo(302.485291f, 590.000000f, 304.243195f, 591.756775f);
1299     path.quadTo(306.000000f, 593.514709f, 306.000000f, 596.000000f);
1300     path.lineTo(306.000000f, 617.000000f);
1301     path.lineTo(229.000000f, 617.000000f);
1302     path.lineTo(229.000000f, 596.000000f);
1303     path.quadTo(229.000000f, 593.514709f, 230.756805f, 591.756775f);
1304     path.close();
1305     path.moveTo(231.000000f, 597.000000f);
1306     path.cubicTo(231.000000f, 594.238586f, 233.238571f, 592.000000f, 236.000000f, 592.000000f);
1307     path.lineTo(299.000000f, 592.000000f);
1308     path.cubicTo(301.761414f, 592.000000f, 304.000000f, 594.238586f, 304.000000f, 597.000000f);
1309     path.lineTo(304.000000f, 616.000000f);
1310     path.lineTo(231.000000f, 616.000000f);
1311     path.lineTo(231.000000f, 597.000000f);
1312     path.close();
1321     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1325     SkPath path;
1326     path.setFillType(SkPathFillType::kEvenOdd);
1327     path.moveTo(18.0000000f, 226.000000f);
1328     path.quadTo(14.6862917f, 226.000000f, 12.3423996f, 228.342407f);
1329     path.quadTo(10.0000000f, 230.686295f, 10.0000000f, 234.000000f);
1330     path.lineTo(10.0000000f, 253.000000f);
1331     path.lineTo(1247.00000f, 253.000000f);
1332     path.lineTo(1247.00000f, 234.000000f);
1333     path.quadTo(1247.00000f, 230.686295f, 1244.65759f, 228.342407f);
1334     path.quadTo(1242.31372f, 226.000000f, 1239.00000f, 226.000000f);
1335     path.lineTo(18.0000000f, 226.000000f);
1336     path.close();
1347     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1351     SkPath path, pathB;
1352     path.setFillType(SkPathFillType::kWinding);
1353     path.moveTo(0,1);
1354     path.cubicTo(0,5, 4,0, 5,0);
1355     path.close();
1360     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1364     SkPath path, pathB;
1365     path.setFillType(SkPathFillType::kWinding);
1366     path.moveTo(0,1);
1367     path.cubicTo(0,5, 4,1, 6,4);
1368     path.close();
1373     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1377     SkPath path, pathB;
1378     path.setFillType(SkPathFillType::kWinding);
1379     path.moveTo(0,1);
1380     path.cubicTo(0,5, 5,2, 5,4);
1381     path.close();
1386     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1390     SkPath path, pathB;
1391     path.setFillType(SkPathFillType::kWinding);
1392     path.moveTo(0,1);
1393     path.cubicTo(3,4, 4,0, 6,4);
1394     path.lineTo(0,1);
1395     path.close();
1401     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1405     SkPath path, pathB;
1406     path.setFillType(SkPathFillType::kWinding);
1407     path.moveTo(0,1);
1408     path.cubicTo(1,5, 5,1, 5,1);
1409     path.lineTo(0,1);
1410     path.close();
1416     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1420     SkPath path, pathB;
1421     path.setFillType(SkPathFillType::kWinding);
1422     path.moveTo(0,1);
1423     path.cubicTo(0,4, 5,1, 6,4);
1424     path.lineTo(0,1);
1425     path.close();
1431     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1435     SkPath path, pathB;
1436     path.setFillType(SkPathFillType::kWinding);
1437     path.moveTo(0,1);
1438     path.cubicTo(0,2, 2,0, 5,3);
1439     path.close();
1444     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1448     SkPath path, pathB;
1449     path.setFillType(SkPathFillType::kEvenOdd);
1450     path.moveTo(0,1);
1451     path.cubicTo(1,3, 2,0, 3,2);
1452     path.lineTo(0,1);
1453     path.close();
1459     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1463     SkPath path, pathB;
1464     path.setFillType(SkPathFillType::kEvenOdd);
1465     path.moveTo(1,6);
1466     path.cubicTo(1,6, 5,0, 6,1);
1467     path.lineTo(1,6);
1468     path.close();
1474     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1478     SkPath path, pathB;
1479     path.setFillType(SkPathFillType::kWinding);
1480     path.moveTo(0,1);
1481     path.cubicTo(1,3, 1,0, 6,4);
1482     path.close();
1487     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1491     SkPath path, pathB;
1492     path.setFillType(SkPathFillType::kWinding);
1493     path.moveTo(0,1);
1494     path.cubicTo(2,3, 2,1, 4,3);
1495     path.lineTo(0,1);
1496     path.close();
1502     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1506     SkPath path, pathB;
1507     path.setFillType(SkPathFillType::kWinding);
1508     path.moveTo(0,1);
1509     path.cubicTo(4,6, 4,3, 5,4);
1510     path.close();
1515     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1519     SkPath path, pathB;
1520     path.setFillType(SkPathFillType::kEvenOdd);
1521     path.moveTo(0,1);
1522     path.cubicTo(2,3, 5,2, 3,0);
1523     path.lineTo(0,1);
1524     path.close();
1530     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1534     SkPath path, pathB;
1535     path.setFillType(SkPathFillType::kWinding);
1536     path.moveTo(0,1);
1537     path.cubicTo(0,3, 2,1, 4,1);
1538     path.lineTo(0,1);
1539     path.close();
1545     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1549     SkPath path, pathB;
1550     path.setFillType(SkPathFillType::kWinding);
1551     path.moveTo(0,4);
1552     path.cubicTo(2,3, 6,3, 3,2);
1553     path.close();
1558     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1562     SkPath path;
1563     path.setFillType(SkPathFillType::kEvenOdd);
1564     path.moveTo(1126.17114f, 877.171204f);
1565     path.quadTo(1127.34314f, 876.000000f, 1129.00000f, 876.000000f);
1566     path.lineTo(1243.00000f, 876.000000f);
1567     path.quadTo(1244.65686f, 876.000000f, 1245.82886f, 877.171204f);
1568     path.quadTo(1247.00000f, 878.343140f, 1247.00000f, 880.000000f);
1569     path.lineTo(1247.00000f, 907.000000f);
1570     path.lineTo(1246.00000f, 907.000000f);
1571     path.lineTo(1246.00000f, 880.000000f);
1572     path.cubicTo(1246.00000f, 878.343140f, 1244.65686f, 877.000000f, 1243.00000f, 877.000000f);
1573     path.lineTo(1129.00000f, 877.000000f);
1574     path.cubicTo(1127.34314f, 877.000000f, 1126.00000f, 878.343140f, 1126.00000f, 880.000000f);
1575     path.lineTo(1126.00000f, 907.000000f);
1576     path.lineTo(1125.00000f, 907.000000f);
1577     path.lineTo(1125.00000f, 880.000000f);
1578     path.quadTo(1125.00000f, 878.343140f, 1126.17114f, 877.171204f);
1579     path.close();
1588     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1592     SkPath path;
1593     path.setFillType(SkPathFillType::kEvenOdd);
1594     path.moveTo(134.000000f, 11414.0000f);
1595     path.cubicTo(131.990234f, 11414.0000f, 130.326660f, 11415.4824f, 130.042755f, 11417.4131f);
1596     path.cubicTo(130.233124f, 11418.3193f, 131.037079f, 11419.0000f, 132.000000f, 11419.0000f);
1597     path.lineTo(806.000000f, 11419.0000f);
1598     path.cubicTo(806.962891f, 11419.0000f, 807.766907f, 11418.3193f, 807.957275f, 11417.4131f);
1599     path.cubicTo(807.673401f, 11415.4824f, 806.009766f, 11414.0000f, 804.000000f, 11414.0000f);
1600     path.lineTo(134.000000f, 11414.0000f);
1601     path.close();
1614     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1618     SkPath path;
1619     path.setFillType(SkPathFillType::kEvenOdd);
1620     path.moveTo(157.464005f, 670.463989f);
1621     path.quadTo(158.928925f, 669.000000f, 161.000000f, 669.000000f);
1622     path.lineTo(248.000000f, 669.000000f);
1623     path.quadTo(250.071075f, 669.000000f, 251.535995f, 670.463989f);
1624     path.quadTo(253.000000f, 671.928955f, 253.000000f, 674.000000f);
1625     path.lineTo(253.000000f, 706.000000f);
1626     path.lineTo(251.000000f, 706.000000f);
1627     path.lineTo(251.000000f, 675.000000f);
1628     path.cubicTo(251.000000f, 672.790833f, 249.209137f, 671.000000f, 247.000000f, 671.000000f);
1629     path.lineTo(162.000000f, 671.000000f);
1630     path.cubicTo(159.790863f, 671.000000f, 158.000000f, 672.790833f, 158.000000f, 675.000000f);
1631     path.lineTo(158.000000f, 706.000000f);
1632     path.lineTo(156.000000f, 706.000000f);
1633     path.lineTo(156.000000f, 674.000000f);
1634     path.quadTo(156.000000f, 671.928955f, 157.464005f, 670.463989f);
1635     path.close();
1644     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1648     SkPath path;
1649     path.setFillType(SkPathFillType::kEvenOdd);
1650     path.moveTo(161.000000f, 925.000000f);
1651     path.cubicTo(159.874390f, 925.000000f, 158.835663f, 925.371948f, 158.000000f, 925.999634f);
1652     path.lineTo(158.000000f, 926.000000f);
1653     path.lineTo(1108.00000f, 926.000000f);
1654     path.lineTo(1108.00000f, 925.999634f);
1655     path.cubicTo(1107.16443f, 925.371948f, 1106.12561f, 925.000000f, 1105.00000f, 925.000000f);
1656     path.lineTo(161.000000f, 925.000000f);
1657     path.close();
1670     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1674     SkPath path;
1675     path.setFillType(SkPathFillType::kEvenOdd);
1676     path.moveTo(286.695129f, 291.000000f);
1677     path.lineTo(229.304855f, 561.000000f);
1678     path.lineTo(979.304871f, 561.000000f);
1679     path.lineTo(1036.69507f, 291.000000f);
1680     path.lineTo(286.695129f, 291.000000f);
1681     path.close();
1694     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1698     SkPath path;
1699     path.setFillType(SkPathFillType::kEvenOdd);
1700     path.moveTo(968.000000f, 14.0000000f);
1701     path.cubicTo(965.238586f, 14.0000000f, 963.000000f, 16.2385769f, 963.000000f, 19.0000000f);
1702     path.lineTo(963.000000f, 32.0000000f);
1703     path.cubicTo(963.000000f, 34.7614250f, 965.238586f, 37.0000000f, 968.000000f, 37.0000000f);
1704     path.lineTo(1034.00000f, 37.0000000f);
1705     path.cubicTo(1036.76147f, 37.0000000f, 1039.00000f, 34.7614250f, 1039.00000f, 32.0000000f);
1706     path.lineTo(1039.00000f, 19.0000000f);
1707     path.cubicTo(1039.00000f, 16.2385769f, 1036.76147f, 14.0000000f, 1034.00000f, 14.0000000f);
1708     path.lineTo(968.000000f, 14.0000000f);
1709     path.close();
1722     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1726     SkPath path;
1727     path.setFillType(SkPathFillType::kEvenOdd);
1728     path.moveTo(708.099182f, 7.09919119f);
1729     path.lineTo(708.099182f, 7.09920025f);
1730     path.quadTo(704.000000f, 11.2010098f, 704.000000f, 17.0000000f);
1731     path.lineTo(704.000000f, 33.0000000f);
1732     path.lineTo(705.000000f, 33.0000000f);
1733     path.lineTo(705.000000f, 17.0000000f);
1734     path.cubicTo(705.000000f, 13.4101496f, 706.455078f, 10.1601505f, 708.807617f, 7.80761385f);
1735     path.lineTo(708.099182f, 7.09919119f);
1736     path.close();
1743     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1747     SkPath path;
1748     path.setFillType(SkPathFillType::kEvenOdd);
1749     path.moveTo(1099.82886f, 7.17117119f);
1750     path.lineTo(1099.12134f, 7.87867832f);
1751     path.cubicTo(1099.66418f, 8.42157173f, 1100.00000f, 9.17157173f, 1100.00000f, 10.0000000f);
1752     path.lineTo(1100.00000f, 28.0000000f);
1753     path.cubicTo(1100.00000f, 29.6568546f, 1098.65686f, 31.0000000f, 1097.00000f, 31.0000000f);
1754     path.lineTo(1088.00000f, 31.0000000f);
1755     path.lineTo(1088.00000f, 32.0000000f);
1756     path.lineTo(1097.00000f, 32.0000000f);
1757     path.quadTo(1098.65686f, 32.0000000f, 1099.82886f, 30.8288002f);
1758     path.quadTo(1101.00000f, 29.6568546f, 1101.00000f, 28.0000000f);
1759     path.lineTo(1101.00000f, 10.0000000f);
1760     path.quadTo(1101.00000f, 8.34314537f, 1099.82886f, 7.17119980f);
1761     path.lineTo(1099.82886f, 7.17117119f);
1762     path.close();
1769     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1773     SkPath path;
1774     path.setFillType(SkPathFillType::kEvenOdd);
1775     path.moveTo(1037.17114f, 7.17119980f);
1776     path.quadTo(1038.34314f, 6.00000000f, 1040.00000f, 6.00000000f);
1777     path.lineTo(1074.00000f, 6.00000000f);
1778     path.lineTo(1074.00000f, 32.0000000f);
1779     path.lineTo(1040.00000f, 32.0000000f);
1780     path.quadTo(1038.34314f, 32.0000000f, 1037.17114f, 30.8288002f);
1781     path.quadTo(1036.00000f, 29.6568546f, 1036.00000f, 28.0000000f);
1782     path.lineTo(1036.00000f, 10.0000000f);
1783     path.quadTo(1036.00000f, 8.34314537f, 1037.17114f, 7.17119980f);
1784     path.close();
1785     path.moveTo(1037.00000f, 10.0000000f);
1786     path.cubicTo(1037.00000f, 8.34314537f, 1038.34314f, 7.00000000f, 1040.00000f, 7.00000000f);
1787     path.lineTo(1073.00000f, 7.00000000f);
1788     path.lineTo(1073.00000f, 31.0000000f);
1789     path.lineTo(1040.00000f, 31.0000000f);
1790     path.cubicTo(1038.34314f, 31.0000000f, 1037.00000f, 29.6568546f, 1037.00000f, 28.0000000f);
1791     path.lineTo(1037.00000f, 10.0000000f);
1792     path.close();
1799     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1803     SkPath path;
1804     path.setFillType(SkPathFillType::kWinding);
1805     path.moveTo(0,1);
1806     path.cubicTo(1,6, 1,0, 6,2);
1807     path.close();
1813     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1817     SkPath path;
1818     path.setFillType(SkPathFillType::kEvenOdd);
1819     path.moveTo(96, 122);
1820     path.cubicTo(94.6192932f, 122, 93.3692932f, 122.559647f, 92.4644699f, 123.46447f);
1821     path.lineTo(94.1715698f, 125.17157f);
1822     path.cubicTo(94.8954315f, 124.447708f, 95.8954315f, 124, 97, 124);
1823     path.lineTo(257, 124);
1824     path.cubicTo(258.104553f, 124, 259.104584f, 124.447708f, 259.82843f, 125.17157f);
1825     path.lineTo(261.535522f, 123.46447f);
1826     path.cubicTo(260.630707f, 122.559647f, 259.380707f, 122, 258, 122);
1827     path.lineTo(96, 122);
1828     path.close();
1841     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1983     SkPath path, pathB;
1984     path.setFillType(SkPathFillType::kWinding);
1985     path.moveTo(3, 4);
1986     path.cubicTo(1, 5, 4, 3, 6, 4);
1987     path.close();
1992     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2026     SkPath path, pathB;
2027     path.setFillType(SkPathFillType::kWinding);
2028     path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
2029     path.addRect(2, 2, 4, 4, SkPathDirection::kCW);
2033     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2037     SkPath path, pathB;
2038     path.setFillType(SkPathFillType::kEvenOdd);
2039     path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
2040     path.addRect(0, 0, 3, 3, SkPathDirection::kCW);
2044     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2048     SkPath path, pathB;
2049     path.setFillType(SkPathFillType::kEvenOdd);
2050     path.moveTo(0, 0);
2051     path.lineTo(3, 0);
2052     path.lineTo(3, 3);
2053     path.lineTo(0, 3);
2054     path.close();
2055     path.moveTo(2, 2);
2056     path.lineTo(3, 2);
2057     path.lineTo(3, 3);
2058     path.lineTo(2, 3);
2059     path.close();
2071     testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
2126     SkPath path;
2127     path.setFillType(SkPathFillType::kEvenOdd);
2128     path.moveTo(1173, 284);
2129     path.cubicTo(1173, 285.125824f, 1173.37207f, 286.164734f, 1174, 287.000488f);
2130     path.lineTo(1174, 123.999496f);
2131     path.cubicTo(1173.37207f, 124.835243f, 1173, 125.874168f, 1173, 127);
2132     path.lineTo(1173, 284);
2133     path.close();
2146     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2150     SkPath path;
2151     path.setFillType(SkPathFillType::kEvenOdd);
2152     path.moveTo(0,0);
2153     path.lineTo(3,0);
2154     path.lineTo(3,2);
2155     path.lineTo(1,2);
2156     path.lineTo(1,1);
2157     path.lineTo(2,1);
2158     path.lineTo(2,3);
2159     path.lineTo(0,3);
2160     path.close();
2168     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2172     SkPath path;
2173     path.setFillType(SkPathFillType::kEvenOdd);
2174     path.moveTo(0,0);
2175     path.lineTo(3,0);
2176     path.lineTo(3,2);
2177     path.lineTo(1,2);
2178     path.lineTo(1,1);
2179     path.lineTo(2,1);
2180     path.lineTo(2,3);
2181     path.lineTo(0,3);
2182     path.close();
2190     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2194     SkPath path, pathB;
2195     path.setFillType(SkPathFillType::kWinding);
2196     path.moveTo(0, 4);
2197     path.cubicTo(3, 4, 6, 2, 5, 2);
2198     path.close();
2203     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2207     SkPath path, pathB;
2208     path.setFillType(SkPathFillType::kWinding);
2209     path.moveTo(0,1);
2210     path.cubicTo(0,2, 2,0, 6,4);
2211     path.close();
2217     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2221     SkPath path, pathB;
2222     path.setFillType(SkPathFillType::kWinding);
2223     path.moveTo(0,1);
2224     path.cubicTo(2,5, 5,0, 6,4);
2225     path.close();
2230     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2234     SkPath path, pathB;
2235     path.setFillType(SkPathFillType::kWinding);
2236     path.moveTo(0, 3);
2237     path.cubicTo(1, 6, 5, 0, 6, 3);
2238     path.close();
2243     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2247     SkPath path, pathB;
2248     path.setFillType(SkPathFillType::kEvenOdd);
2249     path.moveTo(0, 5);
2250     path.cubicTo(1, 2, 5, 2, 4, 1);
2251     path.close();
2256     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2260     SkPath path, pathB;
2261     path.setFillType(SkPathFillType::kWinding);
2262     path.moveTo(1, 6);
2263     path.cubicTo(0, 3, 6, 3, 5, 0);
2264     path.close();
2269     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2273     SkPath path;
2274     path.setFillType(SkPathFillType::kEvenOdd);
2275    path.moveTo(-1.24344979e-014f, 348);
2276     path.lineTo(258, 348);
2277     path.lineTo(258, 322);
2278     path.quadTo(258, 317.857849f, 255.072006f, 314.928009f);
2279     path.quadTo(252.142136f, 312, 248, 312);
2280     path.lineTo(1.77635684e-015f, 312);
2281     path.lineTo(-1.24344979e-014f, 348);
2282     path.close();
2290     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2294     SkPath path;
2295     path.setFillType(SkPathFillType::kEvenOdd);
2296     path.moveTo(1.99840144e-015f, 494);
2297     path.lineTo(97, 494);
2298     path.quadTo(100.313705f, 494, 102.6576f, 491.657593f);
2299     path.quadTo(105, 489.313721f, 105, 486);
2300     path.lineTo(105, 425);
2301     path.quadTo(105, 421.686279f, 102.6576f, 419.342407f);
2302     path.quadTo(100.313705f, 417, 97, 417);
2303     path.lineTo(2.22044605e-016f, 417);
2304     path.lineTo(1.99840144e-015f, 494);
2305     path.close();
2313     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2317     SkPath path;
2318     path.setFillType(SkPathFillType::kEvenOdd);
2319     path.moveTo(670.537415f, 285);
2320     path.lineTo(670.387451f, 285);
2321     path.lineTo(596.315186f, 314.850708f);
2322     path.lineTo(626.19696f, 389);
2323     path.lineTo(626.346863f, 389);
2324     path.lineTo(700.419189f, 359.149261f);
2325     path.lineTo(670.537415f, 285);
2326     path.close();
2339     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2343     SkPath path;
2344     path.setFillType(SkPathFillType::kEvenOdd);
2345     path.moveTo(1.45716772e-016f, 924.336121f);
2346     path.lineTo(-1.11022302e-016f, 920);
2347     path.lineTo(6, 920);
2348     path.lineTo(6, 926);
2349     path.lineTo(1.66389287f, 926);
2350     path.quadTo(1.18842196f, 925.674561f, 0.756800175f, 925.243225f);
2351     path.quadTo(0.325406998f, 924.811523f, 1.45716772e-016f, 924.336121f);
2352     path.close();
2353     path.moveTo(1, 921);
2354     path.lineTo(5, 921);
2355     path.lineTo(5, 925);
2356     path.cubicTo(2.79086018f, 925, 1, 923.209167f, 1, 921);
2357     path.close();
2364     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2368     SkPath path;
2369     path.setFillType(SkPathFillType::kEvenOdd);
2370     path.moveTo(320.097229f, 628.573669f);
2371     path.lineTo(610.227173f, 85.7786865f);
2372     path.lineTo(946.652588f, 265.601807f);
2373     path.lineTo(656.522644f, 808.39679f);
2374     path.lineTo(320.097229f, 628.573669f);
2375     path.close();
2388     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2392     SkPath path;
2393     path.setFillType(SkPathFillType::kEvenOdd);
2394     path.moveTo(0, 926);
2395     path.lineTo(0, 0);
2396     path.lineTo(1280, 0);
2397     path.lineTo(1280, 926);
2398     path.lineTo(0, 926);
2399     path.close();
2407     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2411     SkPath path;
2412     path.setFillType(SkPathFillType::kEvenOdd);
2413     path.moveTo(205.605804f, 142.334625f);
2414     path.lineTo(254.665359f, 85.6058044f);
2415     path.lineTo(311.394196f, 134.665359f);
2416     path.lineTo(262.334625f, 191.39418f);
2417     path.lineTo(205.605804f, 142.334625f);
2418     path.close();
2431     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2435     SkPath path;
2436     path.setFillType(SkPathFillType::kEvenOdd);
2437     path.moveTo(-4.4408921e-016f, 682.5f);
2438     path.lineTo(30.5f, 682.5f);
2439     path.cubicTo(32.709137f, 682.5f, 34.5f, 680.709167f, 34.5f, 678.5f);
2440     path.lineTo(34.5f, 486.5f);
2441     path.cubicTo(34.5f, 484.290863f, 32.709137f, 482.5f, 30.5f, 482.5f);
2442     path.lineTo(0, 482.5f);
2443     path.lineTo(-4.4408921e-016f, 682.5f);
2444     path.close();
2452     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2456     SkPath path;
2457     path.setFillType(SkPathFillType::kEvenOdd);
2458     path.moveTo(324.071075f, 845.071045f);
2459     path.cubicTo(324.405151f, 844.737f, 324.715668f, 844.379395f, 325, 844.000977f);
2460     path.lineTo(325, 842.127197f);
2461     path.cubicTo(324.571411f, 842.956238f, 324.017761f, 843.710144f, 323.363953f, 844.363953f);
2462     path.lineTo(324.071075f, 845.071045f);
2463     path.close();
2464     path.moveTo(323.363953f, 714.636047f);
2465     path.lineTo(324.071075f, 713.928955f);
2466     path.cubicTo(324.405151f, 714.263f, 324.715668f, 714.620605f, 325, 714.999023f);
2467     path.lineTo(325, 716.872803f);
2468     path.cubicTo(324.571411f, 716.043762f, 324.017761f, 715.289856f, 323.363953f, 714.636047f);
2469     path.close();
2482     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2486     SkPath path, pathB;
2487     path.setFillType(SkPathFillType::kWinding);
2488     path.moveTo(0, 1);
2489     path.cubicTo(2, 6, 4, 1, 5, 4);
2490     path.close();
2495     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2499     SkPath path, pathB;
2500     path.setFillType(SkPathFillType::kWinding);
2501     path.moveTo(0, 1);
2502     path.cubicTo(1, 6, 4, 1, 4, 3);
2503     path.close();
2508     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2512     SkPath path, pathB;
2513     path.setFillType(SkPathFillType::kEvenOdd);
2514     path.moveTo(0, 3);
2515     path.cubicTo(2, 3, 5, 0, 5, 3);
2516     path.close();
2521     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2525     SkPath path;
2526     path.setFillType(SkPathFillType::kEvenOdd);
2527     path.moveTo(333.292084f, 624.570984f);
2528     path.lineTo(614.229797f, 98.9735107f);
2529     path.lineTo(933.457764f, 269.604431f);
2530     path.lineTo(652.52002f, 795.201904f);
2531     path.lineTo(333.292084f, 624.570984f);
2532     path.close();
2545     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2549     SkPath path;
2550     path.setFillType(SkPathFillType::kEvenOdd);
2551     path.moveTo(802, 367);
2552     path.lineTo(802, 324);
2553     path.lineTo(956, 324);
2554     path.lineTo(956, 371);
2555     path.quadTo(956, 373.071075f, 954.536011f, 374.536011f);
2556     path.quadTo(953.071045f, 376, 951, 376);
2557     path.lineTo(811, 376);
2558     path.cubicTo(806.029419f, 376, 802, 371.970551f, 802, 367);
2559     path.close();
2570     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2574     SkPath path;
2575     path.setFillType(SkPathFillType::kEvenOdd);
2576     path.moveTo(-2.220446e-018f, 483.5f);
2577     path.lineTo(0, 482.5f);
2578     path.lineTo(30.5f, 482.5f);
2579     path.cubicTo(32.709137f, 482.5f, 34.5f, 484.290863f, 34.5f, 486.5f);
2580     path.lineTo(34.5f, 678.5f);
2581     path.cubicTo(34.5f, 680.709167f, 32.709137f, 682.5f, 30.5f, 682.5f);
2582     path.lineTo(-4.4408921e-016f, 682.5f);
2583     path.lineTo(-4.41868766e-016f, 681.5f);
2584     path.lineTo(30.5f, 681.5f);
2585     path.cubicTo(32.1568565f, 681.5f, 33.5f, 680.15686f, 33.5f, 678.5f);
2586     path.lineTo(33.5f, 486.5f);
2587     path.cubicTo(33.5f, 484.84314f, 32.1568565f, 483.5f, 30.5f, 483.5f);
2588     path.lineTo(-2.220446e-018f, 483.5f);
2589     path.close();
2597     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2601     SkPath path;
2602     path.setFillType(SkPathFillType::kEvenOdd);
2603     path.moveTo(1182.00037f, 926);
2604     path.cubicTo(1181.08813f, 924.785583f, 1179.63586f, 924, 1178, 924);
2605     path.lineTo(938, 924);
2606     path.cubicTo(936.364197f, 924, 934.911865f, 924.785583f, 933.999634f, 926);
2607     path.lineTo(1182.00037f, 926);
2608     path.close();
2616     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2620     SkPath path;
2621     path.setFillType(SkPathFillType::kEvenOdd);
2622     path.moveTo(925, 27);
2623     path.cubicTo(924.447693f, 27, 924, 27.4477158f, 924, 28);
2624     path.lineTo(924, 55);
2625     path.cubicTo(924, 55.5522842f, 924.447693f, 56, 925, 56);
2626     path.lineTo(1103, 56);
2627     path.cubicTo(1103.55225f, 56, 1104, 55.5522842f, 1104, 55);
2628     path.lineTo(1104, 28);
2629     path.cubicTo(1104, 27.4477158f, 1103.55225f, 27, 1103, 27);
2630     path.lineTo(925, 27);
2631     path.close();
2644     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2648     SkPath path;
2649     path.setFillType(SkPathFillType::kEvenOdd);
2650     path.moveTo(190, 170);
2651     path.cubicTo(178.9543f, 170, 170, 178.9543f, 170, 190);
2652     path.cubicTo(170, 201.0457f, 178.9543f, 210, 190, 210);
2653     path.lineTo(370, 210);
2654     path.cubicTo(381.045685f, 210, 390, 201.0457f, 390, 190);
2655     path.cubicTo(390, 178.9543f, 381.045685f, 170, 370, 170);
2656     path.lineTo(190, 170);
2657     path.close();
2670     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2674     SkPath path;
2675     path.setFillType(SkPathFillType::kEvenOdd);
2676     path.moveTo(47.8780937f, 58);
2677     path.lineTo(0, 58);
2678     path.lineTo(-8.65973959e-015f, 96.9914017f);
2679     path.quadTo(20.0654926f, 96.6451874f, 34.3553391f, 82.3553391f);
2680     path.quadTo(44.9466133f, 71.764061f, 47.8780937f, 58);
2681     path.close();
2694     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2698     SkPath path;
2699     path.setFillType(SkPathFillType::kEvenOdd);
2700     path.moveTo(693.000488f, 926);
2701     path.cubicTo(692.164734f, 925.37207f, 691.125793f, 925, 690, 925);
2702     path.lineTo(578, 925);
2703     path.cubicTo(576.874207f, 925, 575.835266f, 925.37207f, 574.999512f, 926);
2704     path.lineTo(693.000488f, 926);
2705     path.close();
2713     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2717     SkPath path;
2718     path.setFillType(SkPathFillType::kEvenOdd);
2719     path.moveTo(195, 785);
2720     path.cubicTo(124.307556f, 785, 67, 841.859863f, 67, 912);
2721     path.lineTo(67, 913);
2722     path.cubicTo(67, 917.388916f, 67.2243805f, 921.725769f, 67.662384f, 926);
2723     path.lineTo(322, 926);
2724     path.lineTo(322, 896.048035f);
2725     path.cubicTo(314.09201f, 833.437622f, 260.247131f, 785, 195, 785);
2726     path.close();
2737     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2741     SkPath path;
2742     path.setFillType(SkPathFillType::kEvenOdd);
2743     path.moveTo(945, 597);
2744     path.quadTo(913.93396f, 597, 891.96698f, 618.96698f);
2745     path.quadTo(870, 640.93396f, 870, 672);
2746     path.quadTo(870, 703.06604f, 891.96698f, 725.03302f);
2747     path.quadTo(913.93396f, 747, 945, 747);
2748     path.quadTo(976.06604f, 747, 998.03302f, 725.03302f);
2749     path.quadTo(1020, 703.06604f, 1020, 672);
2750     path.quadTo(1020, 640.93396f, 998.03302f, 618.96698f);
2751     path.quadTo(976.06604f, 597, 945, 597);
2752     path.close();
2763     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2767     SkPath path;
2768     path.setFillType(SkPathFillType::kEvenOdd);
2769     path.moveTo(0, 926);
2770     path.lineTo(0, 0);
2771     path.lineTo(1265, 0);
2772     path.lineTo(1265, 926);
2773     path.lineTo(0, 926);
2774     path.close();
2782     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2786     SkPath path;
2787     path.setFillType(SkPathFillType::kEvenOdd);
2788     path.moveTo(883, 23);
2789     path.lineTo(883, 0);
2790     path.lineTo(1122.5f, 0);
2791     path.lineTo(1122.5f, 25.2136822f);
2792     path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2793     path.quadTo(1120.07104f, 28, 1118, 28);
2794     path.lineTo(888, 28);
2795     path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2796     path.quadTo(883, 25.0710678f, 883, 23);
2797     path.close();
2809     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2813     SkPath path;
2814     path.setFillType(SkPathFillType::kEvenOdd);
2815     path.moveTo(883, 23);
2816     path.lineTo(883, 0);
2817     path.lineTo(1122.5f, 0);
2818     path.lineTo(1122.5f, 25.2136822f);
2819     path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2820     path.quadTo(1120.07104f, 28, 1118, 28);
2821     path.lineTo(888, 28);
2822     path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2823     path.quadTo(883, 25.0710678f, 883, 23);
2824     path.close();
2836     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2840     SkPath path;
2841     path.setFillType(SkPathFillType::kEvenOdd);
2842     path.moveTo(896, 745.38678f);
2843     path.lineTo(896, 873.38678f);
2844     path.lineTo(922.567993f, 876.683716f);
2845     path.lineTo(922.567993f, 748.683716f);
2846     path.lineTo(896, 745.38678f);
2847     path.close();
2860     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2864     SkPath path;
2865     path.setFillType(SkPathFillType::kEvenOdd);
2866     path.moveTo(1104, 453);
2867     path.lineTo(399, 453);
2868     path.lineTo(399, 657);
2869     path.cubicTo(399, 661.970581f, 403.029449f, 666, 408, 666);
2870     path.lineTo(1095, 666);
2871     path.cubicTo(1099.97058f, 666, 1104, 661.970581f, 1104, 657);
2872     path.lineTo(1104, 453);
2873     path.close();
2883     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2887     SkPath path;
2888     path.setFillType(SkPathFillType::kEvenOdd);
2889     path.moveTo(883, 23);
2890     path.lineTo(883, 0);
2891     path.lineTo(1122.5f, 0);
2892     path.lineTo(1122.5f, 25.2136822f);
2893     path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2894     path.quadTo(1120.07104f, 28, 1118, 28);
2895     path.lineTo(888, 28);
2896     path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2897     path.quadTo(883, 25.0710678f, 883, 23);
2898     path.close();
2910     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2914     SkPath path;
2915     path.setFillType(SkPathFillType::kEvenOdd);
2916     path.moveTo(883, 23);
2917     path.lineTo(883, 0);
2918     path.lineTo(1122.5f, 0);
2919     path.lineTo(1122.5f, 25.2136822f);
2920     path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2921     path.quadTo(1120.07104f, 28, 1118, 28);
2922     path.lineTo(888, 28);
2923     path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2924     path.quadTo(883, 25.0710678f, 883, 23);
2925     path.close();
2937     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2941     SkPath path;
2942     path.setFillType(SkPathFillType::kEvenOdd);
2943     path.moveTo(160.000488f, 918);
2944     path.cubicTo(159.164749f, 917.37207f, 158.125824f, 917, 157, 917);
2945     path.lineTo(94, 917);
2946     path.cubicTo(92.874176f, 917, 91.8352661f, 917.37207f, 90.9995193f, 918);
2947     path.lineTo(160.000488f, 918);
2948     path.close();
2956     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2960     SkPath path;
2961     path.setFillType(SkPathFillType::kEvenOdd);
2962     path.moveTo(1138, 231);
2963     path.lineTo(1137, 243.625748f);
2964     path.lineTo(1137, 926);
2965     path.lineTo(1139, 926);
2966     path.lineTo(1139, 231);
2967     path.lineTo(1138, 231);
2968     path.close();
2975     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2979     SkPath path, pathB;
2980     path.setFillType(SkPathFillType::kEvenOdd);
2981     path.moveTo(0, 2);
2982     path.cubicTo(2, 3, 5, 1, 3, 2);
2983     path.close();
2988     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2992     SkPath path, pathB;
2993     path.setFillType(SkPathFillType::kEvenOdd);
2994     path.moveTo(1, 6);
2995     path.cubicTo(0, 3, 6, 3, 5, 0);
2996     path.close();
3001     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3005     SkPath path, pathB;
3006     path.setFillType(SkPathFillType::kEvenOdd);
3007     path.moveTo(0, 2);
3008     path.cubicTo(0, 6, 2, 1, 2, 1);
3009     path.close();
3014     testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
3018     SkPath path, pathB;
3019     path.setFillType(SkPathFillType::kEvenOdd);
3020     path.moveTo(0, 3);
3021     path.cubicTo(3, 6, 4, 1, 6, 3);
3022     path.close();
3027     testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
3031     SkPath path, pathB;
3032     path.setFillType(SkPathFillType::kWinding);
3033     path.moveTo(3,6);
3034     path.cubicTo(0,3, 6,5, 5,4);
3035     path.close();
3040     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3044     SkPath path, pathB;
3045     path.setFillType(SkPathFillType::kWinding);
3046     path.moveTo(0,1);
3047     path.cubicTo(0,2, 2,1, 4,2);
3048     path.close();
3053     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3057     SkPath path, pathB;
3058     path.setFillType(SkPathFillType::kWinding);
3059     path.moveTo(0, 1);
3060     path.cubicTo(2, 3, 2, 1, 5, 3);
3061     path.close();
3066     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3070     SkPath path, pathB;
3071     path.setFillType(SkPathFillType::kWinding);
3072     path.moveTo(0,1);
3073     path.cubicTo(1,2, 1,0, 3,0);
3074     path.close();
3079     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3083     SkPath path, pathB;
3084     path.setFillType(SkPathFillType::kWinding);
3085     path.moveTo(0,1);
3086     path.cubicTo(1,5, 2,0, 2,1);
3087     path.close();
3092     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3096     SkPath path, pathB;
3097     path.setFillType(SkPathFillType::kWinding);
3098     path.moveTo(0,1);
3099     path.cubicTo(0,6, 4,0, 6,1);
3100     path.close();
3105     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3109     SkPath path, pathB;
3110     path.setFillType(SkPathFillType::kWinding);
3111     path.moveTo(0,1);
3112     path.cubicTo(0,4, 6,5, 2,0);
3113     path.close();
3118     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3122     SkPath path, pathB;
3123     path.setFillType(SkPathFillType::kWinding);
3124     path.moveTo(0, 1);
3125     path.cubicTo(4, 6, 2, 1, 2, 0);
3126     path.close();
3131     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3135     SkPath path, pathB;
3136     path.setFillType(SkPathFillType::kWinding);
3137     path.moveTo(0, 1);
3138     path.cubicTo(4, 6, 2, 1, 2, 0);
3139     path.close();
3144     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3148     SkPath path, pathB;
3149     path.setFillType(SkPathFillType::kWinding);
3150     path.moveTo(0, 1);
3151     path.cubicTo(4, 6, 2, 1, 2, 0);
3152     path.close();
3157     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3161     SkPath path, pathB;
3162     path.setFillType(SkPathFillType::kWinding);
3163     path.moveTo(0,1);
3164     path.cubicTo(4,5, 6,3, 5,4);
3165     path.close();
3170     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3174     SkPath path, pathB;
3175     path.setFillType(SkPathFillType::kEvenOdd);
3176     path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
3177     path.addRect(0, 0, 4, 4, SkPathDirection::kCW);
3181     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3185     SkPath path, pathB;
3186     path.setFillType(SkPathFillType::kWinding);
3187     path.moveTo(1,4);
3188     path.cubicTo(0,5, 4,1, 3,1);
3189     path.close();
3194     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3198     SkPath path, pathB;
3199     path.setFillType(SkPathFillType::kEvenOdd);
3200     path.moveTo(1, 4);
3201     path.cubicTo(4, 5, 3, 2, 6, 3);
3202     path.close();
3207     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3211     SkPath path, pathB;
3212     path.setFillType(SkPathFillType::kEvenOdd);
3213     path.moveTo(1, 4);
3214     path.cubicTo(1, 5, 6, 0, 5, 1);
3215     path.close();
3220     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3224     SkPath path, pathB;
3225     path.setFillType(SkPathFillType::kEvenOdd);
3226     path.moveTo(1, 5);
3227     path.cubicTo(0, 4, 3, 2, 6, 1);
3228     path.close();
3233     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3237     SkPath path, pathB;
3238     path.setFillType(SkPathFillType::kWinding);
3239     path.moveTo(1,4);
3240     path.cubicTo(0,5, 4,1, 3,1);
3241     path.close();
3246     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3250     SkPath path, pathB;
3251     path.setFillType(SkPathFillType::kWinding);
3252     path.moveTo(0,1);
3253     path.cubicTo(1,6, 5,0, 2,1);
3254     path.close();
3259     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3263     SkPath path, pathB;
3264     path.setFillType(SkPathFillType::kWinding);
3265     path.moveTo(2,4);
3266     path.cubicTo(2,3, 6,4, 1,0);
3267     path.close();
3272     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3276     SkPath path, pathB;
3277     path.moveTo(2,4);
3278     path.cubicTo(3,5, 2.33333325f,4.33333349f, 3.83333325f,3.83333349f);
3279     path.close();
3283     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3287     SkPath path, pathB;
3288     path.setFillType(SkPathFillType::kWinding);
3289     path.moveTo(0, 1);
3290     path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
3291     path.close();
3296     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3300     SkPath path, pathB;
3301     path.setFillType(SkPathFillType::kWinding);
3302     path.moveTo(0, 1);
3303     path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
3304     path.close();
3310     CubicPathToQuads(path, &qPath);
3316     SkPath path, pathB;
3317     path.moveTo(0, 0);
3318     path.quadTo(1, 8, 3, 5);
3319     path.lineTo(8, 1);
3320     path.close();
3324     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3386     SkPath path, pathB;
3387     path.setFillType(SkPathFillType::kEvenOdd);
3388     path.moveTo(0, 0);
3389     path.lineTo(1, 0);
3390     path.lineTo(1, 1);
3391     path.lineTo(0, 1);
3392     path.close();
3393     path.moveTo(0, 0);
3394     path.lineTo(6, 0);
3395     path.lineTo(6, 6);
3396     path.lineTo(0, 6);
3397     path.close();
3409     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3413     SkPath path, pathB;
3414     path.setFillType(SkPathFillType::kEvenOdd);
3415     path.moveTo(0, 0);
3416     path.lineTo(4, 0);
3417     path.lineTo(4, 4);
3418     path.lineTo(0, 4);
3419     path.close();
3420     path.moveTo(3, 3);
3421     path.lineTo(4, 3);
3422     path.lineTo(4, 4);
3423     path.lineTo(3, 4);
3424     path.close();
3436     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3440     SkPath path, pathB;
3441     path.setFillType(SkPathFillType::kEvenOdd);
3442     path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
3443     path.addRect(0, 0, 4, 4, SkPathDirection::kCW);
3447     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3451     SkPath path, pathB;
3452     path.setFillType(SkPathFillType::kEvenOdd);
3453     path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
3454     path.addRect(0, 0, 2, 2, SkPathDirection::kCW);
3458     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3510     SkPath path, pathB;
3511     path.setFillType(SkPathFillType::kWinding);
3512     path.moveTo(0,1);
3513     path.cubicTo(3,4, 2,1, 5,3);
3514     path.close();
3519     SkPath path2(path);
3520     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3524     SkPath path, path2;
3525     path.addRect(0, 0, 60, 60, SkPathDirection::kCCW);
3526     path.addRect(30, 20, 50, 50, SkPathDirection::kCCW);
3527     path.addRect(24, 20, 36, 30, SkPathDirection::kCCW);
3528 //    path.addRect(32, 24, 36, 41, SkPathDirection::kCCW);
3529     testPathOp(reporter, path, path2, kUnion_SkPathOp, filename);
3533     SkPath path, pathB;
3534     path.setFillType(SkPathFillType::kWinding);
3535     path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
3536     path.addRect(4, 4, 5, 5, SkPathDirection::kCW);
3540     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3544     SkPath path, pathB;
3545     path.setFillType(SkPathFillType::kWinding);
3546     path.moveTo(0,1);
3547     path.cubicTo(4,6, 2,0, 2,0);
3548     path.close();
3553     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3557     SkPath path, pathB;
3558     path.setFillType(SkPathFillType::kWinding);
3559     path.moveTo(0,1);
3560     path.cubicTo(4,5, 6,0, 1,0);
3561     path.close();
3566     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3570     SkPath path, pathB;
3571     path.setFillType(SkPathFillType::kWinding);
3572     path.moveTo(0,1);
3573     path.cubicTo(4,6, 5,1, 6,2);
3574     path.close();
3579     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3583     SkPath path, pathB;
3584     path.moveTo(0,1);
3585     path.cubicTo(1,5, -5.66666651f,3.33333349f, 8.83333302f,2.33333349f);
3586     path.close();
3590     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3613     SkPath path, pathB;
3614     path.moveTo(q1a[0].fPts[0].asSkPoint());
3615     path.quadTo(q1a[0].fPts[1].asSkPoint(), q1a[0].fPts[2].asSkPoint());
3616     path.quadTo(q1a[1].fPts[1].asSkPoint(), q1a[1].fPts[2].asSkPoint());
3617     path.quadTo(q1[1].fPts[1].asSkPoint(), q1[1].fPts[2].asSkPoint());
3618     path.close();
3623     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3627     SkPath path, pathB;
3628     path.moveTo(0,1);
3629     path.cubicTo(3,4, 3.f,4.f, 4.5f,1.5f);
3630     path.close();
3634     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3638     SkPath path, pathB;
3639     path.moveTo(0,1);
3640     path.cubicTo(3,5, -3.66666651f,0, 10.5f,-1.66666651f);
3641     path.close();
3645     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3649     SkPath path, pathB;
3650     path.moveTo(0,5);
3651     path.cubicTo(1,5, 1,4, 0.833333313f,3);
3652     path.close();
3656     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3662     SkPath path, pathB;
3665     SkParsePath::FromSVGString(str, &path);
3669     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3673     SkPath path, pathB;
3674     path.setFillType(SkPathFillType::kWinding);
3675     path.moveTo(0,1);
3676     path.cubicTo(3,5, 2,1, 3,1);
3677     path.close();
3682     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3686     SkPath path, pathB;
3687     path.setFillType(SkPathFillType::kWinding);
3688     path.moveTo(0,1);
3689     path.cubicTo(2,4, 2,1, 4,0);
3690     path.close();
3695     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3699     SkPath path, pathB;
3700     path.setFillType(SkPathFillType::kWinding);
3701     path.moveTo(0,1);
3702     path.cubicTo(3,4, 3,2, 4,3);
3703     path.close();
3708     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3713     SkPath path, pathB;
3714     path.setFillType(SkPathFillType::kWinding);
3715     path.moveTo(0,1);
3716     path.cubicTo(3,5, 4,1, 4,0);
3717     path.close();
3722     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3726     SkPath path, pathB;
3727     path.setFillType(SkPathFillType::kWinding);
3728     path.moveTo(0,1);
3729     path.cubicTo(1,5, 2,0, 6,0);
3730     path.close();
3735     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3739     SkPath path, pathB;
3740     path.moveTo(0,2);
3741     path.cubicTo(1,2, 1,1.66666663f, 0.833333313f,1.33333325f);
3742     path.close();
3746     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3750     SkPath path, pathB;
3751     path.moveTo(0,1);
3752     path.cubicTo(1,3, -1.66666675f,1.66666663f, 4.16666651f,1.00000012f);
3753     path.close();
3757     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3761     SkPath path, pathB;
3762     path.setFillType(SkPathFillType::kWinding);
3763     path.moveTo(0,1);
3764     path.cubicTo(1,5, 6,0, 3,0);
3765     path.close();
3770     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3774     SkPath path, pathB;
3775     path.setFillType(SkPathFillType::kWinding);
3776     path.moveTo(0,1);
3777     path.cubicTo(3,6, 3,1, 6,2);
3778     path.close();
3783     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3787     SkPath path, pathB;
3788     path.setFillType(SkPathFillType::kWinding);
3789     path.moveTo(0,1);
3790     path.cubicTo(0,3, 6,0, 2,1);
3791     path.close();
3796     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3800     SkPath path, pathB;
3801     path.setFillType(SkPathFillType::kWinding);
3802     path.moveTo(0,1);
3803     path.cubicTo(1,5, 6,0, 3,0);
3804     path.close();
3809     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3813     SkPath path, pathB;
3814     path.setFillType(SkPathFillType::kWinding);
3815     path.moveTo(0,1);
3816     path.cubicTo(0,3, 3,2, 5,2);
3817     path.close();
3822     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3826     SkPath path, pathB;
3827     path.setFillType(SkPathFillType::kWinding);
3828     path.moveTo(5,6);
3829     path.cubicTo(3,4, 2,0, 2,1);
3830     path.close();
3835     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3839     SkPath path, pathB;
3840     path.setFillType(SkPathFillType::kWinding);
3841     path.moveTo(5,6);
3842     path.cubicTo(4,6, 3,0, 2,1);
3843     path.close();
3848     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3853 static void complex_to_quads(const SkPoint pts[], SkPath* path) {
3863         path->quadTo(q1[1].asSkPoint(), q1[2].asSkPoint());
3864         path->quadTo(q2[1].asSkPoint(), q2[2].asSkPoint());
3866         path->cubicTo(pts[1], pts[2], pts[3]);
3871     SkPath path, pathB;
3872     path.setFillType(SkPathFillType::kWinding);
3873     path.moveTo(5,6);
3875     complex_to_quads(pts, &path);
3876     path.close();
3880     complex_to_quads(pts2, &path);
3882     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3886     SkPath path, pathB;
3887     path.setFillType(SkPathFillType::kWinding);
3888     path.moveTo(0,1);
3889     path.cubicTo(3,4, 3,0, 6,2);
3890     path.close();
3895     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3899     SkPath path, pathB;
3900     path.setFillType(SkPathFillType::kWinding);
3901     path.addCircle(0, 1, 2, SkPathDirection::kCCW);
3904     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3908     SkPath path, pathB;
3909     path.setFillType(SkPathFillType::kWinding);
3910     path.addCircle(0, 1, 4, SkPathDirection::kCCW);
3913     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3917     SkPath path, pathB;
3918     path.setFillType(SkPathFillType::kEvenOdd);
3919     path.moveTo(20.65f, 5.65f);
3920     path.conicTo(20.65f, 1.13612f, 25.1404f, 0.65f, 0.888488f);
3921     path.lineTo(25.65f, 0.65f);
3922     path.lineTo(26.1596f, 0.67604f);
3923     path.conicTo(30.65f, 1.13612f, 30.65f, 5.65f, 0.888488f);
3924     path.lineTo(30.65f, 25.65f);
3925     path.conicTo(30.65f, 20.65f, 25.65f, 20.65f, 0.707107f);
3926     path.lineTo(20.65f, 20.65f);
3927     path.lineTo(20.65f, 5.65f);
3928     path.close();
3929     path.moveTo(20.65f, 20.65f);
3930     path.lineTo(5.65f, 20.65f);
3931     path.conicTo(0.65f, 20.65f, 0.65f, 25.65f, 0.707107f);
3932     path.lineTo(0.65f, 45.65f);
3933     path.conicTo(0.65f, 50.65f, 5.65f, 50.65f, 0.707107f);
3934     path.lineTo(25.65f, 50.65f);
3935     path.conicTo(30.65f, 50.65f, 30.65f, 45.65f, 0.707107f);
3936     path.lineTo(30.65f, 25.65f);
3937     path.conicTo(30.65f, 30.65f, 25.65f, 30.65f, 0.707107f);
3938     path.conicTo(20.65f, 30.65f, 20.65f, 25.65f, 0.707107f);
3939     path.lineTo(20.65f, 20.65f);
3940     path.close();
3941     SkPath path1(path);
3943     path.reset();
3944     path.setFillType(SkPathFillType::kWinding);
3945     path.moveTo(20.65f, 45.65f);
3946     path.lineTo(20.65f, 25.65f);
3947     path.conicTo(20.65f, 20.65f, 25.65f, 20.65f, 0.707107f);
3948     path.lineTo(45.65f, 20.65f);
3949     path.conicTo(50.65f, 20.65f, 50.65f, 25.65f, 0.707107f);
3950     path.lineTo(50.65f, 45.65f);
3951     path.conicTo(50.65f, 50.65f, 45.65f, 50.65f, 0.707107f);
3952     path.lineTo(25.65f, 50.65f);
3953     path.conicTo(20.65f, 50.65f, 20.65f, 45.65f, 0.707107f);
3954     path.close();
3955     SkPath path2(path);
3961     SkPath path, pathB;
3962     path.moveTo(0,1);
3963     path.cubicTo(3,4, -1,0, 8.5f,-2.5f);
3964     path.close();
3968     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3972     SkPath path, pathB;
3973     path.setFillType(SkPathFillType::kWinding);
3974     path.addRect(5, 5, 6, 6, SkPathDirection::kCW);
3975     path.addRect(5, 5, 6, 6, SkPathDirection::kCW);
3979     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3983     SkPath path, pathB;
3984     path.moveTo(0,1);
3985     path.cubicTo(1,4, -3.83333325f,0.166666627f, 6,-1);
3986     path.close();
3990     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3994     SkPath path, pathB;
3995     path.moveTo(0,1);
3996     path.cubicTo(1,3, -2.5f,0, 3.33333325f,-0.666666627f);
3997     path.close();
4001     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4005     SkPath path, pathB;
4006     path.setFillType(SkPathFillType::kWinding);
4007     path.addCircle(0, 1, 2, SkPathDirection::kCCW);
4010     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4014     SkPath path, pathB;
4015     path.moveTo(5,6);
4016     path.cubicTo(1,2, 1,2, -3.66666651f,13.333334f);
4017     path.close();
4021     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4025     SkPath path, pathB;
4026     path.moveTo(0,1);
4027     path.cubicTo(1,3, -1.83333349f,1.33333337f, 4,-1);
4028     path.close();
4032     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4036     SkPath path, pathB;
4037     path.setFillType(SkPathFillType::kWinding);
4038     path.moveTo(5,6);
4039     path.cubicTo(3,4, 3,0, 3,2);
4040     path.close();
4045     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4049     SkPath path, pathB;
4050     path.moveTo(1,2);
4051     path.cubicTo(0,6, -3.16666675f,3.66666675f, 6.33333349f,3.33333349f);
4052     path.close();
4056     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4060     SkPath path, pathB;
4061     path.setFillType(SkPathFillType::kWinding);
4062     path.moveTo(5,6);
4063     path.cubicTo(5,6, 5,0, 4,1);
4064     path.close();
4069     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4073     SkPath path, pathB;
4074     path.setFillType(SkPathFillType::kWinding);
4075     path.moveTo(5,6);
4076     path.cubicTo(5,6, 6,0, 3,1);
4077     path.close();
4082     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4086     SkPath path, pathB;
4087     path.setFillType(SkPathFillType::kWinding);
4088     path.moveTo(5,6);
4089     path.cubicTo(5,6, 6,0, 4,1);
4090     path.close();
4095     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4099     SkPath path, pathB;
4100     path.setFillType(SkPathFillType::kWinding);
4101     path.moveTo(5,6);
4102     path.cubicTo(5,6, 5,0, 3,1);
4103     path.close();
4108     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4112     SkPath path, pathB;
4113     path.setFillType(SkPathFillType::kWinding);
4114     path.moveTo(5,6);
4115     path.quadTo(5,0, 3,1);
4116     path.close();
4121     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4125     SkPath path, pathB;
4126     path.setFillType(SkPathFillType::kWinding);
4127     path.moveTo(0, 5);
4128     path.cubicTo(3, 6, 1, 0, 3, 2);
4129     path.close();
4134     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4138     SkPath path, pathB;
4139     path.setFillType(SkPathFillType::kWinding);
4140     path.moveTo(0, 5);
4141     path.cubicTo(3, 6, 1, 0, 4, 2);
4142     path.close();
4147     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4152     SkPath path, pathB;
4153     path.setFillType(SkPathFillType::kWinding);
4154     path.moveTo(0,2);
4155     path.cubicTo(0,4, 3,1, 5,1);
4156     path.close();
4161     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4165     SkPath path, pathB;
4166     path.setFillType(SkPathFillType::kWinding);
4167     path.moveTo(0,2);
4168     path.cubicTo(1,2, 5,4, 3,2);
4169     path.close();
4174     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4178     SkPath path, pathB;
4179     path.setFillType(SkPathFillType::kWinding);
4180     path.moveTo(0,2);
4181     path.cubicTo(1,2, 6,4, 3,2);
4182     path.close();
4187     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4191     SkPath path, pathB;
4192     path.moveTo(6,15);
4193     path.quadTo(16,0, 8,4);
4194     path.quadTo(2,7, 12,12);
4195     path.close();
4197     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4201     SkPath path, pathB;
4202     path.moveTo(5,12);
4203     path.quadTo(15,7, 9,4);
4204     path.quadTo(1,0, 11,15);
4205     path.close();
4207     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4211     SkPath path, pathB;
4212     path.moveTo(12,12);
4213     path.quadTo(2,7, 8,4);
4214     path.quadTo(16,0, 6,15);
4215     path.close();
4217     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4221     SkPath path, pathB;
4222     path.moveTo(11,15);
4223     path.quadTo(1,0, 9,4);
4224     path.quadTo(15,7, 5,12);
4225     path.close();
4227     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4231     SkPath path, pathB;
4232     path.moveTo(11,13);
4233     path.quadTo(4,4, 8,4);
4234     path.quadTo(12,4, 5,13);
4235     path.close();
4237     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4241     SkPath path, pathB;
4242     path.moveTo(5,13);
4243     path.quadTo(12,4, 8,4);
4244     path.quadTo(4,4, 11,13);
4245     path.close();
4247     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4251     SkPath path, pathB;
4252     path.setFillType(SkPathFillType::kWinding);
4253     path.moveTo(0, 3);
4254     path.cubicTo(0, 2, 0, 2, -1.66666663f, 2.16666675f);
4255     path.close();
4260     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4264     SkPath path, pathB;
4265     path.setFillType(SkPathFillType::kWinding);
4266     path.moveTo(1, 2);
4267     path.cubicTo(0, 2, 0, 2, 0.166666672f, 2.66666675f);
4268     path.close();
4273     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4277     SkPath path, pathB;
4278     path.setFillType(SkPathFillType::kWinding);
4279     path.moveTo(5,6);
4280     path.cubicTo(2,5, 2,1, 1,0);
4281     path.close();
4286     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4290     SkPath path, pathB;
4291     path.setFillType(SkPathFillType::kWinding);
4292     path.moveTo(3, 5);
4293     path.cubicTo(1, 5, 4, 2, 4, 0);
4294     path.close();
4299     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4303     SkPath path, pathB;
4304     path.setFillType(SkPathFillType::kWinding);
4305     path.moveTo(2, 6);
4306     path.cubicTo(2, 4, 5, 1, 3, 1);
4307     path.close();
4312     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4316     SkPath path, pathB;
4317     path.setFillType(SkPathFillType::kWinding);
4318     path.moveTo(2, 5);
4319     path.cubicTo(2, 4, 5, 1, 3, 2);
4320     path.close();
4325     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4329     SkPath path, pathB;
4330     path.setFillType(SkPathFillType::kWinding);
4331     path.moveTo(2, 4);
4332     path.cubicTo(2, 6, 3, 1, 5, 1);
4333     path.close();
4338     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4342     SkPath path, pathB;
4343     path.setFillType(SkPathFillType::kWinding);
4344     path.moveTo(2, 4);
4345     path.cubicTo(1, 6, 4, 1, 5, 1);
4346     path.close();
4351     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
4355     SkPath path, pathB;
4356     path.setFillType(SkPathFillType::kWinding);
4357     path.moveTo(2, 4);
4358     path.cubicTo(2, 5, 3, 2, 5, 1);
4359     path.close();
4364     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4368     SkPath path, pathB;
4369     path.setFillType(SkPathFillType::kWinding);
4370     path.moveTo(2, 4);
4371     path.cubicTo(0, 4, 5, 3, 5, 1);
4372     path.close();
4377     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4381     SkPath path, pathB;
4382     path.setFillType(SkPathFillType::kWinding);
4383     path.moveTo(2, 3);
4384     path.cubicTo(1, 5, 4, 2, 5, 2);
4385     path.close();
4390     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4394     SkPath path, pathB;
4395     path.setFillType(SkPathFillType::kWinding);
4396     path.moveTo(2, 3);
4397     path.cubicTo(0, 4, 3, 1, 3, 0);
4398     path.close();
4403     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4407     SkPath path, pathB;
4408     path.setFillType(SkPathFillType::kWinding);
4409     path.moveTo(1, 5);
4410     path.cubicTo(3, 5, 4, 0, 4, 2);
4411     path.close();
4416     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4420     SkPath path, pathB;
4421     path.setFillType(SkPathFillType::kWinding);
4422     path.moveTo(1, 5);
4423     path.cubicTo(2, 5, 5, 0, 4, 2);
4424     path.close();
4429     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4433     SkPath path, pathB;
4434     path.setFillType(SkPathFillType::kWinding);
4435     path.moveTo(1, 5);
4436     path.cubicTo(3, 4, 4, 1, 4, 2);
4437     path.close();
4442     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4446     SkPath path, pathB;
4447     path.setFillType(SkPathFillType::kWinding);
4448     path.moveTo(1, 5);
4449     path.cubicTo(1, 3, 4, 0, 2, 0);
4450     path.close();
4455     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4459     SkPath path, pathB;
4460     path.setFillType(SkPathFillType::kWinding);
4461     path.moveTo(1, 5);
4462     path.cubicTo(2, 3, 5, 2, 4, 2);
4463     path.close();
4468     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4472     SkPath path, pathB;
4473     path.setFillType(SkPathFillType::kWinding);
4474     path.moveTo(1,5);
4475     path.cubicTo(1,3, 6,2, 4,2);
4476     path.close();
4481     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4485     SkPath path, pathB;
4486     path.setFillType(SkPathFillType::kWinding);
4487     path.moveTo(1, 2);
4488     path.cubicTo(0, 3, 6, 0, 3, 2);
4489     path.close();
4494     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4498     SkPath path, pathB;
4499     path.setFillType(SkPathFillType::kWinding);
4500     path.moveTo(1, 2);
4501     path.cubicTo(0, 2, 0.833333313f, 2, 1, 3.66666651f);
4502     path.close();
4507     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4511     SkPath path, pathB;
4512     path.setFillType(SkPathFillType::kWinding);
4513     path.moveTo(1, 2);
4514     path.cubicTo(0, 2, 0.833333313f, 2, 1, 4);
4515     path.close();
4520     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4524     SkPath path, pathB;
4525     path.setFillType(SkPathFillType::kWinding);
4526     path.moveTo(1, 3);
4527     path.cubicTo(0, 3, 0.833333313f, 3, 1, 4.66666651f);
4528     path.close();
4533     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4537     SkPath path, pathB;
4538     path.setFillType(SkPathFillType::kWinding);
4539     path.moveTo(1, 5);
4540     path.cubicTo(0, 1, 6.16666698f, 5.66666698f, -5.66666651f, 6.66666651f);
4541     path.close();
4546     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4550     SkPath path, pathB;
4551     path.setFillType(SkPathFillType::kWinding);
4552     path.moveTo(1, 2);
4553     path.cubicTo(0, 2, 0.833333313f, 2, 1, 3);
4554     path.close();
4559     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4563     SkPath path, pathB;
4564     path.setFillType(SkPathFillType::kWinding);
4565     path.moveTo(1, 5);
4566     path.cubicTo(0, 5, 0.833333313f, 5, 1, 7);
4567     path.close();
4572     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4576     SkPath path, pathB;
4577     path.setFillType(SkPathFillType::kWinding);
4578     path.moveTo(1, 6);
4579     path.cubicTo(0, 2, 6.16666698f, 6.66666698f, -5.66666651f, 7.66666651f);
4580     path.close();
4585     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4589     SkPath path, pathB;
4590     path.setFillType(SkPathFillType::kWinding);
4591     path.moveTo(1, 3);
4592     path.cubicTo(0, 3, 0.833333313f, 3, 1, 4.33333349f);
4593     path.close();
4598     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4602     SkPath path, pathB;
4603     path.setFillType(SkPathFillType::kWinding);
4604     path.moveTo(2, 3);
4605     path.cubicTo(1, 3, 1.83333337f, 3, 2, 4.66666651f);
4606     path.close();
4611     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4615     SkPath path, pathB;
4616     path.setFillType(SkPathFillType::kWinding);
4617     path.moveTo(2, 4);
4618     path.cubicTo(0, 4, 1.66666663f, 4, 2, 7.33333302f);
4619     path.close();
4624     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4628     SkPath path, pathB;
4629     path.setFillType(SkPathFillType::kWinding);
4630     path.moveTo(2, 4);
4631     path.cubicTo(0, 4, 1.66666663f, 4, 2, 8);
4632     path.close();
4637     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4641     SkPath path, pathB;
4642     path.setFillType(SkPathFillType::kWinding);
4643     path.moveTo(2, 5);
4644     path.cubicTo(1, 5, 1.83333337f, 5, 2, 6.66666651f);
4645     path.close();
4650     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4654     SkPath path, pathB;
4655     path.setFillType(SkPathFillType::kWinding);
4656     path.moveTo(2, 6);
4657     path.cubicTo(1, 6, 1.83333337f, 6, 2, 8);
4658     path.close();
4663     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4667     SkPath path, pathB;
4668     path.setFillType(SkPathFillType::kWinding);
4669     path.moveTo(2, 6);
4670     path.cubicTo(1, 2, 7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f);
4671     path.close();
4676     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4693         SkPath path, pathB;
4694         path.setFillType(SkPathFillType::kWinding);
4695         path.moveTo(pts[0]);
4696         path.cubicTo(pts[1], pts[2], pts[3]);
4697         path.close();
4702         bool result = testPathOp(reporter, path, pathB, kIntersect_SkPathOp, name.c_str());
4714     SkPath path, pathB;
4715     path.setFillType(SkPathFillType::kWinding);
4716     path.moveTo(2, 6);
4717     path.cubicTo(1, 2, 7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f);
4718     path.close();
4724     CubicPathToQuads(path, &qPath);
4730     SkPath path, pathB;
4731     path.setFillType(SkPathFillType::kWinding);
4732     path.moveTo(3, 4);
4733     path.cubicTo(0, 4, 2.5f, 4, 3, 9);
4734     path.close();
4739     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4743     SkPath path, pathB;
4744     path.setFillType(SkPathFillType::kWinding);
4745     path.moveTo(3, 4);
4746     path.cubicTo(0, 4, 2.5f, 4, 3, 10);
4747     path.close();
4752     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4756     SkPath path, pathB;
4757     path.setFillType(SkPathFillType::kWinding);
4758     path.moveTo(3, 4);
4759     path.cubicTo(1, 4, 2.66666675f, 4, 3, 8);
4760     path.close();
4765     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4769     SkPath path, pathB;
4770     path.setFillType(SkPathFillType::kWinding);
4771     path.moveTo(2, 4);
4772     path.cubicTo(1, 4, 1.83333337f, 4, 2, 5.33333349f);
4773     path.close();
4778     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4782     SkPath path, pathB;
4783     path.setFillType(SkPathFillType::kWinding);
4784     path.moveTo(3, 4);
4785     path.cubicTo(2, 4, 2.83333325f, 4, 3, 6);
4786     path.close();
4791     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4795     SkPath path, pathB;
4796     path.setFillType(SkPathFillType::kWinding);
4797     path.moveTo(3, 5);
4798     path.cubicTo(0, 5, 2.5f, 5, 3, 10);
4799     path.close();
4804     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4808     SkPath path, pathB;
4809     path.setFillType(SkPathFillType::kWinding);
4810     path.moveTo(3, 5);
4811     path.cubicTo(0, 5, 2.5f, 5, 3, 11);
4812     path.close();
4817     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4821     SkPath path, pathB;
4822     path.setFillType(SkPathFillType::kWinding);
4823     path.moveTo(3, 5);
4824     path.cubicTo(0, 5, 2.5f, 5, 3, 11);
4825     path.close();
4831     CubicPathToQuads(path, &qPath);
4837     SkPath path, pathB;
4838     path.setFillType(SkPathFillType::kWinding);
4839     path.moveTo(1, 5);
4840     path.cubicTo(0, 1, 7.33333302f, 5.33333349f, -7, 7);
4841     path.close();
4846     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4850     SkPath path, pathB;
4851     path.setFillType(SkPathFillType::kWinding);
4852     path.moveTo(1, 6);
4853     path.cubicTo(0, 2, 7.33333302f, 6.33333302f, -7, 8);
4854     path.close();
4859     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4863     SkPath path, pathB;
4864     path.setFillType(SkPathFillType::kWinding);
4865     path.moveTo(2, 6);
4866     path.cubicTo(1, 2, 8.33333302f, 6.33333302f, -6, 8);
4867     path.close();
4872     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4878     SkPath path, pathB;
4879     path.setFillType(SkPathFillType::kWinding);
4880     path.moveTo(2, 4);
4881     path.cubicTo(0, 1, 6, 5.83333302f, -4, 8);
4882     path.close();
4887     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4891     SkPath path, pathB;
4892     path.setFillType(SkPathFillType::kWinding);
4893     path.moveTo(2, 6);
4894     path.cubicTo(0, 1, 9.33333302f, 6.83333302f, -8.33333302f, 9.16666603f);
4895     path.close();
4900     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4904     SkPath path, pathB;
4905     path.setFillType(SkPathFillType::kWinding);
4906     path.moveTo(0, 2);
4907     path.cubicTo(1, 4, -0.166666687f, 2.66666675f, 1.66666675f, 2);
4908     path.close();
4913     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4917     SkPath path, pathB;
4918     path.setFillType(SkPathFillType::kWinding);
4919     path.moveTo(0, 3);
4920     path.cubicTo(1, 5, -0.166666687f, 3.66666675f, 1.66666675f, 3);
4921     path.close();
4926     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4930     SkPath path, pathB;
4931     path.setFillType(SkPathFillType::kWinding);
4932     path.moveTo(1, 2);
4933     path.cubicTo(2, 4, 0.833333313f, 2.66666675f, 2.66666675f, 2);
4934     path.close();
4939     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4943     SkPath path, pathB;
4944     path.setFillType(SkPathFillType::kWinding);
4945     path.moveTo(1, 3);
4946     path.cubicTo(2, 5, 0.833333313f, 3.66666675f, 2.66666675f, 3);
4947     path.close();
4952     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4956     SkPath path, pathB;
4957     path.setFillType(SkPathFillType::kWinding);
4958     path.moveTo(2, 3);
4959     path.cubicTo(3, 5, 1.83333325f, 3.66666675f, 3.66666651f, 3);
4960     path.close();
4965     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4969     SkPath path, pathB;
4970     path.setFillType(SkPathFillType::kWinding);
4971     path.moveTo(0, 2);
4972     path.cubicTo(1, 4, 0, 3, 1.66666675f, 2);
4973     path.close();
4978     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4982     SkPath path, pathB;
4983     path.setFillType(SkPathFillType::kWinding);
4984     path.moveTo(0, 3);
4985     path.cubicTo(1, 5, 0, 4, 1.66666675f, 3);
4986     path.close();
4991     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4995     SkPath path, pathB;
4996     path.setFillType(SkPathFillType::kWinding);
4997     path.moveTo(1, 2);
4998     path.cubicTo(2, 4, 0.99999994f, 3, 2.66666675f, 2);
4999     path.close();
5004     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5008     SkPath path, pathB;
5009     path.setFillType(SkPathFillType::kWinding);
5010     path.moveTo(1, 3);
5011     path.cubicTo(2, 5, 0.99999994f, 4, 2.66666675f, 3);
5012     path.close();
5017     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5021     SkPath path, pathB;
5022     path.setFillType(SkPathFillType::kWinding);
5023     path.moveTo(2, 3);
5024     path.cubicTo(3, 5, 2, 4, 3.66666651f, 3);
5025     path.close();
5030     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5034     SkPath path, pathB;
5035     path.setFillType(SkPathFillType::kWinding);
5036     path.moveTo(2, 3);
5037     path.cubicTo(3, 5, 2, 4, 3.66666651f, 3);
5038     path.close();
5044     CubicPathToQuads(path, &qPath);
5053     SkPath path, pathB;
5054     path.setFillType(SkPathFillType::kWinding);
5055     path.moveTo(0, 6);
5056     path.cubicTo(1, 2, 7.33333302f, 1.66666663f, -7.5f, 2);
5057     path.close();
5062     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5066     SkPath path, pathB;
5067     path.setFillType(SkPathFillType::kWinding);
5068     path.moveTo(0, 6);
5069     path.cubicTo(1, 2, 7.33333302f, 1.66666663f, -7.5f, 2);
5070     path.close();
5076     CubicPathToQuads(path, &qPath);
5085     SkPath path, pathB;
5086     path.setFillType(SkPathFillType::kWinding);
5087     path.moveTo(0, 1);
5088     path.cubicTo(1, 4, 3, 0, 3, 1);
5089     path.close();
5094     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5098     SkPath path, pathB;
5099     path.setFillType(SkPathFillType::kWinding);
5100     path.moveTo(0, 1);
5101     path.cubicTo(1, 5, -6.33333302f, 0.666666627f, 8, -1);
5102     path.close();
5107     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5111     SkPath path, pathB;
5112     path.setFillType(SkPathFillType::kWinding);
5113     path.moveTo(0, 2);
5114     path.cubicTo(1, 6, -6.33333302f, 1.66666663f, 8, 0);
5115     path.close();
5120     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5124     SkPath path, pathB;
5125     path.setFillType(SkPathFillType::kWinding);
5126     path.moveTo(0, 1);
5127     path.cubicTo(2, 4, -4, -0.833333254f, 6, -3);
5128     path.close();
5133     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5137     SkPath path, pathB;
5138     path.setFillType(SkPathFillType::kWinding);
5139     path.moveTo(3, 4);
5140     path.cubicTo(2, 5, 3, 1, 6, 2);
5141     path.close();
5146     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5150     SkPath path, pathB;
5151     path.setFillType(SkPathFillType::kWinding);
5152     path.moveTo(1, 3);
5153     path.cubicTo(2, 6, 4, 3, 5, 2);
5154     path.close();
5159     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
5163     SkPath path, pathB;
5164     path.moveTo(100.34f, 303.312f);
5165     path.lineTo(-1e+08, 303.312f);
5166     path.lineTo(102, 310.156f);
5167     path.lineTo(100.34f, 310.156f);
5168     path.lineTo(100.34f, 303.312f);
5169     path.close();
5170     testPathOpCheck(reporter, path, pathB, kUnion_SkPathOp, filename, true);
5173 // we currently don't produce meaningful intersections when a path has extremely large segments
5177     SkPath path;
5178     path.setFillType((SkPathFillType) 1);
5179 path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0xcf000000));  // 360, -2.14748e+09f
5180 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
5181 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
5182 path.lineTo(SkBits2Float(0x444bf3bc), SkBits2Float(0x4460537e));  // 815.808f, 897.305f
5183 path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd));  // 213.229f, 572.949f
5184 path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000));  // 32, 16
5185 path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000));  // 100, 512
5186 path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd));  // 213.229f, 572.949f
5187 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000));  // 360, 1024
5188 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000));  // 360, 4140
5190     SkPath path1(path);
5191     path.reset();
5192     path.setFillType((SkPathFillType) 0);
5193 path.moveTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000));  // 127, 321
5194 path.lineTo(SkBits2Float(0x45d5c000), SkBits2Float(0x43870000));  // 6840, 270
5195 path.lineTo(SkBits2Float(0xd0a00000), SkBits2Float(0x4cbebc20));  // -2.14748e+10f, 1e+08
5196 path.lineTo(SkBits2Float(0x451f7000), SkBits2Float(0x42800000));  // 2551, 64
5197 path.lineTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000));  // 127, 321
5198 path.close();
5200     SkPath path2(path);
5205     SkPath path;
5206     path.setFillType(SkPathFillType::kEvenOdd);
5207 path.moveTo(SkBits2Float(0x41e80000), SkBits2Float(0x43bde212));  // 29, 379.766f
5208 path.lineTo(SkBits2Float(0x41e80000), SkBits2Float(0x43bdc7ef));  // 29, 379.562f
5209 path.conicTo(SkBits2Float(0x42a5861e), SkBits2Float(0x43c61f86), SkBits2Float(0x430b0610), SkBits2Float(0x43c61f86), SkBits2Float(0x3f7d23f3));  // 82.7619f, 396.246f, 139.024f, 396.246f, 0.98883f
5210 path.conicTo(SkBits2Float(0x42a58e20), SkBits2Float(0x43c61f86), SkBits2Float(0x41e80000), SkBits2Float(0x43bde212), SkBits2Float(0x3f7d2cf5));  // 82.7776f, 396.246f, 29, 379.766f, 0.988967f
5211 path.close();
5213     SkPath path1(path);
5214     path.setFillType(SkPathFillType::kWinding);
5215 path.moveTo(SkBits2Float(0xc36c7bd8), SkBits2Float(0xc3a31d72));  // -236.484f, -326.23f
5216 path.lineTo(SkBits2Float(0xc367a4ae), SkBits2Float(0xc3a31d72));  // -231.643f, -326.23f
5217 path.lineTo(SkBits2Float(0x430b0610), SkBits2Float(0x43c61f86));  // 139.024f, 396.246f
5218 path.lineTo(SkBits2Float(0xc36c7bd8), SkBits2Float(0x43c61f86));  // -236.484f, 396.246f
5220     SkPath path2(path);
5225     SkPath path;
5226     path.setFillType((SkPathFillType) 0);
5227 path.moveTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5228 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
5229 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
5230 path.lineTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5231 path.close();
5232     SkPath path1(path);
5234     path.reset();
5235     path.setFillType((SkPathFillType) 0);
5236 path.moveTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5237 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
5238 path.lineTo(SkBits2Float(0x417ab74b), SkBits2Float(0x4154a02b)); // 15.6697f, 13.2891f
5239 path.lineTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5240 path.close();
5241     SkPath path2(path);
5246     SkPath path, pathB;
5247     path.setFillType(SkPathFillType::kWinding);
5248     path.moveTo(0, 1);
5249     path.cubicTo(3, 5, 1, 0, 3, 0);
5250     path.close();
5255     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5259     SkPath path, pathB;
5260     path.setFillType(SkPathFillType::kWinding);
5261     path.moveTo(0, 1);
5262     path.cubicTo(2, 5, 2, 0, 2, 1);
5263     path.close();
5268     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5272     SkPath path, pathB;
5273     path.setFillType(SkPathFillType::kWinding);
5274     path.moveTo(2, 3);
5275     path.cubicTo(0, 4, -0.333333343f, 4.66666651f, 3, 5.83333349f);
5276     path.close();
5281     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5285     SkPath path, pathB;
5286     path.setFillType(SkPathFillType::kWinding);
5287     path.moveTo(2, 4);
5288     path.cubicTo(0, 5, -0.333333343f, 5.66666651f, 3, 6.83333302f);
5289     path.close();
5294     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5298     SkPath path, pathB;
5299     path.setFillType(SkPathFillType::kWinding);
5300     path.moveTo(2, 5);
5301     path.cubicTo(0, 6, -0.333333343f, 6.66666651f, 3, 7.83333302f);
5302     path.close();
5307     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5311     SkPath path, pathB;
5312     path.setFillType(SkPathFillType::kWinding);
5313     path.moveTo(3, 4);
5314     path.cubicTo(1, 5, 0.666666627f, 5.66666651f, 4, 6.83333302f);
5315     path.close();
5320     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5324     SkPath path, pathB;
5325     path.setFillType(SkPathFillType::kWinding);
5326     path.moveTo(3, 5);
5327     path.cubicTo(1, 6, 0.666666627f, 6.66666651f, 4, 7.83333302f);
5328     path.close();
5333     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5337     SkPath path, pathB;
5338     path.setFillType(SkPathFillType::kWinding);
5339     path.moveTo(4, 5);
5340     path.cubicTo(2, 6, 1.66666663f, 6.66666651f, 5, 7.83333302f);
5341     path.close();
5346     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5350     SkPath path, pathB;
5351     path.setFillType(SkPathFillType::kWinding);
5352     path.moveTo(3, 4);
5353     path.cubicTo(0, 6, 6, 1, 4, 2);
5354     path.close();
5359     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5363     SkPath path, pathB;
5364     path.setFillType(SkPathFillType::kWinding);
5365     path.moveTo(1, 4);
5366     path.cubicTo(2, 6, 5, 0, 5, 3);
5367     path.close();
5372     testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
5376     SkPath path, pathB;
5377     path.setFillType(SkPathFillType::kWinding);
5378     path.moveTo(0,1);
5379     path.cubicTo(2,4, 2,0, 2,0);
5380     path.close();
5385     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5389     SkPath path, pathB;
5390     path.moveTo(1, 2);
5391     path.cubicTo(0, 3, -0.333333343f, 3.33333325f, 0.833333373f, 3.5f);
5392     path.close();
5396     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5400     SkPath path, pathB;
5401     path.setFillType(SkPathFillType::kWinding);
5402     path.addCircle(0, 1, 5, SkPathDirection::kCW);
5405     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5409  SkPath path;
5410 path.moveTo(815, 82);
5411 path.cubicTo(814.4794311523438f, 82.7868881225586f, 814.5330810546875f,
5413 path.cubicTo(814.5229492187500f, 82.6230010986328f, 814.3790283203125f,
5415 path.close();
5416     testPathOp(reporter, path, path, kUnion_SkPathOp, filename);
5420  SkPath path, pathB;
5421 path.moveTo(SkBits2Float(0xc0a00000), SkBits2Float(0x00000000));  // -5, 0
5422 path.lineTo(SkBits2Float(0x44866000), SkBits2Float(0x00000000));  // 1075, 0
5423 path.lineTo(SkBits2Float(0x44866000), SkBits2Float(0x43720000));  // 1075, 242
5424 path.lineTo(SkBits2Float(0xc0a00000), SkBits2Float(0x43720000));  // -5, 242
5425 path.lineTo(SkBits2Float(0xc0a00000), SkBits2Float(0x00000000));  // -5, 0
5426 path.close();
5433     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5437    SkPath path;
5438    path.setFillType(SkPathFillType::kEvenOdd);
5439    path.moveTo(SkBits2Float(0x45b56000), SkBits2Float(0x45bca000));  // 5804, 6036
5440    path.lineTo(SkBits2Float(0x45b55f0a), SkBits2Float(0x45bc9fc0));  // 5803.88f, 6035.97f
5441    path.lineTo(SkBits2Float(0x45b55e15), SkBits2Float(0x45bc9f7b));  // 5803.76f, 6035.94f
5442    path.lineTo(SkBits2Float(0x45b55d1f), SkBits2Float(0x45bc9f32));  // 5803.64f, 6035.9f
5443    path.lineTo(SkBits2Float(0x45b55c29), SkBits2Float(0x45bc9ee3));  // 5803.52f, 6035.86f
5444    path.lineTo(SkBits2Float(0x45b55b34), SkBits2Float(0x45bc9e90));  // 5803.4f, 6035.82f
5445    path.lineTo(SkBits2Float(0x45b55a3f), SkBits2Float(0x45bc9e38));  // 5803.28f, 6035.78f
5446    path.lineTo(SkBits2Float(0x45b5594a), SkBits2Float(0x45bc9ddc));  // 5803.16f, 6035.73f
5447    path.lineTo(SkBits2Float(0x45b55856), SkBits2Float(0x45bc9d7a));  // 5803.04f, 6035.68f
5448    path.lineTo(SkBits2Float(0x45b55762), SkBits2Float(0x45bc9d14));  // 5802.92f, 6035.63f
5449    path.lineTo(SkBits2Float(0x45b5566f), SkBits2Float(0x45bc9caa));  // 5802.8f, 6035.58f
5450    path.lineTo(SkBits2Float(0x45b5557c), SkBits2Float(0x45bc9c3b));  // 5802.69f, 6035.53f
5451    path.lineTo(SkBits2Float(0x45b55489), SkBits2Float(0x45bc9bc7));  // 5802.57f, 6035.47f
5452    path.lineTo(SkBits2Float(0x45b55397), SkBits2Float(0x45bc9b4f));  // 5802.45f, 6035.41f
5453    path.lineTo(SkBits2Float(0x45b552a6), SkBits2Float(0x45bc9ad3));  // 5802.33f, 6035.35f
5454    path.lineTo(SkBits2Float(0x45b551b5), SkBits2Float(0x45bc9a52));  // 5802.21f, 6035.29f
5455    path.lineTo(SkBits2Float(0x45b550c5), SkBits2Float(0x45bc99cd));  // 5802.1f, 6035.23f
5456    path.lineTo(SkBits2Float(0x45b54fd6), SkBits2Float(0x45bc9943));  // 5801.98f, 6035.16f
5457    path.lineTo(SkBits2Float(0x45b54ee8), SkBits2Float(0x45bc98b6));  // 5801.86f, 6035.09f
5458    path.lineTo(SkBits2Float(0x45b54dfb), SkBits2Float(0x45bc9824));  // 5801.75f, 6035.02f
5459    path.lineTo(SkBits2Float(0x45b54d0e), SkBits2Float(0x45bc978d));  // 5801.63f, 6034.94f
5460    path.lineTo(SkBits2Float(0x45b54c23), SkBits2Float(0x45bc96f3));  // 5801.52f, 6034.87f
5461    path.lineTo(SkBits2Float(0x45b54b39), SkBits2Float(0x45bc9654));  // 5801.4f, 6034.79f
5462    path.lineTo(SkBits2Float(0x45b54a4f), SkBits2Float(0x45bc95b2));  // 5801.29f, 6034.71f
5463    path.lineTo(SkBits2Float(0x45b54967), SkBits2Float(0x45bc950b));  // 5801.18f, 6034.63f
5464    path.lineTo(SkBits2Float(0x45b54880), SkBits2Float(0x45bc9460));  // 5801.06f, 6034.55f
5465    path.lineTo(SkBits2Float(0x45b5479a), SkBits2Float(0x45bc93b1));  // 5800.95f, 6034.46f
5466    path.lineTo(SkBits2Float(0x45b546b6), SkBits2Float(0x45bc92fe));  // 5800.84f, 6034.37f
5467    path.lineTo(SkBits2Float(0x45b545d3), SkBits2Float(0x45bc9248));  // 5800.73f, 6034.29f
5468    path.lineTo(SkBits2Float(0x45b544f1), SkBits2Float(0x45bc918d));  // 5800.62f, 6034.19f
5469    path.lineTo(SkBits2Float(0x45b54410), SkBits2Float(0x45bc90cf));  // 5800.51f, 6034.1f
5470    path.lineTo(SkBits2Float(0x45b54331), SkBits2Float(0x45bc900d));  // 5800.4f, 6034.01f
5471    path.lineTo(SkBits2Float(0x45b54254), SkBits2Float(0x45bc8f47));  // 5800.29f, 6033.91f
5472    path.lineTo(SkBits2Float(0x45b54178), SkBits2Float(0x45bc8e7d));  // 5800.18f, 6033.81f
5473    path.lineTo(SkBits2Float(0x45b5409e), SkBits2Float(0x45bc8db0));  // 5800.08f, 6033.71f
5474    path.lineTo(SkBits2Float(0x45b53fc6), SkBits2Float(0x45bc8cde));  // 5799.97f, 6033.61f
5475    path.lineTo(SkBits2Float(0x45b53eef), SkBits2Float(0x45bc8c0a));  // 5799.87f, 6033.5f
5476    path.lineTo(SkBits2Float(0x45b53e1a), SkBits2Float(0x45bc8b31));  // 5799.76f, 6033.4f
5477    path.lineTo(SkBits2Float(0x45b53d47), SkBits2Float(0x45bc8a56));  // 5799.66f, 6033.29f
5478    path.lineTo(SkBits2Float(0x45b53c75), SkBits2Float(0x45bc8976));  // 5799.56f, 6033.18f
5479    path.lineTo(SkBits2Float(0x45b53ba6), SkBits2Float(0x45bc8893));  // 5799.46f, 6033.07f
5480    path.lineTo(SkBits2Float(0x45b53ad8), SkBits2Float(0x45bc87ad));  // 5799.36f, 6032.96f
5481    path.lineTo(SkBits2Float(0x45b53a0d), SkBits2Float(0x45bc86c4));  // 5799.26f, 6032.85f
5482    path.lineTo(SkBits2Float(0x45b53944), SkBits2Float(0x45bc85d6));  // 5799.16f, 6032.73f
5483    path.lineTo(SkBits2Float(0x45b5387c), SkBits2Float(0x45bc84e6));  // 5799.06f, 6032.61f
5484    path.lineTo(SkBits2Float(0x45b537b7), SkBits2Float(0x45bc83f2));  // 5798.96f, 6032.49f
5485    path.lineTo(SkBits2Float(0x45b536f4), SkBits2Float(0x45bc82fc));  // 5798.87f, 6032.37f
5486    path.lineTo(SkBits2Float(0x45b53634), SkBits2Float(0x45bc8201));  // 5798.78f, 6032.25f
5487    path.lineTo(SkBits2Float(0x45b53575), SkBits2Float(0x45bc8104));  // 5798.68f, 6032.13f
5488    path.lineTo(SkBits2Float(0x45b534ba), SkBits2Float(0x45bc8004));  // 5798.59f, 6032
5489    path.lineTo(SkBits2Float(0x45b53400), SkBits2Float(0x45bc7f00));  // 5798.5f, 6031.88f
5490    path.lineTo(SkBits2Float(0x45b53349), SkBits2Float(0x45bc7df9));  // 5798.41f, 6031.75f
5491    path.lineTo(SkBits2Float(0x45b53294), SkBits2Float(0x45bc7cf0));  // 5798.32f, 6031.62f
5492    path.lineTo(SkBits2Float(0x45b531e2), SkBits2Float(0x45bc7be3));  // 5798.24f, 6031.49f
5493    path.lineTo(SkBits2Float(0x45b53133), SkBits2Float(0x45bc7ad3));  // 5798.15f, 6031.35f
5494    path.lineTo(SkBits2Float(0x45b53086), SkBits2Float(0x45bc79c1));  // 5798.07f, 6031.22f
5495    path.lineTo(SkBits2Float(0x45b52fdc), SkBits2Float(0x45bc78ab));  // 5797.98f, 6031.08f
5496    path.lineTo(SkBits2Float(0x45b52f35), SkBits2Float(0x45bc7793));  // 5797.9f, 6030.95f
5497    path.lineTo(SkBits2Float(0x45b52e90), SkBits2Float(0x45bc7678));  // 5797.82f, 6030.81f
5498    path.lineTo(SkBits2Float(0x45b52def), SkBits2Float(0x45bc755a));  // 5797.74f, 6030.67f
5499    path.lineTo(SkBits2Float(0x45b52d50), SkBits2Float(0x45bc7439));  // 5797.66f, 6030.53f
5500    path.lineTo(SkBits2Float(0x45b52cb4), SkBits2Float(0x45bc7316));  // 5797.59f, 6030.39f
5501    path.lineTo(SkBits2Float(0x45b52c1b), SkBits2Float(0x45bc71f0));  // 5797.51f, 6030.24f
5502    path.lineTo(SkBits2Float(0x45b52b86), SkBits2Float(0x45bc70c7));  // 5797.44f, 6030.1f
5503    path.lineTo(SkBits2Float(0x45b52af3), SkBits2Float(0x45bc6f9c));  // 5797.37f, 6029.95f
5504    path.lineTo(SkBits2Float(0x45b52a63), SkBits2Float(0x45bc6e6e));  // 5797.3f, 6029.8f
5505    path.lineTo(SkBits2Float(0x45b529d7), SkBits2Float(0x45bc6d3e));  // 5797.23f, 6029.66f
5506    path.lineTo(SkBits2Float(0x45b5294e), SkBits2Float(0x45bc6c0b));  // 5797.16f, 6029.51f
5507    path.lineTo(SkBits2Float(0x45b528c8), SkBits2Float(0x45bc6ad6));  // 5797.1f, 6029.35f
5508    path.lineTo(SkBits2Float(0x45b52846), SkBits2Float(0x45bc699e));  // 5797.03f, 6029.2f
5509    path.lineTo(SkBits2Float(0x45b527c7), SkBits2Float(0x45bc6864));  // 5796.97f, 6029.05f
5510    path.lineTo(SkBits2Float(0x45b5274b), SkBits2Float(0x45bc6728));  // 5796.91f, 6028.89f
5511    path.lineTo(SkBits2Float(0x45b526d3), SkBits2Float(0x45bc65e9));  // 5796.85f, 6028.74f
5512    path.lineTo(SkBits2Float(0x45b5265e), SkBits2Float(0x45bc64a8));  // 5796.8f, 6028.58f
5513    path.lineTo(SkBits2Float(0x45b52600), SkBits2Float(0x45bc639b));  // 5796.75f, 6028.45f
5514    path.lineTo(SkBits2Float(0x45b52600), SkBits2Float(0x45bab032));  // 5796.75f, 5974.02f
5515    path.lineTo(SkBits2Float(0x45b52611), SkBits2Float(0x45baaffd));  // 5796.76f, 5974
5516    path.lineTo(SkBits2Float(0x45b52687), SkBits2Float(0x45baae9d));  // 5796.82f, 5973.83f
5517    path.lineTo(SkBits2Float(0x45b52700), SkBits2Float(0x45baad40));  // 5796.88f, 5973.66f
5518    path.lineTo(SkBits2Float(0x45b5277d), SkBits2Float(0x45baabe7));  // 5796.94f, 5973.49f
5519    path.lineTo(SkBits2Float(0x45b527fe), SkBits2Float(0x45baaa91));  // 5797, 5973.32f
5520    path.lineTo(SkBits2Float(0x45b52883), SkBits2Float(0x45baa93f));  // 5797.06f, 5973.16f
5521    path.lineTo(SkBits2Float(0x45b5290b), SkBits2Float(0x45baa7f1));  // 5797.13f, 5972.99f
5522    path.lineTo(SkBits2Float(0x45b52998), SkBits2Float(0x45baa6a6));  // 5797.2f, 5972.83f
5523    path.lineTo(SkBits2Float(0x45b52a28), SkBits2Float(0x45baa55f));  // 5797.27f, 5972.67f
5524    path.lineTo(SkBits2Float(0x45b52abb), SkBits2Float(0x45baa41c));  // 5797.34f, 5972.51f
5525    path.lineTo(SkBits2Float(0x45b52b52), SkBits2Float(0x45baa2dc));  // 5797.42f, 5972.36f
5526    path.lineTo(SkBits2Float(0x45b52bed), SkBits2Float(0x45baa1a0));  // 5797.49f, 5972.2f
5527    path.lineTo(SkBits2Float(0x45b52c8c), SkBits2Float(0x45baa068));  // 5797.57f, 5972.05f
5528    path.lineTo(SkBits2Float(0x45b52d2e), SkBits2Float(0x45ba9f34));  // 5797.65f, 5971.9f
5529    path.lineTo(SkBits2Float(0x45b52dd3), SkBits2Float(0x45ba9e04));  // 5797.73f, 5971.75f
5530    path.lineTo(SkBits2Float(0x45b52e7c), SkBits2Float(0x45ba9cd8));  // 5797.81f, 5971.61f
5531    path.lineTo(SkBits2Float(0x45b52f28), SkBits2Float(0x45ba9baf));  // 5797.89f, 5971.46f
5532    path.lineTo(SkBits2Float(0x45b52fd8), SkBits2Float(0x45ba9a8b));  // 5797.98f, 5971.32f
5533    path.lineTo(SkBits2Float(0x45b5308b), SkBits2Float(0x45ba996b));  // 5798.07f, 5971.18f
5534    path.lineTo(SkBits2Float(0x45b53141), SkBits2Float(0x45ba984f));  // 5798.16f, 5971.04f
5535    path.lineTo(SkBits2Float(0x45b531fa), SkBits2Float(0x45ba9736));  // 5798.25f, 5970.9f
5536    path.lineTo(SkBits2Float(0x45b532b7), SkBits2Float(0x45ba9623));  // 5798.34f, 5970.77f
5537    path.lineTo(SkBits2Float(0x45b53377), SkBits2Float(0x45ba9513));  // 5798.43f, 5970.63f
5538    path.lineTo(SkBits2Float(0x45b5343a), SkBits2Float(0x45ba9407));  // 5798.53f, 5970.5f
5539    path.lineTo(SkBits2Float(0x45b53500), SkBits2Float(0x45ba9300));  // 5798.63f, 5970.38f
5540    path.lineTo(SkBits2Float(0x45b535c9), SkBits2Float(0x45ba91fd));  // 5798.72f, 5970.25f
5541    path.lineTo(SkBits2Float(0x45b53695), SkBits2Float(0x45ba90fe));  // 5798.82f, 5970.12f
5542    path.lineTo(SkBits2Float(0x45b53765), SkBits2Float(0x45ba9004));  // 5798.92f, 5970
5543    path.lineTo(SkBits2Float(0x45b53837), SkBits2Float(0x45ba8f0e));  // 5799.03f, 5969.88f
5544    path.lineTo(SkBits2Float(0x45b5390c), SkBits2Float(0x45ba8e1d));  // 5799.13f, 5969.76f
5545    path.lineTo(SkBits2Float(0x45b539e4), SkBits2Float(0x45ba8d30));  // 5799.24f, 5969.65f
5546    path.lineTo(SkBits2Float(0x45b53abf), SkBits2Float(0x45ba8c48));  // 5799.34f, 5969.54f
5547    path.lineTo(SkBits2Float(0x45b53b9d), SkBits2Float(0x45ba8b64));  // 5799.45f, 5969.42f
5548    path.lineTo(SkBits2Float(0x45b53c7d), SkBits2Float(0x45ba8a85));  // 5799.56f, 5969.31f
5549    path.lineTo(SkBits2Float(0x45b53d60), SkBits2Float(0x45ba89aa));  // 5799.67f, 5969.21f
5550    path.lineTo(SkBits2Float(0x45b53e46), SkBits2Float(0x45ba88d4));  // 5799.78f, 5969.1f
5551    path.lineTo(SkBits2Float(0x45b53f2f), SkBits2Float(0x45ba8803));  // 5799.9f, 5969
5552    path.lineTo(SkBits2Float(0x45b5401a), SkBits2Float(0x45ba8736));  // 5800.01f, 5968.9f
5553    path.lineTo(SkBits2Float(0x45b54108), SkBits2Float(0x45ba866f));  // 5800.13f, 5968.8f
5554    path.lineTo(SkBits2Float(0x45b541f8), SkBits2Float(0x45ba85ac));  // 5800.25f, 5968.71f
5555    path.lineTo(SkBits2Float(0x45b542eb), SkBits2Float(0x45ba84ee));  // 5800.36f, 5968.62f
5556    path.lineTo(SkBits2Float(0x45b543e0), SkBits2Float(0x45ba8435));  // 5800.48f, 5968.53f
5557    path.lineTo(SkBits2Float(0x45b544d8), SkBits2Float(0x45ba8380));  // 5800.61f, 5968.44f
5558    path.lineTo(SkBits2Float(0x45b545d2), SkBits2Float(0x45ba82d1));  // 5800.73f, 5968.35f
5559    path.lineTo(SkBits2Float(0x45b546cf), SkBits2Float(0x45ba8227));  // 5800.85f, 5968.27f
5560    path.lineTo(SkBits2Float(0x45b547ce), SkBits2Float(0x45ba8182));  // 5800.98f, 5968.19f
5561    path.lineTo(SkBits2Float(0x45b548cf), SkBits2Float(0x45ba80e2));  // 5801.1f, 5968.11f
5562    path.lineTo(SkBits2Float(0x45b549d2), SkBits2Float(0x45ba8047));  // 5801.23f, 5968.03f
5563    path.lineTo(SkBits2Float(0x45b54ad8), SkBits2Float(0x45ba7fb1));  // 5801.36f, 5967.96f
5564    path.lineTo(SkBits2Float(0x45b54be0), SkBits2Float(0x45ba7f20));  // 5801.48f, 5967.89f
5565    path.lineTo(SkBits2Float(0x45b54cea), SkBits2Float(0x45ba7e95));  // 5801.61f, 5967.82f
5566    path.lineTo(SkBits2Float(0x45b54df6), SkBits2Float(0x45ba7e0e));  // 5801.75f, 5967.76f
5567    path.lineTo(SkBits2Float(0x45b54f04), SkBits2Float(0x45ba7d8d));  // 5801.88f, 5967.69f
5568    path.lineTo(SkBits2Float(0x45b55015), SkBits2Float(0x45ba7d12));  // 5802.01f, 5967.63f
5569    path.lineTo(SkBits2Float(0x45b55127), SkBits2Float(0x45ba7c9c));  // 5802.14f, 5967.58f
5570    path.lineTo(SkBits2Float(0x45b551b5), SkBits2Float(0x45ba7c62));  // 5802.21f, 5967.55f
5571    path.lineTo(SkBits2Float(0x45c7b29a), SkBits2Float(0x45ba7c62));  // 6390.33f, 5967.55f
5572    path.lineTo(SkBits2Float(0x45c7b2f2), SkBits2Float(0x45ba7c8b));  // 6390.37f, 5967.57f
5573    path.lineTo(SkBits2Float(0x45c7b3dd), SkBits2Float(0x45ba7cff));  // 6390.48f, 5967.62f
5574    path.lineTo(SkBits2Float(0x45c7b4c7), SkBits2Float(0x45ba7d78));  // 6390.6f, 5967.68f
5575    path.lineTo(SkBits2Float(0x45c7b5b1), SkBits2Float(0x45ba7df5));  // 6390.71f, 5967.74f
5576    path.lineTo(SkBits2Float(0x45c7b699), SkBits2Float(0x45ba7e78));  // 6390.82f, 5967.81f
5577    path.lineTo(SkBits2Float(0x45c7b780), SkBits2Float(0x45ba7f00));  // 6390.94f, 5967.88f
5578    path.lineTo(SkBits2Float(0x45c7b866), SkBits2Float(0x45ba7f8d));  // 6391.05f, 5967.94f
5579    path.lineTo(SkBits2Float(0x45c7b94a), SkBits2Float(0x45ba801e));  // 6391.16f, 5968.01f
5580    path.lineTo(SkBits2Float(0x45c7ba2d), SkBits2Float(0x45ba80b5));  // 6391.27f, 5968.09f
5581    path.lineTo(SkBits2Float(0x45c7bb0f), SkBits2Float(0x45ba8150));  // 6391.38f, 5968.16f
5582    path.lineTo(SkBits2Float(0x45c7bbf0), SkBits2Float(0x45ba81f0));  // 6391.49f, 5968.24f
5583    path.lineTo(SkBits2Float(0x45c7bccf), SkBits2Float(0x45ba8294));  // 6391.6f, 5968.32f
5584    path.lineTo(SkBits2Float(0x45c7bdac), SkBits2Float(0x45ba833d));  // 6391.71f, 5968.4f
5585    path.lineTo(SkBits2Float(0x45c7be88), SkBits2Float(0x45ba83eb));  // 6391.82f, 5968.49f
5586    path.lineTo(SkBits2Float(0x45c7bf62), SkBits2Float(0x45ba849d));  // 6391.92f, 5968.58f
5587    path.lineTo(SkBits2Float(0x45c7c03a), SkBits2Float(0x45ba8554));  // 6392.03f, 5968.67f
5588    path.lineTo(SkBits2Float(0x45c7c111), SkBits2Float(0x45ba860f));  // 6392.13f, 5968.76f
5589    path.lineTo(SkBits2Float(0x45c7c1e6), SkBits2Float(0x45ba86cf));  // 6392.24f, 5968.85f
5590    path.lineTo(SkBits2Float(0x45c7c2b9), SkBits2Float(0x45ba8792));  // 6392.34f, 5968.95f
5591    path.lineTo(SkBits2Float(0x45c7c38b), SkBits2Float(0x45ba885b));  // 6392.44f, 5969.04f
5592    path.lineTo(SkBits2Float(0x45c7c45a), SkBits2Float(0x45ba8927));  // 6392.54f, 5969.14f
5593    path.lineTo(SkBits2Float(0x45c7c528), SkBits2Float(0x45ba89f7));  // 6392.64f, 5969.25f
5594    path.lineTo(SkBits2Float(0x45c7c5f3), SkBits2Float(0x45ba8acc));  // 6392.74f, 5969.35f
5595    path.lineTo(SkBits2Float(0x45c7c6bc), SkBits2Float(0x45ba8ba5));  // 6392.84f, 5969.46f
5596    path.lineTo(SkBits2Float(0x45c7c784), SkBits2Float(0x45ba8c82));  // 6392.94f, 5969.56f
5597    path.lineTo(SkBits2Float(0x45c7c849), SkBits2Float(0x45ba8d62));  // 6393.04f, 5969.67f
5598    path.lineTo(SkBits2Float(0x45c7c90c), SkBits2Float(0x45ba8e47));  // 6393.13f, 5969.78f
5599    path.lineTo(SkBits2Float(0x45c7c9cc), SkBits2Float(0x45ba8f30));  // 6393.22f, 5969.9f
5600    path.lineTo(SkBits2Float(0x45c7ca8b), SkBits2Float(0x45ba901c));  // 6393.32f, 5970.01f
5601    path.lineTo(SkBits2Float(0x45c7cb46), SkBits2Float(0x45ba910c));  // 6393.41f, 5970.13f
5602    path.lineTo(SkBits2Float(0x45c7cc00), SkBits2Float(0x45ba9200));  // 6393.5f, 5970.25f
5603    path.lineTo(SkBits2Float(0x45c7ccb7), SkBits2Float(0x45ba92f8));  // 6393.59f, 5970.37f
5604    path.lineTo(SkBits2Float(0x45c7cd6c), SkBits2Float(0x45ba93f3));  // 6393.68f, 5970.49f
5605    path.lineTo(SkBits2Float(0x45c7ce1e), SkBits2Float(0x45ba94f2));  // 6393.76f, 5970.62f
5606    path.lineTo(SkBits2Float(0x45c7cecd), SkBits2Float(0x45ba95f4));  // 6393.85f, 5970.74f
5607    path.lineTo(SkBits2Float(0x45c7cf7a), SkBits2Float(0x45ba96fa));  // 6393.93f, 5970.87f
5608    path.lineTo(SkBits2Float(0x45c7d024), SkBits2Float(0x45ba9803));  // 6394.02f, 5971
5609    path.lineTo(SkBits2Float(0x45c7d0cb), SkBits2Float(0x45ba9910));  // 6394.1f, 5971.13f
5610    path.lineTo(SkBits2Float(0x45c7d170), SkBits2Float(0x45ba9a20));  // 6394.18f, 5971.27f
5611    path.lineTo(SkBits2Float(0x45c7d211), SkBits2Float(0x45ba9b33));  // 6394.26f, 5971.4f
5612    path.lineTo(SkBits2Float(0x45c7d2b0), SkBits2Float(0x45ba9c4a));  // 6394.34f, 5971.54f
5613    path.lineTo(SkBits2Float(0x45c7d34c), SkBits2Float(0x45ba9d63));  // 6394.41f, 5971.67f
5614    path.lineTo(SkBits2Float(0x45c7d3e5), SkBits2Float(0x45ba9e80));  // 6394.49f, 5971.81f
5615    path.lineTo(SkBits2Float(0x45c7d47a), SkBits2Float(0x45ba9fa0));  // 6394.56f, 5971.95f
5616    path.lineTo(SkBits2Float(0x45c7d50d), SkBits2Float(0x45baa0c3));  // 6394.63f, 5972.1f
5617    path.lineTo(SkBits2Float(0x45c7d59d), SkBits2Float(0x45baa1e9));  // 6394.7f, 5972.24f
5618    path.lineTo(SkBits2Float(0x45c7d629), SkBits2Float(0x45baa312));  // 6394.77f, 5972.38f
5619    path.lineTo(SkBits2Float(0x45c7d6b2), SkBits2Float(0x45baa43e));  // 6394.84f, 5972.53f
5620    path.lineTo(SkBits2Float(0x45c7d738), SkBits2Float(0x45baa56d));  // 6394.9f, 5972.68f
5621    path.lineTo(SkBits2Float(0x45c7d7ba), SkBits2Float(0x45baa69f));  // 6394.97f, 5972.83f
5622    path.lineTo(SkBits2Float(0x45c7d839), SkBits2Float(0x45baa7d3));  // 6395.03f, 5972.98f
5623    path.lineTo(SkBits2Float(0x45c7d8b5), SkBits2Float(0x45baa90a));  // 6395.09f, 5973.13f
5624    path.lineTo(SkBits2Float(0x45c7d92d), SkBits2Float(0x45baaa44));  // 6395.15f, 5973.28f
5625    path.lineTo(SkBits2Float(0x45c7d9a2), SkBits2Float(0x45baab80));  // 6395.2f, 5973.44f
5626    path.lineTo(SkBits2Float(0x45c7da13), SkBits2Float(0x45baacbf));  // 6395.26f, 5973.59f
5627    path.lineTo(SkBits2Float(0x45c7da80), SkBits2Float(0x45baae00));  // 6395.31f, 5973.75f
5628    path.lineTo(SkBits2Float(0x45c7daea), SkBits2Float(0x45baaf44));  // 6395.36f, 5973.91f
5629    path.lineTo(SkBits2Float(0x45c7db50), SkBits2Float(0x45bab08a));  // 6395.41f, 5974.07f
5630    path.lineTo(SkBits2Float(0x45c7dbb2), SkBits2Float(0x45bab1d3));  // 6395.46f, 5974.23f
5631    path.lineTo(SkBits2Float(0x45c7dc10), SkBits2Float(0x45bab31d));  // 6395.51f, 5974.39f
5632    path.lineTo(SkBits2Float(0x45c7dc6a), SkBits2Float(0x45bab46a));  // 6395.55f, 5974.55f
5633    path.lineTo(SkBits2Float(0x45c7dc6b), SkBits2Float(0x45bc5fbe));  // 6395.55f, 6027.97f
5634    path.lineTo(SkBits2Float(0x45c7dc10), SkBits2Float(0x45bc60e7));  // 6395.51f, 6028.11f
5635    path.lineTo(SkBits2Float(0x45c7dbb2), SkBits2Float(0x45bc620f));  // 6395.46f, 6028.26f
5636    path.lineTo(SkBits2Float(0x45c7db50), SkBits2Float(0x45bc6336));  // 6395.41f, 6028.4f
5637    path.lineTo(SkBits2Float(0x45c7daea), SkBits2Float(0x45bc645c));  // 6395.36f, 6028.54f
5638    path.lineTo(SkBits2Float(0x45c7da80), SkBits2Float(0x45bc6580));  // 6395.31f, 6028.69f
5639    path.lineTo(SkBits2Float(0x45c7da13), SkBits2Float(0x45bc66a3));  // 6395.26f, 6028.83f
5640    path.lineTo(SkBits2Float(0x45c7d9a2), SkBits2Float(0x45bc67c5));  // 6395.2f, 6028.97f
5641    path.lineTo(SkBits2Float(0x45c7d92d), SkBits2Float(0x45bc68e6));  // 6395.15f, 6029.11f
5642    path.lineTo(SkBits2Float(0x45c7d8b5), SkBits2Float(0x45bc6a05));  // 6395.09f, 6029.25f
5643    path.lineTo(SkBits2Float(0x45c7d839), SkBits2Float(0x45bc6b23));  // 6395.03f, 6029.39f
5644    path.lineTo(SkBits2Float(0x45c7d7ba), SkBits2Float(0x45bc6c3f));  // 6394.97f, 6029.53f
5645    path.lineTo(SkBits2Float(0x45c7d738), SkBits2Float(0x45bc6d5a));  // 6394.9f, 6029.67f
5646    path.lineTo(SkBits2Float(0x45c7d6b2), SkBits2Float(0x45bc6e73));  // 6394.84f, 6029.81f
5647    path.lineTo(SkBits2Float(0x45c7d629), SkBits2Float(0x45bc6f8b));  // 6394.77f, 6029.94f
5648    path.lineTo(SkBits2Float(0x45c7d59d), SkBits2Float(0x45bc70a1));  // 6394.7f, 6030.08f
5649    path.lineTo(SkBits2Float(0x45c7d50d), SkBits2Float(0x45bc71b5));  // 6394.63f, 6030.21f
5650    path.lineTo(SkBits2Float(0x45c7d47a), SkBits2Float(0x45bc72c7));  // 6394.56f, 6030.35f
5651    path.lineTo(SkBits2Float(0x45c7d3e5), SkBits2Float(0x45bc73d8));  // 6394.49f, 6030.48f
5652    path.lineTo(SkBits2Float(0x45c7d34c), SkBits2Float(0x45bc74e7));  // 6394.41f, 6030.61f
5653    path.lineTo(SkBits2Float(0x45c7d2b0), SkBits2Float(0x45bc75f4));  // 6394.34f, 6030.74f
5654    path.lineTo(SkBits2Float(0x45c7d211), SkBits2Float(0x45bc76ff));  // 6394.26f, 6030.87f
5655    path.lineTo(SkBits2Float(0x45c7d170), SkBits2Float(0x45bc7807));  // 6394.18f, 6031
5656    path.lineTo(SkBits2Float(0x45c7d0cb), SkBits2Float(0x45bc790e));  // 6394.1f, 6031.13f
5657    path.lineTo(SkBits2Float(0x45c7d024), SkBits2Float(0x45bc7a13));  // 6394.02f, 6031.26f
5658    path.lineTo(SkBits2Float(0x45c7cf7a), SkBits2Float(0x45bc7b16));  // 6393.93f, 6031.39f
5659    path.lineTo(SkBits2Float(0x45c7cecd), SkBits2Float(0x45bc7c16));  // 6393.85f, 6031.51f
5660    path.lineTo(SkBits2Float(0x45c7ce1e), SkBits2Float(0x45bc7d14));  // 6393.76f, 6031.63f
5661    path.lineTo(SkBits2Float(0x45c7cd6c), SkBits2Float(0x45bc7e10));  // 6393.68f, 6031.76f
5662    path.lineTo(SkBits2Float(0x45c7ccb7), SkBits2Float(0x45bc7f09));  // 6393.59f, 6031.88f
5663    path.lineTo(SkBits2Float(0x45c7cc00), SkBits2Float(0x45bc8000));  // 6393.5f, 6032
5664    path.lineTo(SkBits2Float(0x45c7cb46), SkBits2Float(0x45bc80f5));  // 6393.41f, 6032.12f
5665    path.lineTo(SkBits2Float(0x45c7ca8b), SkBits2Float(0x45bc81e7));  // 6393.32f, 6032.24f
5666    path.lineTo(SkBits2Float(0x45c7c9cc), SkBits2Float(0x45bc82d6));  // 6393.22f, 6032.35f
5667    path.lineTo(SkBits2Float(0x45c7c90c), SkBits2Float(0x45bc83c3));  // 6393.13f, 6032.47f
5668    path.lineTo(SkBits2Float(0x45c7c849), SkBits2Float(0x45bc84ad));  // 6393.04f, 6032.58f
5669    path.lineTo(SkBits2Float(0x45c7c784), SkBits2Float(0x45bc8595));  // 6392.94f, 6032.7f
5670    path.lineTo(SkBits2Float(0x45c7c6bc), SkBits2Float(0x45bc8679));  // 6392.84f, 6032.81f
5671    path.lineTo(SkBits2Float(0x45c7c5f3), SkBits2Float(0x45bc875b));  // 6392.74f, 6032.92f
5672    path.lineTo(SkBits2Float(0x45c7c528), SkBits2Float(0x45bc883a));  // 6392.64f, 6033.03f
5673    path.lineTo(SkBits2Float(0x45c7c45a), SkBits2Float(0x45bc8917));  // 6392.54f, 6033.14f
5674    path.lineTo(SkBits2Float(0x45c7c38b), SkBits2Float(0x45bc89f0));  // 6392.44f, 6033.24f
5675    path.lineTo(SkBits2Float(0x45c7c2b9), SkBits2Float(0x45bc8ac6));  // 6392.34f, 6033.35f
5676    path.lineTo(SkBits2Float(0x45c7c1e6), SkBits2Float(0x45bc8b99));  // 6392.24f, 6033.45f
5677    path.lineTo(SkBits2Float(0x45c7c111), SkBits2Float(0x45bc8c69));  // 6392.13f, 6033.55f
5678    path.lineTo(SkBits2Float(0x45c7c03a), SkBits2Float(0x45bc8d36));  // 6392.03f, 6033.65f
5679    path.lineTo(SkBits2Float(0x45c7bf62), SkBits2Float(0x45bc8e00));  // 6391.92f, 6033.75f
5680    path.lineTo(SkBits2Float(0x45c7be88), SkBits2Float(0x45bc8ec7));  // 6391.82f, 6033.85f
5681    path.lineTo(SkBits2Float(0x45c7bdac), SkBits2Float(0x45bc8f8a));  // 6391.71f, 6033.94f
5682    path.lineTo(SkBits2Float(0x45c7bccf), SkBits2Float(0x45bc904a));  // 6391.6f, 6034.04f
5683    path.lineTo(SkBits2Float(0x45c7bbf0), SkBits2Float(0x45bc9106));  // 6391.49f, 6034.13f
5684    path.lineTo(SkBits2Float(0x45c7bb0f), SkBits2Float(0x45bc91bf));  // 6391.38f, 6034.22f
5685    path.lineTo(SkBits2Float(0x45c7ba2d), SkBits2Float(0x45bc9275));  // 6391.27f, 6034.31f
5686    path.lineTo(SkBits2Float(0x45c7b94a), SkBits2Float(0x45bc9327));  // 6391.16f, 6034.39f
5687    path.lineTo(SkBits2Float(0x45c7b866), SkBits2Float(0x45bc93d5));  // 6391.05f, 6034.48f
5688    path.lineTo(SkBits2Float(0x45c7b780), SkBits2Float(0x45bc9480));  // 6390.94f, 6034.56f
5689    path.lineTo(SkBits2Float(0x45c7b699), SkBits2Float(0x45bc9527));  // 6390.82f, 6034.64f
5690    path.lineTo(SkBits2Float(0x45c7b5b1), SkBits2Float(0x45bc95ca));  // 6390.71f, 6034.72f
5691    path.lineTo(SkBits2Float(0x45c7b4c8), SkBits2Float(0x45bc966a));  // 6390.6f, 6034.8f
5692    path.lineTo(SkBits2Float(0x45c7b3dd), SkBits2Float(0x45bc9706));  // 6390.48f, 6034.88f
5693    path.lineTo(SkBits2Float(0x45c7b2f2), SkBits2Float(0x45bc979e));  // 6390.37f, 6034.95f
5694    path.lineTo(SkBits2Float(0x45c7b205), SkBits2Float(0x45bc9832));  // 6390.25f, 6035.02f
5695    path.lineTo(SkBits2Float(0x45c7b118), SkBits2Float(0x45bc98c2));  // 6390.14f, 6035.09f
5696    path.lineTo(SkBits2Float(0x45c7b02a), SkBits2Float(0x45bc994e));  // 6390.02f, 6035.16f
5697    path.lineTo(SkBits2Float(0x45c7af3b), SkBits2Float(0x45bc99d5));  // 6389.9f, 6035.23f
5698    path.lineTo(SkBits2Float(0x45c7ae4b), SkBits2Float(0x45bc9a59));  // 6389.79f, 6035.29f
5699    path.lineTo(SkBits2Float(0x45c7ad5a), SkBits2Float(0x45bc9ad9));  // 6389.67f, 6035.36f
5700    path.lineTo(SkBits2Float(0x45c7ac69), SkBits2Float(0x45bc9b54));  // 6389.55f, 6035.42f
5701    path.lineTo(SkBits2Float(0x45c7ab77), SkBits2Float(0x45bc9bcb));  // 6389.43f, 6035.47f
5702    path.lineTo(SkBits2Float(0x45c7aa84), SkBits2Float(0x45bc9c3e));  // 6389.31f, 6035.53f
5703    path.lineTo(SkBits2Float(0x45c7a991), SkBits2Float(0x45bc9cac));  // 6389.2f, 6035.58f
5704    path.lineTo(SkBits2Float(0x45c7a89e), SkBits2Float(0x45bc9d16));  // 6389.08f, 6035.64f
5705    path.lineTo(SkBits2Float(0x45c7a7aa), SkBits2Float(0x45bc9d7b));  // 6388.96f, 6035.69f
5706    path.lineTo(SkBits2Float(0x45c7a6b6), SkBits2Float(0x45bc9ddc));  // 6388.84f, 6035.73f
5707    path.lineTo(SkBits2Float(0x45c7a5c1), SkBits2Float(0x45bc9e39));  // 6388.72f, 6035.78f
5708    path.lineTo(SkBits2Float(0x45c7a4cc), SkBits2Float(0x45bc9e90));  // 6388.6f, 6035.82f
5709    path.lineTo(SkBits2Float(0x45c7a3d7), SkBits2Float(0x45bc9ee3));  // 6388.48f, 6035.86f
5710    path.lineTo(SkBits2Float(0x45c7a2e1), SkBits2Float(0x45bc9f32));  // 6388.36f, 6035.9f
5711    path.lineTo(SkBits2Float(0x45c7a1eb), SkBits2Float(0x45bc9f7b));  // 6388.24f, 6035.94f
5712    path.lineTo(SkBits2Float(0x45c7a0f6), SkBits2Float(0x45bc9fc0));  // 6388.12f, 6035.97f
5713    path.lineTo(SkBits2Float(0x45c7a000), SkBits2Float(0x45bca000));  // 6388, 6036
5714    path.lineTo(SkBits2Float(0x45b56000), SkBits2Float(0x45bca000));  // 5804, 6036
5715    path.close();
5727     testPathOp(reporter, path, path2, kIntersect_SkPathOp, filename);
5731     SkPath path, path2;
5732     path.setFillType(SkPathFillType::kEvenOdd);
5733     path.addRect(SkRect{278.653992f, 155.747406f, 580.15918f, 593.602051f});
5736     testPathOp(reporter, path, path2, kIntersect_SkPathOp, filename);
5740     SkPath path, pathB;
5741     path.setFillType(SkPathFillType::kWinding);
5742     path.moveTo(0, 0);
5743     path.lineTo(0, 60);
5744     path.lineTo(60, 60);
5745     path.lineTo(60, 0);
5746     path.close();
5747     path.moveTo(30, 20);
5748     path.lineTo(30, 50);
5749     path.lineTo(50, 50);
5750     path.lineTo(50, 20);
5751     path.close();
5752     path.moveTo(24, 20);
5753     path.lineTo(24, 30);
5754     path.lineTo(36, 30);
5755     path.lineTo(36, 20);
5756     path.close();
5758     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
5762 SkPath path, path1;
5763 path.setFillType(SkPathFillType::kWinding);
5764         path.moveTo(SkBits2Float(0x440bc02c), SkBits2Float(0x4409c000));  // 559.003f, 551
5765         path.lineTo(SkBits2Float(0x440bc02c), SkBits2Float(0x440e8000));  // 559.003f, 570
5766         path.lineTo(SkBits2Float(0x440bbfda), SkBits2Float(0x440e8000));  // 558.998f, 570
5767         path.lineTo(SkBits2Float(0x440bbfda), SkBits2Float(0x4409c000));  // 558.998f, 551
5768         path.lineTo(SkBits2Float(0x440bc02c), SkBits2Float(0x4409c000));  // 559.003f, 551
5769         path.close();
5770 path1 = path;
5771 path.reset();
5772         path.setFillType(SkPathFillType::kWinding);
5773         path.moveTo(SkBits2Float(0x45582000), SkBits2Float(0x45be9805));  // 3458, 6099
5774         path.lineTo(SkBits2Float(0x4554b667), SkBits2Float(0x45be9805));  // 3403.4f, 6099
5775         path.lineTo(SkBits2Float(0x4554b667), SkBits2Float(0x45be97fb));  // 3403.4f, 6099
5776         path.lineTo(SkBits2Float(0x45582000), SkBits2Float(0x45be97fb));  // 3458, 6099
5777         path.lineTo(SkBits2Float(0x45582000), SkBits2Float(0x45be9805));  // 3458, 6099
5778         path.close();
5779         path.moveTo(SkBits2Float(0x43b60000), SkBits2Float(0x443dffd7));  // 364, 759.997f
5780         path.lineTo(SkBits2Float(0x4554b667), SkBits2Float(0x443dffd7));  // 3403.4f, 759.997f
5781         path.lineTo(SkBits2Float(0x4554b667), SkBits2Float(0x443e0029));  // 3403.4f, 760.003f
5782         path.lineTo(SkBits2Float(0x43b60000), SkBits2Float(0x443e0029));  // 364, 760.003f
5783         path.lineTo(SkBits2Float(0x43b60000), SkBits2Float(0x443dffd7));  // 364, 759.997f
5784         path.close();
5785         path.moveTo(SkBits2Float(0x4554b65d), SkBits2Float(0x45be9800));  // 3403.4f, 6099
5786         path.lineTo(SkBits2Float(0x4554b65d), SkBits2Float(0x443e0000));  // 3403.4f, 760
5787         path.lineTo(SkBits2Float(0x4554b671), SkBits2Float(0x443e0000));  // 3403.4f, 760
5788         path.lineTo(SkBits2Float(0x4554b671), SkBits2Float(0x45be9800));  // 3403.4f, 6099
5789         path.lineTo(SkBits2Float(0x4554b65d), SkBits2Float(0x45be9800));  // 3403.4f, 6099
5790         path.close();
5791         path.moveTo(SkBits2Float(0x449f4000), SkBits2Float(0x43bdffae));  // 1274, 379.997f
5792         path.lineTo(SkBits2Float(0x4554b667), SkBits2Float(0x43bdffae));  // 3403.4f, 379.997f
5793         path.lineTo(SkBits2Float(0x4554b667), SkBits2Float(0x43be0052));  // 3403.4f, 380.003f
5794         path.lineTo(SkBits2Float(0x449f4000), SkBits2Float(0x43be0052));  // 1274, 380.003f
5795         path.lineTo(SkBits2Float(0x449f4000), SkBits2Float(0x43bdffae));  // 1274, 379.997f
5796         path.close();
5797         path.moveTo(SkBits2Float(0x4554b65d), SkBits2Float(0x443e0000));  // 3403.4f, 760
5798         path.lineTo(SkBits2Float(0x4554b65d), SkBits2Float(0x43be0000));  // 3403.4f, 380
5799         path.lineTo(SkBits2Float(0x4554b671), SkBits2Float(0x43be0000));  // 3403.4f, 380
5800         path.lineTo(SkBits2Float(0x4554b671), SkBits2Float(0x443e0000));  // 3403.4f, 760
5801         path.lineTo(SkBits2Float(0x4554b65d), SkBits2Float(0x443e0000));  // 3403.4f, 760
5802         path.close();
5803             testPathOp(reporter, path1, path, kUnion_SkPathOp, filename);
5807 SkPath path, path1;
5808 path.setFillType(SkPathFillType::kWinding);
5809 path.moveTo(25.0098f, 23.1973f);
5810 path.lineTo(25.5689f, 22.3682f);
5811 path.conicTo(26.1281f, 21.5392f, 26.9572f, 22.0984f, 0.707107f);
5812 path.conicTo(27.7862f, 22.6576f, 27.227f, 23.4866f, 0.707107f);
5813 path.lineTo(26.6678f, 24.3156f);
5814 path.conicTo(26.1086f, 25.1447f, 25.2796f, 24.5855f, 0.707107f);
5815 path.conicTo(24.4506f, 24.0263f, 25.0098f, 23.1973f, 0.707107f);
5816 path.close();
5817 path.moveTo(26.6873f, 20.7101f);
5818 path.lineTo(27.2465f, 19.8811f);
5819 path.conicTo(27.8057f, 19.0521f, 28.6348f, 19.6113f, 0.707107f);
5820 path.conicTo(29.4638f, 20.1704f, 28.9046f, 20.9995f, 0.707107f);
5821 path.lineTo(28.3454f, 21.8285f);
5822 path.conicTo(27.7862f, 22.6576f, 26.9572f, 22.0984f, 0.707107f);
5823 path.conicTo(26.1281f, 21.5392f, 26.6873f, 20.7101f, 0.707107f);
5824 path.close();
5825 path.moveTo(28.3649f, 18.223f);
5826 path.lineTo(28.9241f, 17.394f);
5827 path.conicTo(29.4833f, 16.565f, 30.3123f, 17.1241f, 0.707107f);
5828 path.conicTo(31.1414f, 17.6833f, 30.5822f, 18.5124f, 0.707107f);
5829 path.lineTo(30.023f, 19.3414f);
5830 path.conicTo(29.4638f, 20.1704f, 28.6348f, 19.6113f, 0.707107f);
5831 path.conicTo(27.8057f, 19.0521f, 28.3649f, 18.223f, 0.707107f);
5832 path.close();
5833 path.moveTo(30.0425f, 15.7359f);
5834 path.lineTo(30.6017f, 14.9069f);
5835 path.conicTo(31.1609f, 14.0778f, 31.9899f, 14.637f, 0.707107f);
5836 path.conicTo(32.8189f, 15.1962f, 32.2598f, 16.0253f, 0.707107f);
5837 path.lineTo(31.7006f, 16.8543f);
5838 path.conicTo(31.1414f, 17.6833f, 30.3123f, 17.1241f, 0.707107f);
5839 path.conicTo(29.4833f, 16.565f, 30.0425f, 15.7359f, 0.707107f);
5840 path.close();
5841 path.moveTo(31.7201f, 13.2488f);
5842 path.lineTo(32.2793f, 12.4198f);
5843 path.conicTo(32.8385f, 11.5907f, 33.6675f, 12.1499f, 0.707107f);
5844 path.conicTo(34.4965f, 12.7091f, 33.9373f, 13.5381f, 0.707107f);
5845 path.lineTo(33.3781f, 14.3672f);
5846 path.conicTo(32.8189f, 15.1962f, 31.9899f, 14.637f, 0.707107f);
5847 path.conicTo(31.1609f, 14.0778f, 31.7201f, 13.2488f, 0.707107f);
5848 path.close();
5849 path.moveTo(33.3976f, 10.7617f);
5850 path.lineTo(33.9568f, 9.93265f);
5851 path.conicTo(34.516f, 9.10361f, 35.3451f, 9.6628f, 0.707107f);
5852 path.conicTo(36.1741f, 10.222f, 35.6149f, 11.051f, 0.707107f);
5853 path.lineTo(35.0557f, 11.8801f);
5854 path.conicTo(34.4965f, 12.7091f, 33.6675f, 12.1499f, 0.707107f);
5855 path.conicTo(32.8385f, 11.5907f, 33.3976f, 10.7617f, 0.707107f);
5856 path.close();
5857 path.moveTo(35.0752f, 8.27457f);
5858 path.lineTo(35.6344f, 7.44554f);
5859 path.conicTo(36.1936f, 6.6165f, 37.0226f, 7.17569f, 0.707107f);
5860 path.conicTo(37.8517f, 7.73488f, 37.2925f, 8.56392f, 0.707107f);
5861 path.lineTo(36.7333f, 9.39296f);
5862 path.conicTo(36.1741f, 10.222f, 35.3451f, 9.6628f, 0.707107f);
5863 path.conicTo(34.516f, 9.10361f, 35.0752f, 8.27457f, 0.707107f);
5864 path.close();
5865 path.moveTo(36.7528f, 5.78746f);
5866 path.lineTo(37.312f, 4.95842f);
5867 path.conicTo(37.8712f, 4.12939f, 38.7002f, 4.68858f, 0.707107f);
5868 path.conicTo(39.5293f, 5.24777f, 38.9701f, 6.07681f, 0.707107f);
5869 path.lineTo(38.4109f, 6.90585f);
5870 path.conicTo(37.8517f, 7.73488f, 37.0226f, 7.17569f, 0.707107f);
5871 path.conicTo(36.1936f, 6.6165f, 36.7528f, 5.78746f, 0.707107f);
5872 path.close();
5873 path.moveTo(39.9447f, 3.72429f);
5874 path.quadTo(40.3524f, 4.01069f, 40.7489f, 4.31248f);
5875 path.conicTo(41.5445f, 4.9182f, 40.9388f, 5.71387f, 0.707107f);
5876 path.conicTo(40.3331f, 6.50955f, 39.5374f, 5.90383f, 0.707107f);
5877 path.quadTo(39.1714f, 5.62521f, 38.7951f, 5.36088f);
5878 path.conicTo(37.9768f, 4.78608f, 38.5516f, 3.96779f, 0.707107f);
5879 path.conicTo(39.1264f, 3.14949f, 39.9447f, 3.72429f, 0.707107f);
5880 path.close();
5881 path.moveTo(42.3194f, 5.60826f);
5882 path.quadTo(42.707f, 5.95446f, 43.0804f, 6.31583f);
5883 path.conicTo(43.7991f, 7.01122f, 43.1037f, 7.72985f, 0.707107f);
5884 path.conicTo(42.4083f, 8.44848f, 41.6896f, 7.75308f, 0.707107f);
5885 path.quadTo(41.3448f, 7.41944f, 40.9871f, 7.09992f);
5886 path.conicTo(40.2413f, 6.43379f, 40.9074f, 5.68796f, 0.707107f);
5887 path.conicTo(41.5735f, 4.94212f, 42.3194f, 5.60826f, 0.707107f);
5888 path.close();
5889 path.moveTo(44.5406f, 7.84871f);
5890 path.quadTo(44.8959f, 8.25352f, 45.2341f, 8.67266f);
5891 path.conicTo(45.862f, 9.4509f, 45.0838f, 10.0789f, 0.707107f);
5892 path.conicTo(44.3056f, 10.7068f, 43.6776f, 9.9286f, 0.707107f);
5893 path.quadTo(43.3654f, 9.54174f, 43.0374f, 9.16805f);
5894 path.conicTo(42.3778f, 8.41649f, 43.1293f, 7.75682f, 0.707107f);
5895 path.conicTo(43.8809f, 7.09715f, 44.5406f, 7.84871f, 0.707107f);
5896 path.close();
5897 path.moveTo(46.528f, 10.4211f);
5898 path.quadTo(46.815f, 10.8449f, 47.0851f, 11.2796f);
5899 path.conicTo(47.6128f, 12.129f, 46.7633f, 12.6567f, 0.707107f);
5900 path.conicTo(45.9139f, 13.1844f, 45.3862f, 12.335f, 0.707107f);
5901 path.quadTo(45.1369f, 11.9337f, 44.872f, 11.5426f);
5902 path.conicTo(44.3113f, 10.7146f, 45.1393f, 10.1538f, 0.707107f);
5903 path.conicTo(45.9673f, 9.5931f, 46.528f, 10.4211f, 0.707107f);
5904 path.close();
5905 path.moveTo(48.1056f, 13.0782f);
5906 path.quadTo(48.3449f, 13.542f, 48.5654f, 14.015f);
5907 path.conicTo(48.9879f, 14.9213f, 48.0816f, 15.3438f, 0.707107f);
5908 path.conicTo(47.1752f, 15.7663f, 46.7527f, 14.86f, 0.707107f);
5909 path.quadTo(46.5492f, 14.4234f, 46.3283f, 13.9953f);
5910 path.conicTo(45.8698f, 13.1066f, 46.7584f, 12.6481f, 0.707107f);
5911 path.conicTo(47.6471f, 12.1895f, 48.1056f, 13.0782f, 0.707107f);
5912 path.close();
5913 path.moveTo(49.3755f, 15.9538f);
5914 path.quadTo(49.5594f, 16.4493f, 49.7229f, 16.9516f);
5915 path.conicTo(50.0325f, 17.9025f, 49.0816f, 18.2121f, 0.707107f);
5916 path.conicTo(48.1307f, 18.5216f, 47.8212f, 17.5707f, 0.707107f);
5917 path.quadTo(47.6702f, 17.1069f, 47.5005f, 16.6497f);
5918 path.conicTo(47.1526f, 15.7122f, 48.0901f, 15.3642f, 0.707107f);
5919 path.conicTo(49.0276f, 15.0163f, 49.3755f, 15.9538f, 0.707107f);
5920 path.close();
5921 path.moveTo(50.2964f, 18.9923f);
5922 path.quadTo(50.4191f, 19.5089f, 50.5206f, 20.0302f);
5923 path.conicTo(50.7117f, 21.0117f, 49.7302f, 21.2029f, 0.707107f);
5924 path.conicTo(48.7486f, 21.394f, 48.5575f, 20.4125f, 0.707107f);
5925 path.quadTo(48.4638f, 19.9313f, 48.3505f, 19.4544f);
5926 path.conicTo(48.1194f, 18.4815f, 49.0924f, 18.2504f, 0.707107f);
5927 path.conicTo(50.0653f, 18.0193f, 50.2964f, 18.9923f, 0.707107f);
5928 path.close();
5929 path.moveTo(50.8373f, 22.0956f);
5930 path.quadTo(50.8955f, 22.6138f, 50.933f, 23.1341f);
5931 path.conicTo(51.0047f, 24.1315f, 50.0073f, 24.2033f, 0.707107f);
5932 path.conicTo(49.0099f, 24.275f, 48.9381f, 23.2776f, 0.707107f);
5933 path.quadTo(48.9036f, 22.7975f, 48.8498f, 22.3191f);
5934 path.conicTo(48.7381f, 21.3253f, 49.7318f, 21.2136f, 0.707107f);
5935 path.conicTo(50.7255f, 21.1019f, 50.8373f, 22.0956f, 0.707107f);
5936 path.close();
5937 path.moveTo(50.9992f, 25.2099f);
5938 path.quadTo(50.9949f, 25.7358f, 50.9694f, 26.2608f);
5939 path.conicTo(50.9209f, 27.2596f, 49.9221f, 27.2111f, 0.707107f);
5940 path.conicTo(48.9233f, 27.1626f, 48.9718f, 26.1638f, 0.707107f);
5941 path.quadTo(48.9953f, 25.679f, 48.9992f, 25.1938f);
5942 path.conicTo(49.0073f, 24.1938f, 50.0073f, 24.2019f, 0.707107f);
5943 path.conicTo(51.0072f, 24.21f, 50.9992f, 25.2099f, 0.707107f);
5944 path.close();
5945 path.moveTo(50.7839f, 28.3454f);
5946 path.quadTo(50.7172f, 28.8596f, 50.63f, 29.3708f);
5947 path.conicTo(50.4619f, 30.3565f, 49.4761f, 30.1884f, 0.707107f);
5948 path.conicTo(48.4903f, 30.0203f, 48.6584f, 29.0346f, 0.707107f);
5949 path.quadTo(48.7389f, 28.5627f, 48.8005f, 28.088f);
5950 path.conicTo(48.9292f, 27.0963f, 49.9209f, 27.225f, 0.707107f);
5951 path.conicTo(50.9126f, 27.3537f, 50.7839f, 28.3454f, 0.707107f);
5952 path.close();
5953 path.moveTo(50.1906f, 31.437f);
5954 path.quadTo(50.0558f, 31.9646f, 49.899f, 32.4861f);
5955 path.conicTo(49.611f, 33.4438f, 48.6534f, 33.1558f, 0.707107f);
5956 path.conicTo(47.6957f, 32.8679f, 47.9837f, 31.9103f, 0.707107f);
5957 path.quadTo(48.1284f, 31.4289f, 48.2528f, 30.9418f);
5958 path.conicTo(48.5004f, 29.9729f, 49.4693f, 30.2205f, 0.707107f);
5959 path.conicTo(50.4382f, 30.4681f, 50.1906f, 31.437f, 0.707107f);
5960 path.close();
5961 path.moveTo(49.1978f, 34.5114f);
5962 path.quadTo(49.0051f, 35.0016f, 48.7927f, 35.4837f);
5963 path.conicTo(48.3895f, 36.3988f, 47.4744f, 35.9956f, 0.707107f);
5964 path.conicTo(46.5593f, 35.5923f, 46.9625f, 34.6772f, 0.707107f);
5965 path.quadTo(47.1586f, 34.2323f, 47.3364f, 33.7797f);
5966 path.conicTo(47.7023f, 32.849f, 48.6329f, 33.2149f, 0.707107f);
5967 path.conicTo(49.5636f, 33.5807f, 49.1978f, 34.5114f, 0.707107f);
5968 path.close();
5969 path.moveTo(47.8852f, 37.3397f);
5970 path.quadTo(47.6449f, 37.7853f, 47.3876f, 38.2211f);
5971 path.conicTo(46.879f, 39.0821f, 46.018f, 38.5736f, 0.707107f);
5972 path.conicTo(45.1569f, 38.0651f, 45.6655f, 37.204f, 0.707107f);
5973 path.quadTo(45.903f, 36.8018f, 46.1248f, 36.3906f);
5974 path.conicTo(46.5993f, 35.5103f, 47.4796f, 35.9849f, 0.707107f);
5975 path.conicTo(48.3598f, 36.4595f, 47.8852f, 37.3397f, 0.707107f);
5976 path.close();
5977 path.moveTo(46.3154f, 39.8881f);
5978 path.quadTo(46.0303f, 40.2962f, 45.7299f, 40.693f);
5979 path.conicTo(45.1264f, 41.4903f, 44.3291f, 40.8867f, 0.707107f);
5980 path.conicTo(43.5318f, 40.2831f, 44.1353f, 39.4858f, 0.707107f);
5981 path.quadTo(44.4126f, 39.1195f, 44.6757f, 38.7428f);
5982 path.conicTo(45.2483f, 37.923f, 46.0682f, 38.4956f, 0.707107f);
5983 path.conicTo(46.888f, 39.0682f, 46.3154f, 39.8881f, 0.707107f);
5984 path.close();
5985 path.moveTo(44.4398f, 42.2654f);
5986 path.quadTo(44.095f, 42.6536f, 43.7349f, 43.0278f);
5987 path.conicTo(43.0415f, 43.7484f, 42.321f, 43.055f, 0.707107f);
5988 path.conicTo(41.6004f, 42.3616f, 42.2938f, 41.641f, 0.707107f);
5989 path.quadTo(42.6261f, 41.2957f, 42.9444f, 40.9374f);
5990 path.conicTo(43.6084f, 40.1897f, 44.3561f, 40.8537f, 0.707107f);
5991 path.conicTo(45.1038f, 41.5177f, 44.4398f, 42.2654f, 0.707107f);
5992 path.close();
5993 path.moveTo(42.2075f, 44.4911f);
5994 path.quadTo(41.804f, 44.8473f, 41.3862f, 45.1865f);
5995 path.conicTo(40.6098f, 45.8167f, 39.9795f, 45.0403f, 0.707107f);
5996 path.conicTo(39.3493f, 44.2639f, 40.1257f, 43.6336f, 0.707107f);
5997 path.quadTo(40.5114f, 43.3205f, 40.8838f, 42.9918f);
5998 path.conicTo(41.6335f, 42.3299f, 42.2953f, 43.0796f, 0.707107f);
5999 path.conicTo(42.9572f, 43.8292f, 42.2075f, 44.4911f, 0.707107f);
6000 path.close();
6001 path.moveTo(39.6379f, 46.488f);
6002 path.quadTo(39.2151f, 46.776f, 38.7814f, 47.0471f);
6003 path.conicTo(37.9334f, 47.5771f, 37.4034f, 46.7292f, 0.707107f);
6004 path.conicTo(36.8733f, 45.8812f, 37.7213f, 45.3511f, 0.707107f);
6005 path.quadTo(38.1217f, 45.1009f, 38.5119f, 44.835f);
6006 path.conicTo(39.3383f, 44.2721f, 39.9013f, 45.0985f, 0.707107f);
6007 path.conicTo(40.4643f, 45.925f, 39.6379f, 46.488f, 0.707107f);
6008 path.close();
6009 path.moveTo(36.9864f, 48.0722f);
6010 path.quadTo(36.5234f, 48.3127f, 36.0513f, 48.5344f);
6011 path.conicTo(35.1461f, 48.9595f, 34.7211f, 48.0543f, 0.707107f);
6012 path.conicTo(34.296f, 47.1491f, 35.2012f, 46.7241f, 0.707107f);
6013 path.quadTo(35.6371f, 46.5194f, 36.0644f, 46.2974f);
6014 path.conicTo(36.9518f, 45.8364f, 37.4128f, 46.7238f, 0.707107f);
6015 path.conicTo(37.8738f, 47.6112f, 36.9864f, 48.0722f, 0.707107f);
6016 path.close();
6017 path.moveTo(34.1153f, 49.3498f);
6018 path.quadTo(33.6206f, 49.535f, 33.1187f, 49.6999f);
6019 path.conicTo(32.1687f, 50.0122f, 31.8565f, 49.0622f, 0.707107f);
6020 path.conicTo(31.5442f, 48.1122f, 32.4942f, 47.7999f, 0.707107f);
6021 path.quadTo(32.9575f, 47.6477f, 33.4141f, 47.4767f);
6022 path.conicTo(34.3507f, 47.1261f, 34.7012f, 48.0627f, 0.707107f);
6023 path.conicTo(35.0518f, 48.9992f, 34.1153f, 49.3498f, 0.707107f);
6024 path.close();
6025 path.moveTo(31.08f, 50.2791f);
6026 path.quadTo(30.5637f, 50.4033f, 30.0427f, 50.5063f);
6027 path.conicTo(29.0617f, 50.7002f, 28.8678f, 49.7192f, 0.707107f);
6028 path.conicTo(28.6738f, 48.7382f, 29.6548f, 48.5443f, 0.707107f);
6029 path.quadTo(30.1357f, 48.4492f, 30.6122f, 48.3346f);
6030 path.conicTo(31.5845f, 48.1007f, 31.8184f, 49.073f, 0.707107f);
6031 path.conicTo(32.0522f, 50.0453f, 31.08f, 50.2791f, 0.707107f);
6032 path.close();
6033 path.moveTo(27.9769f, 50.829f);
6034 path.quadTo(27.4588f, 50.8887f, 26.9386f, 50.9276f);
6035 path.conicTo(25.9414f, 51.0022f, 25.8668f, 50.005f, 0.707107f);
6036 path.conicTo(25.7923f, 49.0078f, 26.7895f, 48.9332f, 0.707107f);
6037 path.quadTo(27.2696f, 48.8973f, 27.7479f, 48.8422f);
6038 path.conicTo(28.7413f, 48.7277f, 28.8558f, 49.7211f, 0.707107f);
6039 path.conicTo(28.9703f, 50.7145f, 27.9769f, 50.829f, 0.707107f);
6040 path.close();
6041 path.moveTo(24.8625f, 50.9996f);
6042 path.quadTo(24.3373f, 50.9969f, 23.8128f, 50.9729f);
6043 path.conicTo(22.8138f, 50.9272f, 22.8595f, 49.9283f, 0.707107f);
6044 path.conicTo(22.9051f, 48.9293f, 23.9041f, 48.975f, 0.707107f);
6045 path.quadTo(24.3884f, 48.9971f, 24.8731f, 48.9997f);
6046 path.conicTo(25.8731f, 49.005f, 25.8678f, 50.005f, 0.707107f);
6047 path.conicTo(25.8624f, 51.0049f, 24.8625f, 50.9996f, 0.707107f);
6048 path.close();
6049 path.moveTo(21.7268f, 50.7931f);
6050 path.quadTo(21.2121f, 50.7278f, 20.7005f, 50.642f);
6051 path.conicTo(19.7143f, 50.4767f, 19.8796f, 49.4905f, 0.707107f);
6052 path.conicTo(20.045f, 48.5042f, 21.0312f, 48.6696f, 0.707107f);
6053 path.quadTo(21.5036f, 48.7488f, 21.9786f, 48.8091f);
6054 path.conicTo(22.9707f, 48.9349f, 22.8448f, 49.927f, 0.707107f);
6055 path.conicTo(22.7189f, 50.919f, 21.7268f, 50.7931f, 0.707107f);
6056 path.close();
6057 path.moveTo(18.6372f, 50.2094f);
6058 path.quadTo(18.1089f, 50.0761f, 17.5865f, 49.9207f);
6059 path.conicTo(16.628f, 49.6356f, 16.9132f, 48.6771f, 0.707107f);
6060 path.conicTo(17.1983f, 47.7186f, 18.1568f, 48.0037f, 0.707107f);
6061 path.quadTo(18.639f, 48.1472f, 19.1267f, 48.2702f);
6062 path.conicTo(20.0963f, 48.515f, 19.8516f, 49.4846f, 0.707107f);
6063 path.conicTo(19.6068f, 50.4542f, 18.6372f, 50.2094f, 0.707107f);
6064 path.close();
6065 path.moveTo(15.5577f, 49.2248f);
6066 path.quadTo(15.0665f, 49.0334f, 14.5834f, 48.8222f);
6067 path.conicTo(13.6672f, 48.4215f, 14.0678f, 47.5053f, 0.707107f);
6068 path.conicTo(14.4684f, 46.589f, 15.3847f, 46.9897f, 0.707107f);
6069 path.quadTo(15.8306f, 47.1846f, 16.284f, 47.3614f);
6070 path.conicTo(17.2158f, 47.7246f, 16.8526f, 48.6563f, 0.707107f);
6071 path.conicTo(16.4894f, 49.588f, 15.5577f, 49.2248f, 0.707107f);
6072 path.close();
6073 path.moveTo(12.7231f, 47.9189f);
6074 path.quadTo(12.2765f, 47.6797f, 11.8395f, 47.4233f);
6075 path.conicTo(10.9771f, 46.9171f, 11.4833f, 46.0547f, 0.707107f);
6076 path.conicTo(11.9894f, 45.1922f, 12.8519f, 45.6984f, 0.707107f);
6077 path.quadTo(13.2552f, 45.9351f, 13.6675f, 46.156f);
6078 path.conicTo(14.549f, 46.6282f, 14.0768f, 47.5096f, 0.707107f);
6079 path.conicTo(13.6046f, 48.3911f, 12.7231f, 47.9189f, 0.707107f);
6080 path.close();
6081 path.moveTo(10.1686f, 46.3548f);
6082 path.quadTo(9.76024f, 46.0712f, 9.363f, 45.7722f);
6083 path.conicTo(8.56406f, 45.1708f, 9.16549f, 44.3718f, 0.707107f);
6084 path.conicTo(9.76691f, 43.5729f, 10.5658f, 44.1743f, 0.707107f);
6085 path.quadTo(10.9325f, 44.4504f, 11.3095f, 44.7122f);
6086 path.conicTo(12.1308f, 45.2826f, 11.5604f, 46.1039f, 0.707107f);
6087 path.conicTo(10.9899f, 46.9253f, 10.1686f, 46.3548f, 0.707107f);
6088 path.close();
6089 path.moveTo(7.78853f, 44.4876f);
6090 path.quadTo(7.39972f, 44.1442f, 7.02492f, 43.7855f);
6091 path.conicTo(6.3024f, 43.0942f, 6.99374f, 42.3717f, 0.707107f);
6092 path.conicTo(7.68509f, 41.6492f, 8.40761f, 42.3405f, 0.707107f);
6093 path.quadTo(8.7536f, 42.6715f, 9.11249f, 42.9885f);
6094 path.conicTo(9.86201f, 43.6505f, 9.20003f, 44.4f, 0.707107f);
6095 path.conicTo(8.53805f, 45.1496f, 7.78853f, 44.4876f, 0.707107f);
6096 path.close();
6097 path.moveTo(5.55855f, 42.2635f);
6098 path.quadTo(5.20148f, 41.8614f, 4.86131f, 41.4449f);
6099 path.conicTo(4.22883f, 40.6703f, 5.0034f, 40.0378f, 0.707107f);
6100 path.conicTo(5.77797f, 39.4053f, 6.41046f, 40.1799f, 0.707107f);
6101 path.quadTo(6.72443f, 40.5644f, 7.05403f, 40.9356f);
6102 path.conicTo(7.71802f, 41.6833f, 6.97028f, 42.3473f, 0.707107f);
6103 path.conicTo(6.22254f, 43.0113f, 5.55855f, 42.2635f, 0.707107f);
6104 path.close();
6105 path.moveTo(3.55261f, 39.6973f);
6106 path.quadTo(3.26341f, 39.2752f, 2.99107f, 38.8422f);
6107 path.conicTo(2.45867f, 37.9957f, 3.30517f, 37.4633f, 0.707107f);
6108 path.conicTo(4.15167f, 36.9309f, 4.68406f, 37.7774f, 0.707107f);
6109 path.quadTo(4.93548f, 38.1772f, 5.20241f, 38.5667f);
6110 path.conicTo(5.76769f, 39.3916f, 4.94279f, 39.9569f, 0.707107f);
6111 path.conicTo(4.11789f, 40.5222f, 3.55261f, 39.6973f, 0.707107f);
6112 path.close();
6113 path.moveTo(1.96145f, 37.0509f);
6114 path.quadTo(1.71975f, 36.5889f, 1.49677f, 36.1175f);
6115 path.conicTo(1.06917f, 35.2135f, 1.97315f, 34.7859f, 0.707107f);
6116 path.conicTo(2.87712f, 34.3583f, 3.30471f, 35.2623f, 0.707107f);
6117 path.quadTo(3.51053f, 35.6974f, 3.73364f, 36.1239f);
6118 path.conicTo(4.19714f, 37.01f, 3.31105f, 37.4735f, 0.707107f);
6119 path.conicTo(2.42495f, 37.937f, 1.96145f, 37.0509f, 0.707107f);
6120 path.close();
6121 path.moveTo(0.676191f, 34.1844f);
6122 path.quadTo(0.489621f, 33.6902f, 0.323275f, 33.189f);
6123 path.conicTo(0.00831527f, 32.2399f, 0.95742f, 31.9249f, 0.707107f);
6124 path.conicTo(1.90653f, 31.6099f, 2.22149f, 32.559f, 0.707107f);
6125 path.quadTo(2.37504f, 33.0218f, 2.54726f, 33.4779f);
6126 path.conicTo(2.9005f, 34.4134f, 1.96497f, 34.7666f, 0.707107f);
6127 path.conicTo(1.02943f, 35.1199f, 0.676191f, 34.1844f, 0.707107f);
6128 path.close();
6129 path.moveTo(-0.261658f, 31.1521f);
6130 path.quadTo(-0.387304f, 30.6362f, -0.491779f, 30.1156f);
6131 path.conicTo(-0.68853f, 29.1351f, 0.291923f, 28.9384f, 0.707107f);
6132 path.conicTo(1.27238f, 28.7416f, 1.46913f, 29.7221f, 0.707107f);
6133 path.quadTo(1.56557f, 30.2026f, 1.68155f, 30.6789f);
6134 path.conicTo(1.91817f, 31.6505f, 0.946565f, 31.8871f, 0.707107f);
6135 path.conicTo(-0.0250367f, 32.1237f, -0.261658f, 31.1521f, 0.707107f);
6136 path.close();
6137 path.moveTo(-0.820549f, 28.0495f);
6138 path.quadTo(-0.881733f, 27.5314f, -0.922089f, 27.0113f);
6139 path.conicTo(-0.999449f, 26.0143f, -0.00244591f, 25.9369f, 0.707107f);
6140 path.conicTo(0.994557f, 25.8596f, 1.07192f, 26.8566f, 0.707107f);
6141 path.quadTo(1.10917f, 27.3367f, 1.16565f, 27.8149f);
6142 path.conicTo(1.28293f, 28.808f, 0.289834f, 28.9253f, 0.707107f);
6143 path.conicTo(-0.703265f, 29.0426f, -0.820549f, 28.0495f, 0.707107f);
6144 path.close();
6145 path.moveTo(-0.999918f, 24.9349f);
6146 path.quadTo(-0.998605f, 24.4104f, -0.976138f, 23.8863f);
6147 path.conicTo(-0.933305f, 22.8873f, 0.0657772f, 22.9301f, 0.707107f);
6148 path.conicTo(1.06486f, 22.9729f, 1.02203f, 23.972f, 0.707107f);
6149 path.quadTo(1.00129f, 24.4557f, 1.00008f, 24.9399f);
6150 path.conicTo(0.997572f, 25.9399f, -0.0024244f, 25.9374f, 0.707107f);
6151 path.conicTo(-1.00242f, 25.9349f, -0.999918f, 24.9349f, 0.707107f);
6152 path.close();
6153 path.moveTo(-0.802212f, 21.7991f);
6154 path.quadTo(-0.738311f, 21.284f, -0.653903f, 20.7719f);
6155 path.conicTo(-0.491283f, 19.7852f, 0.495406f, 19.9478f, 0.707107f);
6156 path.conicTo(1.48209f, 20.1104f, 1.31948f, 21.0971f, 0.707107f);
6157 path.quadTo(1.24156f, 21.5698f, 1.18257f, 22.0453f);
6158 path.conicTo(1.05946f, 23.0377f, 0.0670681f, 22.9146f, 0.707107f);
6159 path.conicTo(-0.925325f, 22.7915f, -0.802212f, 21.7991f, 0.707107f);
6160 path.close();
6161 path.moveTo(-0.228066f, 18.7115f);
6162 path.quadTo(-0.096172f, 18.1824f, 0.0577899f, 17.6593f);
6163 path.conicTo(0.340124f, 16.7f, 1.29944f, 16.9823f, 0.707107f);
6164 path.conicTo(2.25876f, 17.2646f, 1.97642f, 18.2239f, 0.707107f);
6165 path.quadTo(1.8343f, 18.7068f, 1.71255f, 19.1953f);
6166 path.conicTo(1.47069f, 20.1656f, 0.50038f, 19.9237f, 0.707107f);
6167 path.conicTo(-0.46993f, 19.6819f, -0.228066f, 18.7115f, 0.707107f);
6168 path.close();
6169 path.moveTo(0.74831f, 15.6269f);
6170 path.quadTo(0.938539f, 15.1347f, 1.14857f, 14.6506f);
6171 path.conicTo(1.54662f, 13.7333f, 2.46398f, 14.1313f, 0.707107f);
6172 path.conicTo(3.38135f, 14.5294f, 2.9833f, 15.4467f, 0.707107f);
6173 path.quadTo(2.78942f, 15.8936f, 2.61382f, 16.3479f);
6174 path.conicTo(2.25331f, 17.2806f, 1.32056f, 16.9201f, 0.707107f);
6175 path.conicTo(0.387801f, 16.5596f, 0.74831f, 15.6269f, 0.707107f);
6176 path.close();
6177 path.moveTo(2.04744f, 12.7861f);
6178 path.quadTo(2.28569f, 12.3384f, 2.5412f, 11.9003f);
6179 path.conicTo(3.04504f, 11.0365f, 3.90884f, 11.5403f, 0.707107f);
6180 path.conicTo(4.77264f, 12.0442f, 4.26881f, 12.908f, 0.707107f);
6181 path.quadTo(4.03293f, 13.3123f, 3.81302f, 13.7256f);
6182 path.conicTo(3.34325f, 14.6084f, 2.46046f, 14.1386f, 0.707107f);
6183 path.conicTo(1.57767f, 13.6689f, 2.04744f, 12.7861f, 0.707107f);
6184 path.close();
6185 path.moveTo(3.60589f, 10.2253f);
6186 path.quadTo(3.88812f, 9.81661f, 4.18576f, 9.419f);
6187 path.conicTo(4.78503f, 8.61845f, 5.58558f, 9.21772f, 0.707107f);
6188 path.conicTo(6.38613f, 9.81699f, 5.78686f, 10.6175f, 0.707107f);
6189 path.quadTo(5.51211f, 10.9846f, 5.25159f, 11.3618f);
6190 path.conicTo(4.68333f, 12.1847f, 3.86048f, 11.6164f, 0.707107f);
6191 path.conicTo(3.03763f, 11.0481f, 3.60589f, 10.2253f, 0.707107f);
6192 path.close();
6193 path.moveTo(5.46482f, 7.84259f);
6194 path.quadTo(5.80682f, 7.4532f, 6.16407f, 7.07773f);
6195 path.conicTo(6.85339f, 6.35327f, 7.57785f, 7.04259f, 0.707107f);
6196 path.conicTo(8.30231f, 7.73191f, 7.61299f, 8.45636f, 0.707107f);
6197 path.quadTo(7.28322f, 8.80295f, 6.96752f, 9.16239f);
6198 path.conicTo(6.30762f, 9.91375f, 5.55627f, 9.25385f, 0.707107f);
6199 path.conicTo(4.80492f, 8.59395f, 5.46482f, 7.84259f, 0.707107f);
6200 path.close();
6201 path.moveTo(7.68062f, 5.60827f);
6202 path.quadTo(8.08142f, 5.25031f, 8.49666f, 4.90921f);
6203 path.conicTo(9.26938f, 4.27447f, 9.90412f, 5.04719f, 0.707107f);
6204 path.conicTo(10.5389f, 5.81992f, 9.76614f, 6.45466f, 0.707107f);
6205 path.quadTo(9.38285f, 6.76951f, 9.01289f, 7.09994f);
6206 path.conicTo(8.26705f, 7.76607f, 7.60092f, 7.02024f, 0.707107f);
6207 path.conicTo(6.93479f, 6.2744f, 7.68062f, 5.60827f, 0.707107f);
6208 path.close();
6209 path.moveTo(10.2392f, 3.59627f);
6210 path.quadTo(10.6626f, 3.30433f, 11.0971f, 3.02935f);
6211 path.conicTo(11.9421f, 2.49463f, 12.4768f, 3.33965f, 0.707107f);
6212 path.conicTo(13.0116f, 4.18467f, 12.1666f, 4.7194f, 0.707107f);
6213 path.quadTo(11.7654f, 4.97322f, 11.3747f, 5.24271f);
6214 path.conicTo(10.5515f, 5.81043f, 9.98373f, 4.98721f, 0.707107f);
6215 path.conicTo(9.41601f, 4.16399f, 10.2392f, 3.59627f, 0.707107f);
6216 path.close();
6217 path.moveTo(12.8847f, 1.99524f);
6218 path.quadTo(13.3459f, 1.75234f, 13.8165f, 1.52812f);
6219 path.conicTo(14.7193f, 1.09799f, 15.1494f, 2.00075f, 0.707107f);
6220 path.conicTo(15.5795f, 2.90352f, 14.6768f, 3.33365f, 0.707107f);
6221 path.quadTo(14.2424f, 3.54063f, 13.8166f, 3.76484f);
6222 path.conicTo(12.9318f, 4.23081f, 12.4658f, 3.34601f, 0.707107f);
6223 path.conicTo(11.9999f, 2.46122f, 12.8847f, 1.99524f, 0.707107f);
6224 path.close();
6225 path.moveTo(15.7467f, 0.702339f);
6226 path.quadTo(16.2402f, 0.514409f, 16.7409f, 0.346672f);
6227 path.conicTo(17.6891f, 0.029011f, 18.0067f, 0.977215f, 0.707107f);
6228 path.conicTo(18.3244f, 1.92542f, 17.3762f, 2.24308f, 0.707107f);
6229 path.quadTo(16.914f, 2.39792f, 16.4585f, 2.57139f);
6230 path.conicTo(15.524f, 2.92729f, 15.1681f, 1.99276f, 0.707107f);
6231 path.conicTo(14.8122f, 1.05824f, 15.7467f, 0.702339f, 0.707107f);
6232 path.close();
6233 path.moveTo(18.7758f, -0.24399f);
6234 path.quadTo(19.2913f, -0.371107f, 19.8116f, -0.477061f);
6235 path.conicTo(20.7915f, -0.676608f, 20.9911f, 0.303281f, 0.707107f);
6236 path.conicTo(21.1906f, 1.28317f, 20.2107f, 1.48272f, 0.707107f);
6237 path.quadTo(19.7304f, 1.58052f, 19.2546f, 1.69785f);
6238 path.conicTo(18.2836f, 1.93725f, 18.0443f, 0.966329f, 0.707107f);
6239 path.conicTo(17.8049f, -0.00459272f, 18.7758f, -0.24399f, 0.707107f);
6240 path.close();
6241 path.moveTo(21.878f, -0.811882f);
6242 path.quadTo(22.396f, -0.874528f, 22.916f, -0.916348f);
6243 path.conicTo(23.9128f, -0.996504f, 23.993f, 0.000278629f, 0.707107f);
6244 path.conicTo(24.0731f, 0.997061f, 23.0764f, 1.07722f, 0.707107f);
6245 path.quadTo(22.5963f, 1.11582f, 22.1182f, 1.17365f);
6246 path.conicTo(21.1254f, 1.29372f, 21.0053f, 0.300958f, 0.707107f);
6247 path.conicTo(20.8853f, -0.691807f, 21.878f, -0.811882f, 0.707107f);
6248 path.close();
6249 path.moveTo(24.9926f, -0.999999f);
6250 path.quadTo(25.5166f, -1.00015f, 26.0401f, -0.979188f);
6251 path.conicTo(27.0393f, -0.939179f, 26.9992f, 0.0600199f, 0.707107f);
6252 path.conicTo(26.9592f, 1.05922f, 25.96f, 1.01921f, 0.707107f);
6253 path.quadTo(25.4768f, 0.999863f, 24.9932f, 1);
6254 path.conicTo(23.9932f, 1.00029f, 23.9929f, 0.000287339f, 0.707107f);
6255 path.conicTo(23.9926f, -0.999713f, 24.9926f, -0.999999f, 0.707107f);
6256 path.close();
6257 path.moveTo(28.1286f, -0.811081f);
6258 path.quadTo(28.6441f, -0.748593f, 29.1567f, -0.665572f);
6259 path.conicTo(30.1439f, -0.505698f, 29.984f, 0.48144f, 0.707107f);
6260 path.conicTo(29.8241f, 1.46858f, 28.837f, 1.3087f, 0.707107f);
6261 path.quadTo(28.3638f, 1.23207f, 27.8879f, 1.17439f);
6262 path.conicTo(26.8952f, 1.05406f, 27.0155f, 0.0613233f, 0.707107f);
6263 path.conicTo(27.1359f, -0.931411f, 28.1286f, -0.811081f, 0.707107f);
6264 path.close();
6265 path.moveTo(31.214f, -0.246499f);
6266 path.quadTo(31.7439f, -0.116076f, 32.2679f, 0.0364622f);
6267 path.conicTo(33.228f, 0.315996f, 32.9485f, 1.27613f, 0.707107f);
6268 path.conicTo(32.6689f, 2.23627f, 31.7088f, 1.95673f, 0.707107f);
6269 path.quadTo(31.2252f, 1.81593f, 30.736f, 1.69554f);
6270 path.conicTo(29.765f, 1.45654f, 30.004f, 0.48552f, 0.707107f);
6271 path.conicTo(30.243f, -0.485499f, 31.214f, -0.246499f, 0.707107f);
6272 path.close();
6273 path.moveTo(34.3038f, 0.721629f);
6274 path.quadTo(34.797f, 0.910612f, 35.282f, 1.11946f);
6275 path.conicTo(36.2005f, 1.51493f, 35.805f, 2.43341f, 0.707107f);
6276 path.conicTo(35.4096f, 3.35189f, 34.4911f, 2.95642f, 0.707107f);
6277 path.quadTo(34.0434f, 2.76365f, 33.5881f, 2.5892f);
6278 path.conicTo(32.6543f, 2.23137f, 33.0122f, 1.29758f, 0.707107f);
6279 path.conicTo(33.37f, 0.363796f, 34.3038f, 0.721629f, 0.707107f);
6280 path.close();
6281 path.moveTo(37.1508f, 2.01396f);
6282 path.quadTo(37.5996f, 2.2512f, 38.0388f, 2.50578f);
6283 path.conicTo(38.904f, 3.00727f, 38.4025f, 3.87244f, 0.707107f);
6284 path.conicTo(37.901f, 4.7376f, 37.0358f, 4.23612f, 0.707107f);
6285 path.quadTo(36.6304f, 4.00111f, 36.2161f, 3.78211f);
6286 path.conicTo(35.332f, 3.31476f, 35.7994f, 2.43069f, 0.707107f);
6287 path.conicTo(36.2667f, 1.54661f, 37.1508f, 2.01396f, 0.707107f);
6288 path.close();
6289 path.moveTo(39.718f, 3.56681f);
6290 path.quadTo(40.1269f, 3.84765f, 40.5249f, 4.14392f);
6291 path.conicTo(41.3271f, 4.74104f, 40.73f, 5.54319f, 0.707107f);
6292 path.conicTo(40.1329f, 6.34535f, 39.3307f, 5.74823f, 0.707107f);
6293 path.quadTo(38.9634f, 5.47478f, 38.5858f, 5.21552f);
6294 path.conicTo(37.7615f, 4.64945f, 38.3275f, 3.82509f, 0.707107f);
6295 path.conicTo(38.8936f, 3.00074f, 39.718f, 3.56681f, 0.707107f);
6296 path.close();
6297 path.moveTo(42.1033f, 5.41741f);
6298 path.quadTo(42.4933f, 5.75802f, 42.8694f, 6.11388f);
6299 path.conicTo(43.5958f, 6.80115f, 42.9085f, 7.52755f, 0.707107f);
6300 path.conicTo(42.2212f, 8.25394f, 41.4948f, 7.56667f, 0.707107f);
6301 path.quadTo(41.1476f, 7.23817f, 40.7876f, 6.92375f);
6302 path.conicTo(40.0345f, 6.26593f, 40.6923f, 5.51275f, 0.707107f);
6303 path.conicTo(41.3501f, 4.75958f, 42.1033f, 5.41741f, 0.707107f);
6304 path.close();
6305 path.moveTo(44.3419f, 7.62498f);
6306 path.quadTo(44.7007f, 8.02444f, 45.0428f, 8.43835f);
6307 path.conicTo(45.6797f, 9.20922f, 44.9089f, 9.84622f, 0.707107f);
6308 path.conicTo(44.138f, 10.4832f, 43.501f, 9.71234f, 0.707107f);
6309 path.quadTo(43.1852f, 9.3302f, 42.854f, 8.96151f);
6310 path.conicTo(42.1858f, 8.21759f, 42.9297f, 7.54932f, 0.707107f);
6311 path.conicTo(43.6736f, 6.88106f, 44.3419f, 7.62498f, 0.707107f);
6312 path.close();
6313 path.moveTo(46.3599f, 10.1759f);
6314 path.quadTo(46.6546f, 10.6005f, 46.9322f, 11.0366f);
6315 path.conicTo(47.4693f, 11.8801f, 46.6257f, 12.4172f, 0.707107f);
6316 path.conicTo(45.7822f, 12.9542f, 45.2451f, 12.1107f, 0.707107f);
6317 path.quadTo(44.9889f, 11.7082f, 44.7168f, 11.3162f);
6318 path.conicTo(44.1467f, 10.4947f, 44.9682f, 9.92452f, 0.707107f);
6319 path.conicTo(45.7897f, 9.35435f, 46.3599f, 10.1759f, 0.707107f);
6320 path.close();
6321 path.moveTo(47.9708f, 12.8204f);
6322 path.quadTo(48.2149f, 13.2808f, 48.4403f, 13.7506f);
6323 path.conicTo(48.873f, 14.6521f, 47.9715f, 15.0848f, 0.707107f);
6324 path.conicTo(47.0699f, 15.5174f, 46.6372f, 14.6159f, 0.707107f);
6325 path.quadTo(46.4291f, 14.1822f, 46.2038f, 13.7573f);
6326 path.conicTo(45.7354f, 12.8738f, 46.6188f, 12.4054f, 0.707107f);
6327 path.conicTo(47.5023f, 11.9369f, 47.9708f, 12.8204f, 0.707107f);
6328 path.close();
6329 path.moveTo(49.2713f, 15.6778f);
6330 path.quadTo(49.4606f, 16.1706f, 49.6297f, 16.6708f);
6331 path.conicTo(49.9501f, 17.6181f, 49.0028f, 17.9384f, 0.707107f);
6332 path.conicTo(48.0555f, 18.2588f, 47.7351f, 17.3115f, 0.707107f);
6333 path.quadTo(47.5791f, 16.8499f, 47.4043f, 16.3949f);
6334 path.conicTo(47.0458f, 15.4614f, 47.9793f, 15.1029f, 0.707107f);
6335 path.conicTo(48.9128f, 14.7443f, 49.2713f, 15.6778f, 0.707107f);
6336 path.close();
6337 path.moveTo(50.2261f, 18.7037f);
6338 path.quadTo(50.3547f, 19.2188f, 50.4621f, 19.7388f);
6339 path.conicTo(50.6645f, 20.7182f, 49.6852f, 20.9205f, 0.707107f);
6340 path.conicTo(48.7059f, 21.1229f, 48.5035f, 20.1436f, 0.707107f);
6341 path.quadTo(48.4043f, 19.6636f, 48.2856f, 19.1881f);
6342 path.conicTo(48.0435f, 18.2178f, 49.0137f, 17.9757f, 0.707107f);
6343 path.conicTo(49.984f, 17.7335f, 50.2261f, 18.7037f, 0.707107f);
6344 path.close();
6345 path.moveTo(50.803f, 21.8055f);
6346 path.quadTo(50.8671f, 22.3234f, 50.9104f, 22.8434f);
6347 path.conicTo(50.9934f, 23.8399f, 49.9968f, 23.9229f, 0.707107f);
6348 path.conicTo(49.0002f, 24.0058f, 48.9173f, 23.0093f, 0.707107f);
6349 path.quadTo(48.8773f, 22.5293f, 48.8182f, 22.0513f);
6350 path.conicTo(48.6953f, 21.0588f, 49.6877f, 20.936f, 0.707107f);
6351 path.conicTo(50.6801f, 20.8131f, 50.803f, 21.8055f, 0.707107f);
6352 path.close();
6353 path.moveTo(50.9999f, 24.9202f);
6354 path.quadTo(51.0015f, 25.4434f, 50.982f, 25.9664f);
6355 path.conicTo(50.9449f, 26.9657f, 49.9456f, 26.9286f, 0.707107f);
6356 path.conicTo(48.9463f, 26.8914f, 48.9834f, 25.8921f, 0.707107f);
6357 path.quadTo(49.0014f, 25.4094f, 48.9999f, 24.9263f);
6358 path.conicTo(48.9968f, 23.9263f, 49.9968f, 23.9232f, 0.707107f);
6359 path.conicTo(50.9968f, 23.9202f, 50.9999f, 24.9202f, 0.707107f);
6360 path.close();
6361 path.moveTo(50.8198f, 28.0562f);
6362 path.quadTo(50.7587f, 28.5721f, 50.677f, 29.0852f);
6363 path.conicTo(50.5199f, 30.0728f, 49.5323f, 29.9157f, 0.707107f);
6364 path.conicTo(48.5448f, 29.7586f, 48.7019f, 28.771f, 0.707107f);
6365 path.quadTo(48.7772f, 28.2974f, 48.8336f, 27.8211f);
6366 path.conicTo(48.9512f, 26.8281f, 49.9442f, 26.9456f, 0.707107f);
6367 path.conicTo(50.9373f, 27.0632f, 50.8198f, 28.0562f, 0.707107f);
6368 path.close();
6369 path.moveTo(50.2647f, 31.1395f);
6370 path.quadTo(50.1358f, 31.6701f, 49.9847f, 32.1949f);
6371 path.conicTo(49.7079f, 33.1558f, 48.747f, 32.8791f, 0.707107f);
6372 path.conicTo(47.786f, 32.6024f, 48.0628f, 31.6414f, 0.707107f);
6373 path.quadTo(48.2022f, 31.1571f, 48.3213f, 30.6672f);
6374 path.conicTo(48.5574f, 29.6955f, 49.5291f, 29.9317f, 0.707107f);
6375 path.conicTo(50.5009f, 30.1678f, 50.2647f, 31.1395f, 0.707107f);
6376 path.close();
6377 path.moveTo(49.3049f, 34.2343f);
6378 path.quadTo(49.1171f, 34.7285f, 48.9095f, 35.2145f);
6379 path.conicTo(48.5166f, 36.1341f, 47.597f, 35.7412f, 0.707107f);
6380 path.conicTo(46.6774f, 35.3483f, 47.0703f, 34.4288f, 0.707107f);
6381 path.quadTo(47.262f, 33.9801f, 47.4353f, 33.524f);
6382 path.conicTo(47.7904f, 32.5892f, 48.7252f, 32.9444f, 0.707107f);
6383 path.conicTo(49.66f, 33.2995f, 49.3049f, 34.2343f, 0.707107f);
6384 path.close();
6385 path.moveTo(48.0194f, 37.0875f);
6386 path.quadTo(47.7831f, 37.5374f, 47.5295f, 37.9777f);
6387 path.conicTo(47.0304f, 38.8443f, 46.1638f, 38.3451f, 0.707107f);
6388 path.conicTo(45.2973f, 37.846f, 45.7965f, 36.9795f, 0.707107f);
6389 path.quadTo(46.0306f, 36.5729f, 46.2487f, 36.1577f);
6390 path.conicTo(46.7136f, 35.2723f, 47.5989f, 35.7372f, 0.707107f);
6391 path.conicTo(48.4843f, 36.2021f, 48.0194f, 37.0875f, 0.707107f);
6392 path.close();
6393 path.moveTo(46.4721f, 39.6612f);
6394 path.quadTo(46.1926f, 40.0705f, 45.8977f, 40.4688f);
6395 path.conicTo(45.3028f, 41.2726f, 44.499f, 40.6776f, 0.707107f);
6396 path.conicTo(43.6953f, 40.0827f, 44.2902f, 39.2789f, 0.707107f);
6397 path.quadTo(44.5624f, 38.9112f, 44.8204f, 38.5334f);
6398 path.conicTo(45.3843f, 37.7075f, 46.2101f, 38.2714f, 0.707107f);
6399 path.conicTo(47.036f, 38.8353f, 46.4721f, 39.6612f, 0.707107f);
6400 path.close();
6401 path.moveTo(44.6298f, 42.0491f);
6402 path.quadTo(44.2906f, 42.4396f, 43.9361f, 42.8164f);
6403 path.conicTo(43.2509f, 43.5447f, 42.5226f, 42.8595f, 0.707107f);
6404 path.conicTo(41.7942f, 42.1742f, 42.4795f, 41.4459f, 0.707107f);
6405 path.quadTo(42.8067f, 41.0981f, 43.1198f, 40.7376f);
6406 path.conicTo(43.7756f, 39.9826f, 44.5306f, 40.6383f, 0.707107f);
6407 path.conicTo(45.2856f, 41.2941f, 44.6298f, 42.0491f, 0.707107f);
6408 path.close();
6409 path.moveTo(42.4305f, 44.2919f);
6410 path.quadTo(42.0324f, 44.6516f, 41.6198f, 44.9946f);
6411 path.conicTo(40.8507f, 45.6338f, 40.2115f, 44.8648f, 0.707107f);
6412 path.conicTo(39.5723f, 44.0958f, 40.3413f, 43.4566f, 0.707107f);
6413 path.quadTo(40.7222f, 43.1399f, 41.0897f, 42.8079f);
6414 path.conicTo(41.8317f, 42.1375f, 42.5021f, 42.8795f, 0.707107f);
6415 path.conicTo(43.1725f, 43.6215f, 42.4305f, 44.2919f, 0.707107f);
6416 path.close();
6417 path.moveTo(39.8873f, 46.3159f);
6418 path.quadTo(39.4613f, 46.6134f, 39.0238f, 46.8936f);
6419 path.conicTo(38.1818f, 47.433f, 37.6424f, 46.5909f, 0.707107f);
6420 path.conicTo(37.103f, 45.7489f, 37.9451f, 45.2095f, 0.707107f);
6421 path.quadTo(38.3489f, 44.9508f, 38.7421f, 44.6763f);
6422 path.conicTo(39.5619f, 44.1037f, 40.1345f, 44.9235f, 0.707107f);
6423 path.conicTo(40.7071f, 45.7434f, 39.8873f, 46.3159f, 0.707107f);
6424 path.close();
6425 path.moveTo(37.2437f, 47.9367f);
6426 path.quadTo(36.7842f, 48.182f, 36.3153f, 48.4086f);
6427 path.conicTo(35.415f, 48.8439f, 34.9797f, 47.9435f, 0.707107f);
6428 path.conicTo(34.5445f, 47.0432f, 35.4449f, 46.608f, 0.707107f);
6429 path.quadTo(35.8778f, 46.3987f, 36.3019f, 46.1723f);
6430 path.conicTo(37.1841f, 45.7014f, 37.655f, 46.5836f, 0.707107f);
6431 path.conicTo(38.1259f, 47.4658f, 37.2437f, 47.9367f, 0.707107f);
6432 path.close();
6433 path.moveTo(34.3909f, 49.2448f);
6434 path.quadTo(33.8988f, 49.4354f, 33.3992f, 49.606f);
6435 path.conicTo(32.4528f, 49.929f, 32.1298f, 48.9826f, 0.707107f);
6436 path.conicTo(31.8068f, 48.0362f, 32.7532f, 47.7132f, 0.707107f);
6437 path.quadTo(33.2142f, 47.5558f, 33.6685f, 47.3798f);
6438 path.conicTo(34.601f, 47.0186f, 34.9622f, 47.9511f, 0.707107f);
6439 path.conicTo(35.3234f, 48.8836f, 34.3909f, 49.2448f, 0.707107f);
6440 path.close();
6441 path.moveTo(31.3682f, 50.208f);
6442 path.quadTo(30.8535f, 50.3381f, 30.3338f, 50.447f);
6443 path.conicTo(29.3551f, 50.6521f, 29.15f, 49.6734f, 0.707107f);
6444 path.conicTo(28.9448f, 48.6947f, 29.9236f, 48.4895f, 0.707107f);
6445 path.quadTo(30.4033f, 48.389f, 30.8784f, 48.269f);
6446 path.conicTo(31.8479f, 48.024f, 32.0929f, 48.9936f, 0.707107f);
6447 path.conicTo(32.3378f, 49.9631f, 31.3682f, 50.208f, 0.707107f);
6448 path.close();
6449 path.moveTo(28.2669f, 50.7939f);
6450 path.quadTo(27.7491f, 50.8595f, 27.2292f, 50.9043f);
6451 path.conicTo(26.2329f, 50.99f, 26.1472f, 49.9937f, 0.707107f);
6452 path.conicTo(26.0615f, 48.9973f, 27.0578f, 48.9116f, 0.707107f);
6453 path.quadTo(27.5378f, 48.8703f, 28.0156f, 48.8098f);
6454 path.conicTo(29.0077f, 48.6841f, 29.1334f, 49.6762f, 0.707107f);
6455 path.conicTo(29.259f, 50.6683f, 28.2669f, 50.7939f, 0.707107f);
6456 path.close();
6457 path.moveTo(25.1523f, 50.9996f);
6458 path.quadTo(24.6297f, 51.0026f, 24.1072f, 50.9847f);
6459 path.conicTo(23.1078f, 50.9503f, 23.1422f, 49.9509f, 0.707107f);
6460 path.conicTo(23.1765f, 48.9515f, 24.1759f, 48.9858f, 0.707107f);
6461 path.quadTo(24.658f, 49.0024f, 25.1406f, 48.9996f);
6462 path.conicTo(26.1406f, 48.9937f, 26.1464f, 49.9937f, 0.707107f);
6463 path.conicTo(26.1523f, 50.9937f, 25.1523f, 50.9996f, 0.707107f);
6464 path.close();
6465 path.moveTo(22.0162f, 50.8282f);
6466 path.quadTo(21.4999f, 50.7686f, 20.9863f, 50.6883f);
6467 path.conicTo(19.9983f, 50.5339f, 20.1527f, 49.5459f, 0.707107f);
6468 path.conicTo(20.307f, 48.5579f, 21.295f, 48.7123f, 0.707107f);
6469 path.quadTo(21.7691f, 48.7864f, 22.2457f, 48.8414f);
6470 path.conicTo(23.2391f, 48.9562f, 23.1243f, 49.9496f, 0.707107f);
6471 path.conicTo(23.0096f, 50.943f, 22.0162f, 50.8282f, 0.707107f);
6472 path.close();
6473 path.moveTo(18.9351f, 50.2827f);
6474 path.quadTo(18.4037f, 50.1553f, 17.8782f, 50.0056f);
6475 path.conicTo(16.9164f, 49.7317f, 17.1904f, 48.7699f, 0.707107f);
6476 path.conicTo(17.4643f, 47.8082f, 18.426f, 48.0821f, 0.707107f);
6477 path.quadTo(18.9112f, 48.2203f, 19.4016f, 48.3379f);
6478 path.conicTo(20.374f, 48.5712f, 20.1408f, 49.5436f, 0.707107f);
6479 path.conicTo(19.9075f, 50.516f, 18.9351f, 50.2827f, 0.707107f);
6480 path.close();
6481 path.moveTo(15.8352f, 49.3312f);
6482 path.quadTo(15.3403f, 49.1448f, 14.8531f, 48.9383f);
6483 path.conicTo(13.9324f, 48.548f, 14.3227f, 47.6273f, 0.707107f);
6484 path.conicTo(14.713f, 46.7066f, 15.6337f, 47.0969f, 0.707107f);
6485 path.quadTo(16.0832f, 47.2874f, 16.5402f, 47.4596f);
6486 path.conicTo(17.476f, 47.812f, 17.1235f, 48.7479f, 0.707107f);
6487 path.conicTo(16.771f, 49.6837f, 15.8352f, 49.3312f, 0.707107f);
6488 path.close();
6489 path.moveTo(12.9759f, 48.0526f);
6490 path.quadTo(12.5249f, 47.8173f, 12.0835f, 47.5647f);
6491 path.conicTo(11.2156f, 47.0679f, 11.7124f, 46.2f, 0.707107f);
6492 path.conicTo(12.2092f, 45.3321f, 13.0771f, 45.8289f, 0.707107f);
6493 path.quadTo(13.4846f, 46.0622f, 13.9009f, 46.2793f);
6494 path.conicTo(14.7875f, 46.7418f, 14.325f, 47.6284f, 0.707107f);
6495 path.conicTo(13.8626f, 48.5151f, 12.9759f, 48.0526f, 0.707107f);
6496 path.close();
6497 path.moveTo(10.3957f, 46.5108f);
6498 path.quadTo(9.9861f, 46.2327f, 9.58733f, 45.9392f);
6499 path.conicTo(8.78198f, 45.3464f, 9.37478f, 44.541f, 0.707107f);
6500 path.conicTo(9.96757f, 43.7357f, 10.7729f, 44.3285f, 0.707107f);
6501 path.quadTo(11.141f, 44.5994f, 11.5191f, 44.8561f);
6502 path.conicTo(12.3464f, 45.4178f, 11.7847f, 46.2451f, 0.707107f);
6503 path.conicTo(11.223f, 47.0725f, 10.3957f, 46.5108f, 0.707107f);
6504 path.close();
6505 path.moveTo(8.00525f, 44.6769f);
6506 path.quadTo(7.6141f, 44.339f, 7.23672f, 43.9859f);
6507 path.conicTo(6.50649f, 43.3027f, 7.18969f, 42.5725f, 0.707107f);
6508 path.conicTo(7.87289f, 41.8423f, 8.60312f, 42.5255f, 0.707107f);
6509 path.quadTo(8.95149f, 42.8514f, 9.31254f, 43.1632f);
6510 path.conicTo(10.0693f, 43.8169f, 9.4157f, 44.5737f, 0.707107f);
6511 path.conicTo(8.76206f, 45.3305f, 8.00525f, 44.6769f, 0.707107f);
6512 path.close();
6513 path.moveTo(5.75818f, 42.4858f);
6514 path.quadTo(5.39763f, 42.089f, 5.05371f, 41.6777f);
6515 path.conicTo(4.41226f, 40.9105f, 5.17942f, 40.2691f, 0.707107f);
6516 path.conicTo(5.94658f, 39.6276f, 6.58804f, 40.3948f, 0.707107f);
6517 path.quadTo(6.90548f, 40.7744f, 7.23832f, 41.1407f);
6518 path.conicTo(7.91085f, 41.8808f, 7.17078f, 42.5533f, 0.707107f);
6519 path.conicTo(6.43071f, 43.2258f, 5.75818f, 42.4858f, 0.707107f);
6520 path.close();
6521 path.moveTo(3.72821f, 39.9503f);
6522 path.quadTo(3.42794f, 39.523f, 3.1451f, 39.0842f);
6523 path.conicTo(2.6034f, 38.2436f, 3.44397f, 37.7019f, 0.707107f);
6524 path.conicTo(4.28454f, 37.1602f, 4.82624f, 38.0008f, 0.707107f);
6525 path.quadTo(5.08734f, 38.4059f, 5.3645f, 38.8003f);
6526 path.conicTo(5.93951f, 39.6184f, 5.12137f, 40.1934f, 0.707107f);
6527 path.conicTo(4.30322f, 40.7684f, 3.72821f, 39.9503f, 0.707107f);
6528 path.close();
6529 path.moveTo(2.09762f, 37.3078f);
6530 path.quadTo(1.85114f, 36.8491f, 1.62324f, 36.381f);
6531 path.conicTo(1.18551f, 35.4819f, 2.08461f, 35.0442f, 0.707107f);
6532 path.conicTo(2.98372f, 34.6064f, 3.42145f, 35.5055f, 0.707107f);
6533 path.quadTo(3.63184f, 35.9377f, 3.85934f, 36.361f);
6534 path.conicTo(4.33272f, 37.2419f, 3.45185f, 37.7153f, 0.707107f);
6535 path.conicTo(2.57099f, 38.1886f, 2.09762f, 37.3078f, 0.707107f);
6536 path.close();
6537 path.moveTo(0.781912f, 34.4596f);
6538 path.quadTo(0.589924f, 33.9681f, 0.418029f, 33.4692f);
6539 path.conicTo(0.0922952f, 32.5237f, 1.03776f, 32.198f, 0.707107f);
6540 path.conicTo(1.98322f, 31.8722f, 2.30895f, 32.8177f, 0.707107f);
6541 path.quadTo(2.46761f, 33.2782f, 2.64484f, 33.7319f);
6542 path.conicTo(3.00867f, 34.6634f, 2.07721f, 35.0272f, 0.707107f);
6543 path.conicTo(1.14575f, 35.3911f, 0.781912f, 34.4596f, 0.707107f);
6544 path.close();
6545 path.moveTo(-0.189761f, 31.4402f);
6546 path.quadTo(-0.321263f, 30.9258f, -0.431662f, 30.4065f);
6547 path.conicTo(-0.639608f, 29.4284f, 0.338532f, 29.2205f, 0.707107f);
6548 path.conicTo(1.31667f, 29.0125f, 1.52462f, 29.9906f, 0.707107f);
6549 path.quadTo(1.62653f, 30.47f, 1.74791f, 30.9448f);
6550 path.conicTo(1.99561f, 31.9136f, 1.02677f, 32.1613f, 0.707107f);
6551 path.conicTo(0.0579369f, 32.409f, -0.189761f, 31.4402f, 0.707107f);
6552 path.close();
6553 path.moveTo(-0.784658f, 28.3394f);
6554 path.quadTo(-0.851693f, 27.8218f, -0.897902f, 27.3019f);
6555 path.conicTo(-0.986437f, 26.3058f, 0.00963629f, 26.2173f, 0.707107f);
6556 path.conicTo(1.00571f, 26.1288f, 1.09424f, 27.1248f, 0.707107f);
6557 path.quadTo(1.1369f, 27.6047f, 1.19878f, 28.0825f);
6558 path.conicTo(1.32721f, 29.0742f, 0.335496f, 29.2027f, 0.707107f);
6559 path.conicTo(-0.656222f, 29.3311f, -0.784658f, 28.3394f, 0.707107f);
6560 path.close();
6561 path.moveTo(-0.999031f, 25.2248f);
6562 path.quadTo(-1.00354f, 24.7027f, -0.987098f, 24.1809f);
6563 path.conicTo(-0.955596f, 23.1814f, 0.0439078f, 23.2129f, 0.707107f);
6564 path.conicTo(1.04341f, 23.2444f, 1.01191f, 24.2439f, 0.707107f);
6565 path.quadTo(0.996728f, 24.7256f, 1.00089f, 25.2075f);
6566 path.conicTo(1.00954f, 26.2075f, 0.00957754f, 26.2161f, 0.707107f);
6567 path.conicTo(-0.990385f, 26.2248f, -0.999031f, 25.2248f, 0.707107f);
6568 path.close();
6569 path.moveTo(-0.836492f, 22.0887f);
6570 path.quadTo(-0.778263f, 21.5719f, -0.699419f, 21.0579f);
6571 path.conicTo(-0.5478f, 20.0695f, 0.440639f, 20.2211f, 0.707107f);
6572 path.conicTo(1.42908f, 20.3727f, 1.27746f, 21.3612f, 0.707107f);
6573 path.quadTo(1.20468f, 21.8356f, 1.15093f, 22.3126f);
6574 path.conicTo(1.03896f, 23.3063f, 0.0452449f, 23.1944f, 0.707107f);
6575 path.conicTo(-0.948466f, 23.0824f, -0.836492f, 22.0887f, 0.707107f);
6576 path.close();
6577 path.moveTo(-0.300548f, 19.0098f);
6578 path.quadTo(-0.174573f, 18.4777f, -0.0263361f, 17.9514f);
6579 path.conicTo(0.244762f, 16.9889f, 1.20731f, 17.26f, 0.707107f);
6580 path.conicTo(2.16987f, 17.5311f, 1.89877f, 18.4936f, 0.707107f);
6581 path.quadTo(1.76193f, 18.9794f, 1.64565f, 19.4706f);
6582 path.conicTo(1.41526f, 20.4437f, 0.442159f, 20.2133f, 0.707107f);
6583 path.conicTo(-0.530939f, 19.9829f, -0.300548f, 19.0098f, 0.707107f);
6584 path.close();
6585 path.moveTo(0.642658f, 15.9049f);
6586 path.quadTo(0.827861f, 15.409f, 1.0331f, 14.9209f);
6587 path.conicTo(1.42076f, 13.9991f, 2.34256f, 14.3868f, 0.707107f);
6588 path.conicTo(3.26437f, 14.7744f, 2.87671f, 15.6962f, 0.707107f);
6589 path.quadTo(2.68726f, 16.1467f, 2.5163f, 16.6046f);
6590 path.conicTo(2.16648f, 17.5414f, 1.22967f, 17.1916f, 0.707107f);
6591 path.conicTo(0.292846f, 16.8418f, 0.642658f, 15.9049f, 0.707107f);
6592 path.close();
6593 path.moveTo(1.91434f, 13.0395f);
6594 path.quadTo(2.14856f, 12.5875f, 2.40031f, 12.1449f);
6595 path.conicTo(2.89473f, 11.2757f, 3.76395f, 11.7701f, 0.707107f);
6596 path.conicTo(4.63317f, 12.2645f, 4.13875f, 13.1337f, 0.707107f);
6597 path.quadTo(3.90637f, 13.5423f, 3.69016f, 13.9596f);
6598 path.conicTo(3.23014f, 14.8475f, 2.34223f, 14.3875f, 0.707107f);
6599 path.conicTo(1.45432f, 13.9275f, 1.91434f, 13.0395f, 0.707107f);
6600 path.close();
6601 path.moveTo(3.45073f, 10.4525f);
6602 path.quadTo(3.72744f, 10.0426f, 4.01954f, 9.64356f);
6603 path.conicTo(4.61017f, 8.83661f, 5.41711f, 9.42725f, 0.707107f);
6604 path.conicTo(6.22405f, 10.0179f, 5.63342f, 10.8248f, 0.707107f);
6605 path.quadTo(5.36379f, 11.1932f, 5.10836f, 11.5716f);
6606 path.conicTo(4.54884f, 12.4004f, 3.72003f, 11.8409f, 0.707107f);
6607 path.conicTo(2.89121f, 11.2813f, 3.45073f, 10.4525f, 0.707107f);
6608 path.close();
6609 path.moveTo(5.2763f, 8.05964f);
6610 path.quadTo(5.61273f, 7.66793f, 5.96445f, 7.2899f);
6611 path.conicTo(6.6456f, 6.55776f, 7.37774f, 7.23892f, 0.707107f);
6612 path.conicTo(8.10988f, 7.92008f, 7.42872f, 8.65221f, 0.707107f);
6613 path.quadTo(7.10407f, 9.00116f, 6.79351f, 9.36274f);
6614 path.conicTo(6.14196f, 10.1213f, 5.38336f, 9.46979f, 0.707107f);
6615 path.conicTo(4.62475f, 8.81824f, 5.2763f, 8.05964f, 0.707107f);
6616 path.close();
6617 path.moveTo(7.45913f, 5.80839f);
6618 path.quadTo(7.85457f, 5.44696f, 8.26455f, 5.10214f);
6619 path.conicTo(9.02985f, 4.45847f, 9.67352f, 5.22377f, 0.707107f);
6620 path.conicTo(10.3172f, 5.98907f, 9.5519f, 6.63274f, 0.707107f);
6621 path.quadTo(9.17345f, 6.95105f, 8.80843f, 7.28467f);
6622 path.conicTo(8.07029f, 7.95931f, 7.39564f, 7.22117f, 0.707107f);
6623 path.conicTo(6.72099f, 6.48303f, 7.45913f, 5.80839f, 0.707107f);
6624 path.close();
6625 path.moveTo(9.98688f, 3.77251f);
6626 path.quadTo(10.4153f, 3.46948f, 10.8557f, 3.18397f);
6627 path.conicTo(11.6948f, 2.63996f, 12.2388f, 3.47904f, 0.707107f);
6628 path.conicTo(12.7828f, 4.31812f, 11.9437f, 4.86213f, 0.707107f);
6629 path.quadTo(11.5373f, 5.12566f, 11.1417f, 5.40539f);
6630 path.conicTo(10.3253f, 5.98282f, 9.74787f, 5.16638f, 0.707107f);
6631 path.conicTo(9.17044f, 4.34994f, 9.98688f, 3.77251f, 0.707107f);
6632 path.close();
6633 path.moveTo(12.6283f, 2.13208f);
6634 path.quadTo(13.0861f, 1.88442f, 13.5534f, 1.65529f);
6635 path.conicTo(14.4513f, 1.21504f, 14.8915f, 2.11291f, 0.707107f);
6636 path.conicTo(15.3318f, 3.01078f, 14.4339f, 3.45104f, 0.707107f);
6637 path.quadTo(14.0025f, 3.66255f, 13.58f, 3.89115f);
6638 path.conicTo(12.7005f, 4.36698f, 12.2246f, 3.48744f, 0.707107f);
6639 path.conicTo(11.7488f, 2.60791f, 12.6283f, 2.13208f, 0.707107f);
6640 path.close();
6641 path.moveTo(15.4718f, 0.808815f);
6642 path.quadTo(15.9627f, 0.615476f, 16.461f, 0.442208f);
6643 path.conicTo(17.4055f, 0.113784f, 17.7339f, 1.05831f, 0.707107f);
6644 path.conicTo(18.0624f, 2.00284f, 17.1178f, 2.33127f, 0.707107f);
6645 path.quadTo(16.6578f, 2.49121f, 16.2047f, 2.66968f);
6646 path.conicTo(15.2743f, 3.03614f, 14.9078f, 2.10571f, 0.707107f);
6647 path.conicTo(14.5414f, 1.17528f, 15.4718f, 0.808815f, 0.707107f);
6648 path.close();
6649 path.moveTo(18.4879f, -0.171272f);
6650 path.quadTo(19.0019f, -0.304236f, 19.5208f, -0.416111f);
6651 path.conicTo(20.4984f, -0.62685f, 20.7091f, 0.350692f, 0.707107f);
6652 path.conicTo(20.9198f, 1.32823f, 19.9423f, 1.53897f, 0.707107f);
6653 path.quadTo(19.4633f, 1.64224f, 18.9889f, 1.76498f);
6654 path.conicTo(18.0207f, 2.01544f, 17.7703f, 1.04732f, 0.707107f);
6655 path.conicTo(17.5198f, 0.0791926f, 18.4879f, -0.171272f, 0.707107f);
6656 path.close();
6657 path.moveTo(21.5882f, -0.77517f);
6658 path.quadTo(22.1056f, -0.843665f, 22.6254f, -0.891339f);
6659 path.conicTo(23.6212f, -0.982672f, 23.7126f, 0.0131486f, 0.707107f);
6660 path.conicTo(23.8039f, 1.00897f, 22.8081f, 1.1003f, 0.707107f);
6661 path.quadTo(22.3283f, 1.14431f, 21.8506f, 1.20754f);
6662 path.conicTo(20.8592f, 1.33876f, 20.728f, 0.347405f, 0.707107f);
6663 path.conicTo(20.5968f, -0.643948f, 21.5882f, -0.77517f, 0.707107f);
6664 path.close();
6665 path.moveTo(24.7026f, -0.998301f);
6666 path.quadTo(25.2241f, -1.00426f, 25.7453f, -0.989316f);
6667 path.conicTo(26.7449f, -0.960651f, 26.7162f, 0.0389383f, 0.707107f);
6668 path.conicTo(26.6876f, 1.03853f, 25.688f, 1.00986f, 0.707107f);
6669 path.quadTo(25.2068f, 0.996064f, 24.7255f, 1.00157f);
6670 path.conicTo(23.7256f, 1.013f, 23.7141f, 0.0130688f, 0.707107f);
6671 path.conicTo(23.7027f, -0.986866f, 24.7026f, -0.998301f, 0.707107f);
6672 path.close();
6673 path.moveTo(27.8388f, -0.844563f);
6674 path.quadTo(28.3559f, -0.787759f, 28.8704f, -0.710314f);
6675 path.conicTo(29.8592f, -0.561454f, 29.7104f, 0.427404f, 0.707107f);
6676 path.conicTo(29.5615f, 1.41626f, 28.5726f, 1.2674f, 0.707107f);
6677 path.quadTo(28.0978f, 1.19591f, 27.6204f, 1.14348f);
6678 path.conicTo(26.6264f, 1.0343f, 26.7356f, 0.0402742f, 0.707107f);
6679 path.conicTo(26.8447f, -0.953747f, 27.8388f, -0.844563f, 0.707107f);
6680 path.close();
6681 path.moveTo(30.9153f, -0.318153f);
6682 path.quadTo(31.4481f, -0.193671f, 31.9752f, -0.046875f);
6683 path.conicTo(32.9386f, 0.221405f, 32.6703f, 1.18475f, 0.707107f);
6684 path.conicTo(32.402f, 2.14809f, 31.4387f, 1.87981f, 0.707107f);
6685 path.quadTo(30.9521f, 1.74431f, 30.4603f, 1.6294f);
6686 path.conicTo(29.4865f, 1.40189f, 29.714f, 0.428111f, 0.707107f);
6687 path.conicTo(29.9416f, -0.545664f, 30.9153f, -0.318153f, 0.707107f);
6688 path.close();
6689 path.moveTo(34.0252f, 0.616677f);
6690 path.quadTo(34.5221f, 0.800609f, 35.0111f, 1.00465f);
6691 path.conicTo(35.934f, 1.3897f, 35.549f, 2.31259f, 0.707107f);
6692 path.conicTo(35.1639f, 3.23549f, 34.241f, 2.85044f, 0.707107f);
6693 path.quadTo(33.7896f, 2.66211f, 33.3309f, 2.49232f);
6694 path.conicTo(32.3931f, 2.1452f, 32.7402f, 1.20738f, 0.707107f);
6695 path.conicTo(33.0873f, 0.269559f, 34.0252f, 0.616677f, 0.707107f);
6696 path.close();
6697 path.moveTo(36.8967f, 1.88141f);
6698 path.quadTo(37.3499f, 2.11462f, 37.7936f, 2.3654f);
6699 path.conicTo(38.6641f, 2.85746f, 38.1721f, 3.72802f, 0.707107f);
6700 path.conicTo(37.68f, 4.59858f, 36.8094f, 4.10652f, 0.707107f);
6701 path.quadTo(36.3999f, 3.87504f, 35.9815f, 3.65976f);
6702 path.conicTo(35.0924f, 3.2022f, 35.5499f, 2.31302f, 0.707107f);
6703 path.conicTo(36.0075f, 1.42384f, 36.8967f, 1.88141f, 0.707107f);
6704 path.close();
6705 path.moveTo(39.4914f, 3.413f);
6706 path.lineTo(39.5381f, 3.44439f);
6707 path.quadTo(39.9244f, 3.70494f, 40.3002f, 3.97845f);
6708 path.conicTo(41.1087f, 4.56692f, 40.5202f, 5.37544f, 0.707107f);
6709 path.conicTo(39.9317f, 6.18396f, 39.1232f, 5.59549f, 0.707107f);
6710 path.quadTo(38.7763f, 5.34298f, 38.4215f, 5.10371f);
6711 path.lineTo(38.3749f, 5.07232f);
6712 path.conicTo(37.5452f, 4.51406f, 38.1035f, 3.68439f, 0.707107f);
6713 path.conicTo(38.6618f, 2.85473f, 39.4914f, 3.413f, 0.707107f);
6714 path.close();
6715 path.moveTo(41.8859f, 5.22965f);
6716 path.quadTo(42.2782f, 5.56471f, 42.6568f, 5.91499f);
6717 path.conicTo(43.3908f, 6.5941f, 42.7117f, 7.32814f, 0.707107f);
6718 path.conicTo(42.0326f, 8.06218f, 41.2986f, 7.38308f, 0.707107f);
6719 path.quadTo(40.949f, 7.05968f, 40.587f, 6.75043f);
6720 path.conicTo(39.8266f, 6.10097f, 40.476f, 5.34058f, 0.707107f);
6721 path.conicTo(41.1255f, 4.58018f, 41.8859f, 5.22965f, 0.707107f);
6722 path.close();
6723 path.moveTo(44.1413f, 7.40421f);
6724 path.quadTo(44.5035f, 7.79829f, 44.8493f, 8.20695f);
6725 path.conicTo(45.4952f, 8.97038f, 44.7317f, 9.61627f, 0.707107f);
6726 path.conicTo(43.9683f, 10.2622f, 43.3224f, 9.49874f, 0.707107f);
6727 path.quadTo(43.0033f, 9.1215f, 42.6689f, 8.75773f);
6728 path.conicTo(41.9921f, 8.02152f, 42.7283f, 7.34476f, 0.707107f);
6729 path.conicTo(43.4645f, 6.668f, 44.1413f, 7.40421f, 0.707107f);
6730 path.close();
6731 path.moveTo(46.183f, 9.9242f);
6732 path.quadTo(46.4888f, 10.3539f, 46.777f, 10.7957f);
6733 path.conicTo(47.3233f, 11.6332f, 46.4857f, 12.1796f, 0.707107f);
6734 path.conicTo(45.6482f, 12.7259f, 45.1018f, 11.8883f, 0.707107f);
6735 path.quadTo(44.8358f, 11.4805f, 44.5535f, 11.0839f);
6736 path.conicTo(43.9737f, 10.2691f, 44.7884f, 9.6893f, 0.707107f);
6737 path.conicTo(45.6032f, 9.10947f, 46.183f, 9.9242f, 0.707107f);
6738 path.close();
6739 path.moveTo(47.8333f, 12.5645f);
6740 path.quadTo(48.0821f, 13.0214f, 48.3125f, 13.4879f);
6741 path.conicTo(48.7552f, 14.3845f, 47.8586f, 14.8273f, 0.707107f);
6742 path.conicTo(46.962f, 15.2701f, 46.5192f, 14.3734f, 0.707107f);
6743 path.quadTo(46.3065f, 13.9428f, 46.0769f, 13.5211f);
6744 path.conicTo(45.5986f, 12.6429f, 46.4768f, 12.1646f, 0.707107f);
6745 path.conicTo(47.355f, 11.6863f, 47.8333f, 12.5645f, 0.707107f);
6746 path.close();
6747 path.moveTo(49.1641f, 15.4033f);
6748 path.quadTo(49.3588f, 15.8935f, 49.5334f, 16.3912f);
6749 path.conicTo(49.8645f, 17.3348f, 48.9209f, 17.6659f, 0.707107f);
6750 path.conicTo(47.9773f, 17.997f, 47.6462f, 17.0534f, 0.707107f);
6751 path.quadTo(47.485f, 16.5939f, 47.3053f, 16.1415f);
6752 path.conicTo(46.9362f, 15.2121f, 47.8656f, 14.843f, 0.707107f);
6753 path.conicTo(48.795f, 14.4739f, 49.1641f, 15.4033f, 0.707107f);
6754 path.close();
6755 path.moveTo(50.1526f, 18.4161f);
6756 path.quadTo(50.287f, 18.9296f, 50.4003f, 19.4482f);
6757 path.conicTo(50.6139f, 20.4252f, 49.6369f, 20.6387f, 0.707107f);
6758 path.conicTo(48.66f, 20.8522f, 48.4465f, 19.8753f, 0.707107f);
6759 path.quadTo(48.3419f, 19.3966f, 48.2178f, 18.9225f);
6760 path.conicTo(47.9645f, 17.9551f, 48.9319f, 17.7019f, 0.707107f);
6761 path.conicTo(49.8993f, 17.4487f, 50.1526f, 18.4161f, 0.707107f);
6762 path.close();
6763 path.moveTo(50.7655f, 21.5157f);
6764 path.quadTo(50.8354f, 22.033f, 50.8846f, 22.5528f);
6765 path.conicTo(50.9787f, 23.5483f, 49.9831f, 23.6425f, 0.707107f);
6766 path.conicTo(48.9876f, 23.7366f, 48.8935f, 22.741f, 0.707107f);
6767 path.quadTo(48.8481f, 22.2613f, 48.7835f, 21.7837f);
6768 path.conicTo(48.6495f, 20.7928f, 49.6405f, 20.6587f, 0.707107f);
6769 path.conicTo(50.6315f, 20.5247f, 50.7655f, 21.5157f, 0.707107f);
6770 path.close();
6771 path.moveTo(50.9974f, 24.6301f);
6772 path.quadTo(51.0048f, 25.1509f, 50.9913f, 25.6715f);
6773 path.conicTo(50.9655f, 26.6712f, 49.9658f, 26.6454f, 0.707107f);
6774 path.conicTo(48.9662f, 26.6196f, 48.992f, 25.6199f, 0.707107f);
6775 path.quadTo(49.0044f, 25.1393f, 48.9976f, 24.6585f);
6776 path.conicTo(48.9834f, 23.6586f, 49.9833f, 23.6444f, 0.707107f);
6777 path.conicTo(50.9832f, 23.6302f, 50.9974f, 24.6301f, 0.707107f);
6778 path.close();
6779 path.moveTo(50.8524f, 27.7662f);
6780 path.quadTo(50.7971f, 28.2837f, 50.721f, 28.7986f);
6781 path.conicTo(50.5749f, 29.7879f, 49.5856f, 29.6418f, 0.707107f);
6782 path.conicTo(48.5963f, 29.4957f, 48.7425f, 28.5064f, 0.707107f);
6783 path.quadTo(48.8127f, 28.0311f, 48.8638f, 27.5534f);
6784 path.conicTo(48.9702f, 26.5591f, 49.9645f, 26.6655f, 0.707107f);
6785 path.conicTo(50.9588f, 26.7718f, 50.8524f, 27.7662f, 0.707107f);
6786 path.close();
6787 path.moveTo(50.3355f, 30.8404f);
6788 path.quadTo(50.2125f, 31.3739f, 50.0672f, 31.9018f);
6789 path.conicTo(49.8018f, 32.8659f, 48.8376f, 32.6005f, 0.707107f);
6790 path.conicTo(47.8735f, 32.335f, 48.139f, 31.3709f, 0.707107f);
6791 path.quadTo(48.2731f, 30.8836f, 48.3867f, 30.3912f);
6792 path.conicTo(48.6113f, 29.4167f, 49.5857f, 29.6413f, 0.707107f);
6793 path.conicTo(50.5602f, 29.866f, 50.3355f, 30.8404f, 0.707107f);
6794 path.close();
6795 path.moveTo(49.4091f, 33.9552f);
6796 path.quadTo(49.2264f, 34.4531f, 49.0236f, 34.9431f);
6797 path.conicTo(48.6412f, 35.8671f, 47.7172f, 35.4846f, 0.707107f);
6798 path.conicTo(46.7932f, 35.1022f, 47.1757f, 34.1782f, 0.707107f);
6799 path.quadTo(47.3629f, 33.7259f, 47.5315f, 33.2663f);
6800 path.conicTo(47.8759f, 32.3275f, 48.8147f, 32.672f, 0.707107f);
6801 path.conicTo(49.7535f, 33.0164f, 49.4091f, 33.9552f, 0.707107f);
6802 path.close();
6803 path.moveTo(48.1514f, 36.8328f);
6804 path.quadTo(47.9191f, 37.2871f, 47.6694f, 37.7318f);
6805 path.conicTo(47.1797f, 38.6038f, 46.3078f, 38.1141f, 0.707107f);
6806 path.conicTo(45.4359f, 37.6244f, 45.9256f, 36.7525f, 0.707107f);
6807 path.quadTo(46.1562f, 36.3418f, 46.3705f, 35.9226f);
6808 path.conicTo(46.8256f, 35.0321f, 47.716f, 35.4872f, 0.707107f);
6809 path.conicTo(48.6065f, 35.9423f, 48.1514f, 36.8328f, 0.707107f);
6810 path.close();
6811 path.moveTo(46.6245f, 39.4354f);
6812 path.lineTo(46.5563f, 39.537f);
6813 path.quadTo(46.3146f, 39.8955f, 46.0624f, 40.2438f);
6814 path.conicTo(45.4761f, 41.0539f, 44.666f, 40.4676f, 0.707107f);
6815 path.conicTo(43.8559f, 39.8813f, 44.4422f, 39.0712f, 0.707107f);
6816 path.quadTo(44.6749f, 38.7498f, 44.8955f, 38.4226f);
6817 path.lineTo(44.9637f, 38.3211f);
6818 path.conicTo(45.5209f, 37.4907f, 46.3513f, 38.0479f, 0.707107f);
6819 path.conicTo(47.1817f, 38.605f, 46.6245f, 39.4354f, 0.707107f);
6820 path.close();
6821 path.moveTo(44.8168f, 41.8314f);
6822 path.quadTo(44.4832f, 42.2241f, 44.1342f, 42.6034f);
6823 path.conicTo(43.4572f, 43.3394f, 42.7212f, 42.6623f, 0.707107f);
6824 path.conicTo(41.9853f, 41.9853f, 42.6623f, 41.2494f, 0.707107f);
6825 path.quadTo(42.9845f, 40.8992f, 43.2924f, 40.5366f);
6826 path.conicTo(43.9398f, 39.7745f, 44.702f, 40.4218f, 0.707107f);
6827 path.conicTo(45.4642f, 41.0692f, 44.8168f, 41.8314f, 0.707107f);
6828 path.close();
6829 path.moveTo(42.6505f, 44.0908f);
6830 path.quadTo(42.2577f, 44.454f, 41.8504f, 44.8006f);
6831 path.conicTo(41.0888f, 45.4487f, 40.4408f, 44.6871f, 0.707107f);
6832 path.conicTo(39.7927f, 43.9256f, 40.5542f, 43.2775f, 0.707107f);
6833 path.quadTo(40.9302f, 42.9575f, 41.2928f, 42.6223f);
6834 path.conicTo(42.027f, 41.9434f, 42.7059f, 42.6777f, 0.707107f);
6835 path.conicTo(43.3848f, 43.412f, 42.6505f, 44.0908f, 0.707107f);
6836 path.close();
6837 path.moveTo(40.1383f, 46.1384f);
6838 path.quadTo(39.7073f, 46.4471f, 39.2641f, 46.7378f);
6839 path.conicTo(38.4281f, 47.2865f, 37.8795f, 46.4504f, 0.707107f);
6840 path.conicTo(37.3308f, 45.6143f, 38.1669f, 45.0657f, 0.707107f);
6841 path.quadTo(38.576f, 44.7972f, 38.9738f, 44.5124f);
6842 path.conicTo(39.7868f, 43.9301f, 40.369f, 44.7432f, 0.707107f);
6843 path.conicTo(40.9513f, 45.5562f, 40.1383f, 46.1384f, 0.707107f);
6844 path.close();
6845 path.moveTo(37.4991f, 47.7985f);
6846 path.quadTo(37.0431f, 48.0485f, 36.5775f, 48.2801f);
6847 path.conicTo(35.6821f, 48.7254f, 35.2368f, 47.83f, 0.707107f);
6848 path.conicTo(34.7915f, 46.9346f, 35.6869f, 46.4893f, 0.707107f);
6849 path.quadTo(36.1167f, 46.2755f, 36.5376f, 46.0448f);
6850 path.conicTo(37.4145f, 45.5641f, 37.8952f, 46.4409f, 0.707107f);
6851 path.conicTo(38.376f, 47.3178f, 37.4991f, 47.7985f, 0.707107f);
6852 path.close();
6853 path.moveTo(34.6651f, 49.1368f);
6854 path.quadTo(34.1756f, 49.3328f, 33.6785f, 49.5089f);
6855 path.conicTo(32.7358f, 49.8427f, 32.402f, 48.9f, 0.707107f);
6856 path.conicTo(32.0682f, 47.9574f, 33.0109f, 47.6236f, 0.707107f);
6857 path.quadTo(33.4697f, 47.4611f, 33.9216f, 47.2801f);
6858 path.conicTo(34.85f, 46.9084f, 35.2217f, 47.8368f, 0.707107f);
6859 path.conicTo(35.5934f, 48.7651f, 34.6651f, 49.1368f, 0.707107f);
6860 path.close();
6861 path.moveTo(31.6557f, 50.1337f);
6862 path.quadTo(31.1425f, 50.2696f, 30.6243f, 50.3844f);
6863 path.conicTo(29.648f, 50.6007f, 29.4317f, 49.6244f, 0.707107f);
6864 path.conicTo(29.2153f, 48.6481f, 30.1917f, 48.4317f, 0.707107f);
6865 path.quadTo(30.6701f, 48.3257f, 31.1437f, 48.2003f);
6866 path.conicTo(32.1104f, 47.9443f, 32.3664f, 48.911f, 0.707107f);
6867 path.conicTo(32.6223f, 49.8777f, 31.6557f, 50.1337f, 0.707107f);
6868 path.close();
6869 path.moveTo(28.5567f, 50.7556f);
6870 path.quadTo(28.0395f, 50.827f, 27.5198f, 50.8776f);
6871 path.conicTo(26.5245f, 50.9745f, 26.4276f, 49.9792f, 0.707107f);
6872 path.conicTo(26.3307f, 48.9839f, 27.326f, 48.887f, 0.707107f);
6873 path.quadTo(27.8056f, 48.8403f, 28.2831f, 48.7744f);
6874 path.conicTo(29.2737f, 48.6376f, 29.4105f, 49.6282f, 0.707107f);
6875 path.conicTo(29.5473f, 50.6188f, 28.5567f, 50.7556f, 0.707107f);
6876 path.close();
6877 path.moveTo(25.4424f, 50.9962f);
6878 path.quadTo(24.9222f, 51.0051f, 24.4022f, 50.9931f);
6879 path.conicTo(23.4025f, 50.9701f, 23.4255f, 49.9704f, 0.707107f);
6880 path.conicTo(23.4485f, 48.9707f, 24.4482f, 48.9937f, 0.707107f);
6881 path.quadTo(24.9283f, 49.0047f, 25.4084f, 48.9965f);
6882 path.conicTo(26.4083f, 48.9795f, 26.4253f, 49.9794f, 0.707107f);
6883 path.conicTo(26.4423f, 50.9792f, 25.4424f, 50.9962f, 0.707107f);
6884 path.close();
6885 path.moveTo(22.3065f, 50.8601f);
6886 path.quadTo(21.7885f, 50.8062f, 21.2732f, 50.7315f);
6887 path.conicTo(20.2835f, 50.5882f, 20.4268f, 49.5985f, 0.707107f);
6888 path.conicTo(20.5702f, 48.6088f, 21.5599f, 48.7522f, 0.707107f);
6889 path.quadTo(22.0355f, 48.8211f, 22.5136f, 48.8709f);
6890 path.conicTo(23.5083f, 48.9745f, 23.4047f, 49.9691f, 0.707107f);
6891 path.conicTo(23.3011f, 50.9637f, 22.3065f, 50.8601f, 0.707107f);
6892 path.close();
6893 path.moveTo(19.2346f, 50.3527f);
6894 path.quadTo(18.7003f, 50.2312f, 18.1717f, 50.0873f);
6895 path.conicTo(17.2068f, 49.8247f, 17.4694f, 48.8598f, 0.707107f);
6896 path.conicTo(17.732f, 47.8949f, 18.6969f, 48.1575f, 0.707107f);
6897 path.quadTo(19.185f, 48.2904f, 19.6781f, 48.4025f);
6898 path.conicTo(20.6532f, 48.6243f, 20.4314f, 49.5994f, 0.707107f);
6899 path.conicTo(20.2097f, 50.5745f, 19.2346f, 50.3527f, 0.707107f);
6900 path.close();
6901 path.moveTo(16.1149f, 49.4347f);
6902 path.quadTo(15.6161f, 49.2533f, 15.1251f, 49.0517f);
6903 path.conicTo(14.2f, 48.6719f, 14.5798f, 47.7469f, 0.707107f);
6904 path.conicTo(14.9596f, 46.8218f, 15.8847f, 47.2016f, 0.707107f);
6905 path.quadTo(16.3379f, 47.3877f, 16.7984f, 47.5551f);
6906 path.conicTo(17.7382f, 47.8969f, 17.3964f, 48.8366f, 0.707107f);
6907 path.conicTo(17.0547f, 49.7764f, 16.1149f, 49.4347f, 0.707107f);
6908 path.close();
6909 path.moveTo(13.2313f, 48.184f);
6910 path.quadTo(12.776f, 47.9529f, 12.33f, 47.704f);
6911 path.conicTo(11.4568f, 47.2167f, 11.9441f, 46.3434f, 0.707107f);
6912 path.conicTo(12.4314f, 45.4702f, 13.3046f, 45.9575f, 0.707107f);
6913 path.quadTo(13.7162f, 46.1872f, 14.1365f, 46.4006f);
6914 path.conicTo(15.0282f, 46.8532f, 14.5756f, 47.7449f, 0.707107f);
6915 path.conicTo(14.123f, 48.6366f, 13.2313f, 48.184f, 0.707107f);
6916 path.close();
6917 path.moveTo(10.6208f, 46.6619f);
6918 path.lineTo(10.4641f, 46.5571f);
6919 path.quadTo(10.1333f, 46.334f, 9.81253f, 46.1031f);
6920 path.conicTo(9.00087f, 45.519f, 9.585f, 44.7073f, 0.707107f);
6921 path.conicTo(10.1691f, 43.8957f, 10.9808f, 44.4798f, 0.707107f);
6922 path.quadTo(11.2769f, 44.6929f, 11.5763f, 44.8948f);
6923 path.lineTo(11.7329f, 44.9996f);
6924 path.conicTo(12.564f, 45.5557f, 12.008f, 46.3868f, 0.707107f);
6925 path.conicTo(11.4519f, 47.2179f, 10.6208f, 46.6619f, 0.707107f);
6926 path.close();
6927 path.moveTo(8.22326f, 44.8631f);
6928 path.quadTo(7.82986f, 44.5308f, 7.44999f, 44.1833f);
6929 path.conicTo(6.71217f, 43.5082f, 7.38718f, 42.7704f, 0.707107f);
6930 path.conicTo(8.06219f, 42.0326f, 8.8f, 42.7076f, 0.707107f);
6931 path.quadTo(9.15066f, 43.0284f, 9.51375f, 43.3351f);
6932 path.conicTo(10.2777f, 43.9804f, 9.63248f, 44.7443f, 0.707107f);
6933 path.conicTo(8.98724f, 45.5083f, 8.22326f, 44.8631f, 0.707107f);
6934 path.close();
6935 path.moveTo(5.95972f, 42.705f);
6936 path.quadTo(5.59577f, 42.3136f, 5.24823f, 41.9076f);
6937 path.conicTo(4.59793f, 41.148f, 5.3576f, 40.4977f, 0.707107f);
6938 path.conicTo(6.11728f, 39.8473f, 6.76758f, 40.607f, 0.707107f);
6939 path.quadTo(7.08843f, 40.9818f, 7.42436f, 41.3431f);
6940 path.conicTo(8.10532f, 42.0754f, 7.373f, 42.7564f, 0.707107f);
6941 path.conicTo(6.64068f, 43.4373f, 5.95972f, 42.705f, 0.707107f);
6942 path.close();
6943 path.moveTo(3.90635f, 40.2006f);
6944 path.quadTo(3.59492f, 39.7684f, 3.30147f, 39.3239f);
6945 path.conicTo(2.75055f, 38.4893f, 3.58511f, 37.9384f, 0.707107f);
6946 path.conicTo(4.41967f, 37.3875f, 4.97059f, 38.222f, 0.707107f);
6947 path.quadTo(5.24148f, 38.6324f, 5.52894f, 39.0313f);
6948 path.conicTo(6.11358f, 39.8426f, 5.30228f, 40.4272f, 0.707107f);
6949 path.conicTo(4.49099f, 41.0119f, 3.90635f, 40.2006f, 0.707107f);
6950 path.close();
6951 path.moveTo(2.23643f, 37.5626f);
6952 path.quadTo(1.98525f, 37.1075f, 1.75248f, 36.6427f);
6953 path.conicTo(1.30469f, 35.7486f, 2.19883f, 35.3008f, 0.707107f);
6954 path.conicTo(3.09296f, 34.853f, 3.54076f, 35.7471f, 0.707107f);
6955 path.quadTo(3.75563f, 36.1762f, 3.98747f, 36.5963f);
6956 path.conicTo(4.47065f, 37.4718f, 3.59513f, 37.955f, 0.707107f);
6957 path.conicTo(2.71961f, 38.4382f, 2.23643f, 37.5626f, 0.707107f);
6958 path.close();
6959 path.moveTo(0.890647f, 34.7334f);
6960 path.quadTo(0.69328f, 34.2445f, 0.515902f, 33.7481f);
6961 path.conicTo(0.179435f, 32.8064f, 1.12113f, 32.4699f, 0.707107f);
6962 path.conicTo(2.06282f, 32.1335f, 2.39929f, 33.0752f, 0.707107f);
6963 path.quadTo(2.56303f, 33.5334f, 2.74521f, 33.9847f);
6964 path.conicTo(3.11957f, 34.912f, 2.19229f, 35.2863f, 0.707107f);
6965 path.conicTo(1.26501f, 35.6607f, 0.890647f, 34.7334f, 0.707107f);
6966 path.close();
6967 path.moveTo(-0.114587f, 31.7274f);
6968 path.quadTo(-0.251922f, 31.2147f, -0.368218f, 30.6968f);
6969 path.conicTo(-0.587327f, 29.7211f, 0.388373f, 29.502f, 0.707107f);
6970 path.conicTo(1.36407f, 29.2829f, 1.58318f, 30.2586f, 0.707107f);
6971 path.quadTo(1.69053f, 30.7366f, 1.8173f, 31.2099f);
6972 path.conicTo(2.07605f, 32.1758f, 1.1101f, 32.4346f, 0.707107f);
6973 path.conicTo(0.144159f, 32.6933f, -0.114587f, 31.7274f, 0.707107f);
6974 path.close();
6975 path.moveTo(-0.745485f, 28.6291f);
6976 path.quadTo(-0.818367f, 28.112f, -0.870432f, 27.5925f);
6977 path.conicTo(-0.970142f, 26.5974f, 0.0248742f, 26.4977f, 0.707107f);
6978 path.conicTo(1.01989f, 26.398f, 1.1196f, 27.393f, 0.707107f);
6979 path.quadTo(1.16766f, 27.8726f, 1.23494f, 28.3499f);
6980 path.conicTo(1.37452f, 29.3401f, 0.384305f, 29.4797f, 0.707107f);
6981 path.conicTo(-0.605905f, 29.6193f, -0.745485f, 28.6291f, 0.707107f);
6982 path.close();
6983 path.moveTo(-0.994901f, 25.515f);
6984 path.quadTo(-1.00519f, 24.9955f, -0.994722f, 24.4761f);
6985 path.conicTo(-0.97457f, 23.4763f, 0.0252273f, 23.4964f, 0.707107f);
6986 path.conicTo(1.02502f, 23.5166f, 1.00487f, 24.5164f, 0.707107f);
6987 path.quadTo(0.995207f, 24.9959f, 1.00471f, 25.4754f);
6988 path.conicTo(1.02451f, 26.4752f, 0.0247103f, 26.495f, 0.707107f);
6989 path.conicTo(-0.975093f, 26.5148f, -0.994901f, 25.515f, 0.707107f);
6990 path.close();
6991 path.moveTo(-0.867571f, 22.3792f);
6992 path.quadTo(-0.81506f, 21.8609f, -0.741825f, 21.3451f);
6993 path.conicTo(-0.60125f, 20.355f, 0.38882f, 20.4956f, 0.707107f);
6994 path.conicTo(1.37889f, 20.6361f, 1.23831f, 21.6262f, 0.707107f);
6995 path.quadTo(1.17071f, 22.1023f, 1.12224f, 22.5807f);
6996 path.conicTo(1.02144f, 23.5757f, 0.026537f, 23.4749f, 0.707107f);
6997 path.conicTo(-0.96837f, 23.3741f, -0.867571f, 22.3792f, 0.707107f);
6998 path.close();
6999 path.moveTo(-0.369678f, 19.3097f);
7000 path.quadTo(-0.249693f, 18.7748f, -0.107265f, 18.2453f);
7001 path.conicTo(0.152529f, 17.2797f, 1.11819f, 17.5395f, 0.707107f);
7002 path.conicTo(2.08386f, 17.7993f, 1.82406f, 18.7649f, 0.707107f);
7003 path.quadTo(1.69259f, 19.2536f, 1.58184f, 19.7474f);
7004 path.conicTo(1.36298f, 20.7232f, 0.387221f, 20.5043f, 0.707107f);
7005 path.conicTo(-0.588536f, 20.2855f, -0.369678f, 19.3097f, 0.707107f);
7006 path.close();
7007 path.moveTo(0.539863f, 16.1851f);
7008 path.quadTo(0.719962f, 15.6854f, 0.920307f, 15.1934f);
7009 path.conicTo(1.29748f, 14.2673f, 2.22362f, 14.6445f, 0.707107f);
7010 path.conicTo(3.14976f, 15.0216f, 2.7726f, 15.9478f, 0.707107f);
7011 path.quadTo(2.58765f, 16.4019f, 2.42141f, 16.8632f);
7012 path.conicTo(2.08237f, 17.804f, 1.1416f, 17.4649f, 0.707107f);
7013 path.conicTo(0.200823f, 17.1259f, 0.539863f, 16.1851f, 0.707107f);
7014 path.close();
7015 path.moveTo(1.78353f, 13.2955f);
7016 path.quadTo(2.01364f, 12.8391f, 2.26151f, 12.392f);
7017 path.conicTo(2.74643f, 11.5175f, 3.62099f, 12.0024f, 0.707107f);
7018 path.conicTo(4.49555f, 12.4873f, 4.01063f, 13.3618f, 0.707107f);
7019 path.quadTo(3.78183f, 13.7745f, 3.56941f, 14.1958f);
7020 path.conicTo(3.11923f, 15.0888f, 2.22629f, 14.6386f, 0.707107f);
7021 path.conicTo(1.33336f, 14.1884f, 1.78353f, 13.2955f, 0.707107f);
7022 path.close();
7023 path.moveTo(3.30083f, 10.6771f);
7024 path.lineTo(3.44218f, 10.4652f);
7025 path.quadTo(3.6466f, 10.1621f, 3.85641f, 9.86895f);
7026 path.conicTo(4.43837f, 9.05574f, 5.25159f, 9.6377f, 0.707107f);
7027 path.conicTo(6.0648f, 10.2197f, 5.48284f, 11.0329f, 0.707107f);
7028 path.quadTo(5.28917f, 11.3035f, 5.10592f, 11.5752f);
7029 path.lineTo(4.96457f, 11.787f);
7030 path.conicTo(4.4096f, 12.6189f, 3.57773f, 12.0639f, 0.707107f);
7031 path.conicTo(2.74586f, 11.509f, 3.30083f, 10.6771f, 0.707107f);
7032 path.close();
7033 path.moveTo(5.0909f, 8.27793f);
7034 path.quadTo(5.42174f, 7.88403f, 5.76791f, 7.50353f);
7035 path.conicTo(6.44085f, 6.76383f, 7.18054f, 7.43678f, 0.707107f);
7036 path.conicTo(7.92024f, 8.10972f, 7.24729f, 8.84942f, 0.707107f);
7037 path.quadTo(6.92775f, 9.20065f, 6.62237f, 9.56424f);
7038 path.conicTo(5.97921f, 10.33f, 5.21348f, 9.68682f, 0.707107f);
7039 path.conicTo(4.44774f, 9.04367f, 5.0909f, 8.27793f, 0.707107f);
7040 path.close();
7041 path.moveTo(7.24064f, 6.0104f);
7042 path.quadTo(7.63069f, 5.64561f, 8.03537f, 5.29717f);
7043 path.conicTo(8.79318f, 4.64469f, 9.44566f, 5.40249f, 0.707107f);
7044 path.conicTo(10.0981f, 6.16029f, 9.34034f, 6.81278f, 0.707107f);
7045 path.quadTo(8.96678f, 7.13442f, 8.60675f, 7.47113f);
7046 path.conicTo(7.87638f, 8.15419f, 7.19332f, 7.42382f, 0.707107f);
7047 path.conicTo(6.51027f, 6.69345f, 7.24064f, 6.0104f, 0.707107f);
7048 path.close();
7049 path.moveTo(9.73726f, 3.95128f);
7050 path.quadTo(10.1706f, 3.63704f, 10.6165f, 3.34092f);
7051 path.conicTo(11.4496f, 2.78771f, 12.0028f, 3.62075f, 0.707107f);
7052 path.conicTo(12.556f, 4.4538f, 11.7229f, 5.007f, 0.707107f);
7053 path.quadTo(11.3113f, 5.28035f, 10.9113f, 5.57041f);
7054 path.conicTo(10.1018f, 6.15744f, 9.51472f, 5.34787f, 0.707107f);
7055 path.conicTo(8.92769f, 4.53831f, 9.73726f, 3.95128f, 0.707107f);
7056 path.close();
7057 path.moveTo(12.374f, 2.27153f);
7058 path.quadTo(12.8282f, 2.01921f, 13.2921f, 1.78522f);
7059 path.conicTo(14.185f, 1.33492f, 14.6353f, 2.22779f, 0.707107f);
7060 path.conicTo(15.0856f, 3.12067f, 14.1927f, 3.57097f, 0.707107f);
7061 path.quadTo(13.7645f, 3.78696f, 13.3452f, 4.01988f);
7062 path.conicTo(12.471f, 4.5055f, 11.9854f, 3.63132f, 0.707107f);
7063 path.conicTo(11.4998f, 2.75715f, 12.374f, 2.27153f, 0.707107f);
7064 path.close();
7065 path.moveTo(15.1984f, 0.918296f);
7066 path.quadTo(15.6866f, 0.719602f, 16.1824f, 0.540851f);
7067 path.conicTo(17.1231f, 0.20171f, 17.4623f, 1.14245f, 0.707107f);
7068 path.conicTo(17.8014f, 2.08318f, 16.8607f, 2.42232f, 0.707107f);
7069 path.quadTo(16.403f, 2.58733f, 15.9524f, 2.77074f);
7070 path.conicTo(15.0261f, 3.14772f, 14.6492f, 2.2215f, 0.707107f);
7071 path.conicTo(14.2722f, 1.29528f, 15.1984f, 0.918296f, 0.707107f);
7072 path.close();
7073 path.moveTo(18.201f, -0.0952874f);
7074 path.quadTo(18.7132f, -0.234075f, 19.2308f, -0.351842f);
7075 path.conicTo(20.2058f, -0.573734f, 20.4277f, 0.401338f, 0.707107f);
7076 path.conicTo(20.6496f, 1.37641f, 19.6745f, 1.5983f, 0.707107f);
7077 path.quadTo(19.1968f, 1.70701f, 18.724f, 1.83512f);
7078 path.conicTo(17.7588f, 2.09662f, 17.4973f, 1.13142f, 0.707107f);
7079 path.conicTo(17.2358f, 0.166216f, 18.201f, -0.0952874f, 0.707107f);
7080 path.close();
7081 path.moveTo(21.2986f, -0.73518f);
7082 path.quadTo(21.8155f, -0.809526f, 22.3349f, -0.863052f);
7083 path.conicTo(23.3297f, -0.965552f, 23.4322f, 0.029181f, 0.707107f);
7084 path.conicTo(23.5347f, 1.02391f, 22.5399f, 1.12641f, 0.707107f);
7085 path.quadTo(22.0604f, 1.17582f, 21.5833f, 1.24445f);
7086 path.conicTo(20.5935f, 1.38681f, 20.4511f, 0.397f, 0.707107f);
7087 path.conicTo(20.3088f, -0.592814f, 21.2986f, -0.73518f, 0.707107f);
7088 path.close();
7089 path.moveTo(24.4124f, -0.993361f);
7090 path.quadTo(24.9312f, -1.00509f, 25.4501f, -0.996107f);
7091 path.conicTo(26.4499f, -0.978799f, 26.4326f, 0.0210512f, 0.707107f);
7092 path.conicTo(26.4153f, 1.0209f, 25.4155f, 1.00359f, 0.707107f);
7093 path.quadTo(24.9365f, 0.995302f, 24.4576f, 1.00613f);
7094 path.conicTo(23.4578f, 1.02873f, 23.4352f, 0.0289853f, 0.707107f);
7095 path.conicTo(23.4126f, -0.970759f, 24.4124f, -0.993361f, 0.707107f);
7096 path.close();
7097 path.moveTo(27.5481f, -0.87484f);
7098 path.quadTo(28.0668f, -0.823762f, 28.583f, -0.75194f);
7099 path.conicTo(29.5734f, -0.614138f, 29.4356f, 0.376322f, 0.707107f);
7100 path.conicTo(29.2978f, 1.36678f, 28.3074f, 1.22898f, 0.707107f);
7101 path.quadTo(27.8309f, 1.16268f, 27.3521f, 1.11553f);
7102 path.conicTo(26.3569f, 1.01753f, 26.4549f, 0.0223428f, 0.707107f);
7103 path.conicTo(26.5529f, -0.972843f, 27.5481f, -0.87484f, 0.707107f);
7104 path.close();
7105 path.moveTo(30.6151f, -0.386432f);
7106 path.quadTo(31.1507f, -0.267954f, 31.6809f, -0.126991f);
7107 path.conicTo(32.6473f, 0.129965f, 32.3904f, 1.09639f, 0.707107f);
7108 path.conicTo(32.1334f, 2.06281f, 31.167f, 1.80585f, 0.707107f);
7109 path.quadTo(30.6776f, 1.67574f, 30.1832f, 1.56637f);
7110 path.conicTo(29.2068f, 1.35041f, 29.4227f, 0.374005f, 0.707107f);
7111 path.conicTo(29.6387f, -0.602396f, 30.6151f, -0.386432f, 0.707107f);
7112 path.close();
7113 path.moveTo(33.7445f, 0.514616f);
7114 path.quadTo(34.2452f, 0.693421f, 34.7381f, 0.892536f);
7115 path.conicTo(35.6653f, 1.26708f, 35.2908f, 2.19429f, 0.707107f);
7116 path.conicTo(34.9162f, 3.1215f, 33.989f, 2.74696f, 0.707107f);
7117 path.quadTo(33.534f, 2.56316f, 33.0718f, 2.3981f);
7118 path.conicTo(32.1301f, 2.06177f, 32.4664f, 1.12003f, 0.707107f);
7119 path.conicTo(32.8027f, 0.178285f, 33.7445f, 0.514616f, 0.707107f);
7120 path.close();
7121 path.moveTo(36.6402f, 1.7512f);
7122 path.quadTo(37.0977f, 1.98026f, 37.5458f, 2.22715f);
7123 path.conicTo(38.4217f, 2.70968f, 37.9392f, 3.58556f, 0.707107f);
7124 path.conicTo(37.4566f, 4.46144f, 36.5808f, 3.97891f, 0.707107f);
7125 path.quadTo(36.1671f, 3.75102f, 35.7448f, 3.53956f);
7126 path.conicTo(34.8506f, 3.09185f, 35.2983f, 2.19767f, 0.707107f);
7127 path.conicTo(35.746f, 1.30349f, 36.6402f, 1.7512f, 0.707107f);
7128 path.close();
7129 path.moveTo(39.2611f, 3.26012f);
7130 path.quadTo(39.4005f, 3.35159f, 39.539f, 3.44501f);
7131 path.quadTo(39.8091f, 3.62717f, 40.0746f, 3.81611f);
7132 path.conicTo(40.8893f, 4.3959f, 40.3096f, 5.21067f, 0.707107f);
7133 path.conicTo(39.7298f, 6.02543f, 38.915f, 5.44564f, 0.707107f);
7134 path.quadTo(38.67f, 5.2713f, 38.4206f, 5.10309f);
7135 path.quadTo(38.293f, 5.017f, 38.164f, 4.9324f);
7136 path.conicTo(37.3279f, 4.38388f, 37.8764f, 3.54775f, 0.707107f);
7137 path.conicTo(38.4249f, 2.71161f, 39.2611f, 3.26012f, 0.707107f);
7138 path.close();
7139 path.moveTo(41.6673f, 5.04503f);
7140 path.quadTo(42.0618f, 5.37449f, 42.4428f, 5.71927f);
7141 path.conicTo(43.1844f, 6.39015f, 42.5135f, 7.13171f, 0.707107f);
7142 path.conicTo(41.8426f, 7.87327f, 41.1011f, 7.20239f, 0.707107f);
7143 path.quadTo(40.7493f, 6.88414f, 40.3852f, 6.58004f);
7144 path.conicTo(39.6177f, 5.93899f, 40.2588f, 5.17149f, 0.707107f);
7145 path.conicTo(40.8998f, 4.40399f, 41.6673f, 5.04503f, 0.707107f);
7146 path.close();
7147 path.moveTo(43.9388f, 7.1865f);
7148 path.quadTo(44.3044f, 7.57519f, 44.6538f, 7.97856f);
7149 path.conicTo(45.3084f, 8.73448f, 44.5525f, 9.38914f, 0.707107f);
7150 path.conicTo(43.7966f, 10.0438f, 43.1419f, 9.28789f, 0.707107f);
7151 path.quadTo(42.8195f, 8.91555f, 42.482f, 8.55677f);
7152 path.conicTo(41.7969f, 7.82836f, 42.5253f, 7.14322f, 0.707107f);
7153 path.conicTo(43.2537f, 6.45808f, 43.9388f, 7.1865f, 0.707107f);
7154 path.close();
7155 path.moveTo(46.0036f, 9.6753f);
7156 path.quadTo(46.3207f, 10.1098f, 46.6195f, 10.5571f);
7157 path.conicTo(47.175f, 11.3886f, 46.3435f, 11.9441f, 0.707107f);
7158 path.conicTo(45.5119f, 12.4996f, 44.9564f, 11.6681f, 0.707107f);
7159 path.quadTo(44.6806f, 11.2552f, 44.388f, 10.8541f);
7160 path.conicTo(43.7986f, 10.0463f, 44.6064f, 9.45688f, 0.707107f);
7161 path.conicTo(45.4142f, 8.86747f, 46.0036f, 9.6753f, 0.707107f);
7162 path.close();
7163 path.moveTo(47.6932f, 12.3107f);
7164 path.quadTo(47.9467f, 12.764f, 48.1819f, 13.2271f);
7165 path.conicTo(48.6347f, 14.1187f, 47.7431f, 14.5715f, 0.707107f);
7166 path.conicTo(46.8514f, 15.0243f, 46.3986f, 14.1327f, 0.707107f);
7167 path.quadTo(46.1816f, 13.7053f, 45.9476f, 13.2868f);
7168 path.conicTo(45.4595f, 12.414f, 46.3323f, 11.9259f, 0.707107f);
7169 path.conicTo(47.2051f, 11.4379f, 47.6932f, 12.3107f, 0.707107f);
7170 path.close();
7171 path.moveTo(49.0539f, 15.1303f);
7172 path.quadTo(49.2539f, 15.6178f, 49.434f, 16.113f);
7173 path.conicTo(49.7758f, 17.0527f, 48.836f, 17.3946f, 0.707107f);
7174 path.conicTo(47.8963f, 17.7364f, 47.5545f, 16.7966f, 0.707107f);
7175 path.quadTo(47.3882f, 16.3395f, 47.2036f, 15.8895f);
7176 path.conicTo(46.824f, 14.9643f, 47.7491f, 14.5847f, 0.707107f);
7177 path.conicTo(48.6743f, 14.2051f, 49.0539f, 15.1303f, 0.707107f);
7178 path.close();
7179 path.moveTo(50.0758f, 18.1294f);
7180 path.quadTo(50.216f, 18.6412f, 50.3352f, 19.1584f);
7181 path.conicTo(50.5599f, 20.1328f, 49.5855f, 20.3575f, 0.707107f);
7182 path.conicTo(48.6111f, 20.5821f, 48.3864f, 19.6077f, 0.707107f);
7183 path.quadTo(48.2763f, 19.1304f, 48.1469f, 18.6579f);
7184 path.conicTo(47.8826f, 17.6935f, 48.8471f, 17.4292f, 0.707107f);
7185 path.conicTo(49.8115f, 17.165f, 50.0758f, 18.1294f, 0.707107f);
7186 path.close();
7187 path.moveTo(50.7247f, 21.2262f);
7188 path.quadTo(50.8005f, 21.743f, 50.8555f, 22.2623f);
7189 path.conicTo(50.9607f, 23.2568f, 49.9663f, 23.3621f, 0.707107f);
7190 path.conicTo(48.9719f, 23.4673f, 48.8666f, 22.4729f, 0.707107f);
7191 path.quadTo(48.8158f, 21.9935f, 48.7458f, 21.5165f);
7192 path.conicTo(48.6007f, 20.5271f, 49.5901f, 20.382f, 0.707107f);
7193 path.conicTo(50.5795f, 20.2368f, 50.7247f, 21.2262f, 0.707107f);
7194 path.close();
7195 path.moveTo(50.9916f, 24.3398f);
7196 path.quadTo(51.0048f, 24.858f, 50.9973f, 25.3762f);
7197 path.conicTo(50.9828f, 26.3761f, 49.9829f, 26.3616f, 0.707107f);
7198 path.conicTo(48.983f, 26.3472f, 48.9975f, 25.3473f, 0.707107f);
7199 path.quadTo(49.0044f, 24.8687f, 48.9923f, 24.3906f);
7200 path.conicTo(48.9669f, 23.3909f, 49.9665f, 23.3655f, 0.707107f);
7201 path.conicTo(50.9662f, 23.3401f, 50.9916f, 24.3398f, 0.707107f);
7202 path.close();
7203 path.moveTo(50.8819f, 27.4753f);
7204 path.quadTo(50.8323f, 27.9943f, 50.7618f, 28.511f);
7205 path.conicTo(50.6268f, 29.5018f, 49.636f, 29.3668f, 0.707107f);
7206 path.conicTo(48.6451f, 29.2317f, 48.7802f, 28.2409f, 0.707107f);
7207 path.quadTo(48.8452f, 27.7641f, 48.891f, 27.2849f);
7208 path.conicTo(48.9862f, 26.2894f, 49.9816f, 26.3846f, 0.707107f);
7209 path.conicTo(50.9771f, 26.4798f, 50.8819f, 27.4753f, 0.707107f);
7210 path.close();
7211 path.moveTo(50.4023f, 30.5429f);
7212 path.quadTo(50.2856f, 31.0775f, 50.1465f, 31.607f);
7213 path.conicTo(49.8924f, 32.5742f, 48.9252f, 32.3201f, 0.707107f);
7214 path.conicTo(47.9581f, 32.066f, 48.2122f, 31.0988f, 0.707107f);
7215 path.quadTo(48.3405f, 30.6102f, 48.4483f, 30.1165f);
7216 path.conicTo(48.6614f, 29.1395f, 49.6385f, 29.3527f, 0.707107f);
7217 path.conicTo(50.6155f, 29.5659f, 50.4023f, 30.5429f, 0.707107f);
7218 path.close();
7219 path.moveTo(49.5104f, 33.674f);
7220 path.quadTo(49.3329f, 34.1756f, 49.1351f, 34.6695f);
7221 path.conicTo(48.7632f, 35.5977f, 47.8349f, 35.2258f, 0.707107f);
7222 path.conicTo(46.9066f, 34.854f, 47.2785f, 33.9257f, 0.707107f);
7223 path.quadTo(47.4612f, 33.4697f, 47.625f, 33.0067f);
7224 path.conicTo(47.9587f, 32.064f, 48.9014f, 32.3977f, 0.707107f);
7225 path.conicTo(49.8441f, 32.7313f, 49.5104f, 33.674f, 0.707107f);
7226 path.close();
7227 path.moveTo(48.281f, 36.5756f);
7228 path.quadTo(48.053f, 37.0342f, 47.8071f, 37.4835f);
7229 path.conicTo(47.3269f, 38.3607f, 46.4497f, 37.8805f, 0.707107f);
7230 path.conicTo(45.5725f, 37.4004f, 46.0527f, 36.5232f, 0.707107f);
7231 path.quadTo(46.2797f, 36.1085f, 46.4901f, 35.6852f);
7232 path.conicTo(46.9353f, 34.7898f, 47.8307f, 35.235f, 0.707107f);
7233 path.conicTo(48.7262f, 35.6802f, 48.281f, 36.5756f, 0.707107f);
7234 path.close();
7235 path.moveTo(46.7777f, 39.2033f);
7236 path.quadTo(46.6677f, 39.3719f, 46.555f, 39.539f);
7237 path.quadTo(46.3865f, 39.7888f, 46.2121f, 40.0349f);
7238 path.conicTo(45.6338f, 40.8507f, 44.818f, 40.2724f, 0.707107f);
7239 path.conicTo(44.0021f, 39.6942f, 44.5804f, 38.8783f, 0.707107f);
7240 path.quadTo(44.7413f, 38.6513f, 44.8969f, 38.4206f);
7241 path.quadTo(45.0008f, 38.2665f, 45.1025f, 38.1107f);
7242 path.conicTo(45.6488f, 37.2731f, 46.4864f, 37.8194f, 0.707107f);
7243 path.conicTo(47.324f, 38.3657f, 46.7777f, 39.2033f, 0.707107f);
7244 path.close();
7245 path.moveTo(44.9527f, 41.6701f);
7246 path.quadTo(44.6177f, 42.0709f, 44.267f, 42.458f);
7247 path.conicTo(43.5955f, 43.1991f, 42.8545f, 42.5276f, 0.707107f);
7248 path.conicTo(42.1135f, 41.8561f, 42.7849f, 41.1151f, 0.707107f);
7249 path.quadTo(43.1087f, 40.7578f, 43.4178f, 40.3878f);
7250 path.conicTo(44.059f, 39.6203f, 44.8264f, 40.2615f, 0.707107f);
7251 path.conicTo(45.5938f, 40.9027f, 44.9527f, 41.6701f, 0.707107f);
7252 path.close();
7253 path.moveTo(42.7884f, 43.9624f);
7254 path.quadTo(42.4083f, 44.319f, 42.014f, 44.6602f);
7255 path.conicTo(41.2578f, 45.3146f, 40.6034f, 44.5585f, 0.707107f);
7256 path.conicTo(39.949f, 43.8023f, 40.7052f, 43.1479f, 0.707107f);
7257 path.quadTo(41.0691f, 42.833f, 41.4201f, 42.5037f);
7258 path.conicTo(42.1494f, 41.8196f, 42.8336f, 42.5489f, 0.707107f);
7259 path.conicTo(43.5178f, 43.2782f, 42.7884f, 43.9624f, 0.707107f);
7260 path.close();
7261 path.moveTo(40.3892f, 45.9564f);
7262 path.quadTo(39.9683f, 46.2655f, 39.5354f, 46.5574f);
7263 path.conicTo(38.7062f, 47.1165f, 38.1472f, 46.2873f, 0.707107f);
7264 path.conicTo(37.5881f, 45.4582f, 38.4173f, 44.8992f, 0.707107f);
7265 path.quadTo(38.8169f, 44.6297f, 39.2054f, 44.3444f);
7266 path.conicTo(40.0114f, 43.7525f, 40.6033f, 44.5585f, 0.707107f);
7267 path.conicTo(41.1952f, 45.3645f, 40.3892f, 45.9564f, 0.707107f);
7268 path.close();
7269 path.moveTo(37.7543f, 47.6568f);
7270 path.quadTo(37.2977f, 47.9138f, 36.8312f, 48.1522f);
7271 path.conicTo(35.9407f, 48.6072f, 35.4857f, 47.7167f, 0.707107f);
7272 path.conicTo(35.0306f, 46.8263f, 35.9211f, 46.3712f, 0.707107f);
7273 path.quadTo(36.3518f, 46.1511f, 36.7732f, 45.9139f);
7274 path.conicTo(37.6446f, 45.4234f, 38.1351f, 46.2948f, 0.707107f);
7275 path.conicTo(38.6257f, 47.1662f, 37.7543f, 47.6568f, 0.707107f);
7276 path.close();
7277 path.moveTo(34.9311f, 49.0286f);
7278 path.quadTo(34.4488f, 49.2279f, 33.9589f, 49.4077f);
7279 path.conicTo(33.0202f, 49.7523f, 32.6756f, 48.8136f, 0.707107f);
7280 path.conicTo(32.331f, 47.8748f, 33.2698f, 47.5302f, 0.707107f);
7281 path.quadTo(33.722f, 47.3642f, 34.1672f, 47.1802f);
7282 path.conicTo(35.0914f, 46.7983f, 35.4733f, 47.7224f, 0.707107f);
7283 path.conicTo(35.8553f, 48.6466f, 34.9311f, 49.0286f, 0.707107f);
7284 path.close();
7285 path.moveTo(31.9824f, 50.0449f);
7286 path.quadTo(31.4774f, 50.1857f, 30.9668f, 50.3061f);
7287 path.conicTo(29.9935f, 50.5355f, 29.764f, 49.5622f, 0.707107f);
7288 path.conicTo(29.5346f, 48.5889f, 30.5079f, 48.3594f, 0.707107f);
7289 path.quadTo(30.9789f, 48.2484f, 31.4453f, 48.1184f);
7290 path.conicTo(32.4086f, 47.8498f, 32.6771f, 48.8131f, 0.707107f);
7291 path.conicTo(32.9457f, 49.7763f, 31.9824f, 50.0449f, 0.707107f);
7292 path.close();
7293 path.moveTo(28.899f, 50.706f);
7294 path.quadTo(28.3834f, 50.7842f, 27.8652f, 50.8416f);
7295 path.conicTo(26.8713f, 50.9518f, 26.7611f, 49.9579f, 0.707107f);
7296 path.conicTo(26.6509f, 48.964f, 27.6448f, 48.8538f, 0.707107f);
7297 path.quadTo(28.1231f, 48.8008f, 28.599f, 48.7286f);
7298 path.conicTo(29.5877f, 48.5786f, 29.7377f, 49.5673f, 0.707107f);
7299 path.conicTo(29.8877f, 50.556f, 28.899f, 50.706f, 0.707107f);
7300 path.close();
7301 path.moveTo(25.8106f, 50.9874f);
7302 path.quadTo(25.6321f, 50.9929f, 25.4537f, 50.996f);
7303 path.conicTo(24.4539f, 51.0135f, 24.4365f, 50.0136f, 0.707115f);
7304 path.lineTo(24.4251f, 49.3638f);
7305 path.conicTo(24.4077f, 48.364f, 25.4075f, 48.3465f, 0.707107f);
7306 path.conicTo(26.4073f, 48.3291f, 26.4248f, 49.3289f, 0.707107f);
7307 path.lineTo(26.4361f, 49.9787f);
7308 path.lineTo(25.4363f, 49.9962f);
7309 path.lineTo(25.4189f, 48.9963f);
7310 path.quadTo(25.5836f, 48.9935f, 25.7482f, 48.9883f);
7311 path.conicTo(26.7477f, 48.9571f, 26.7789f, 49.9567f, 0.707107f);
7312 path.conicTo(26.8101f, 50.9562f, 25.8106f, 50.9874f, 0.707107f);
7313 path.close();
7314 path.moveTo(24.3902f, 47.3641f);
7315 path.lineTo(24.3728f, 46.3643f);
7316 path.conicTo(24.3553f, 45.3645f, 25.3551f, 45.347f, 0.707107f);
7317 path.conicTo(26.355f, 45.3295f, 26.3724f, 46.3294f, 0.707107f);
7318 path.lineTo(26.3899f, 47.3292f);
7319 path.conicTo(26.4074f, 48.3291f, 25.4075f, 48.3465f, 0.707107f);
7320 path.conicTo(24.4077f, 48.364f, 24.3902f, 47.3641f, 0.707107f);
7321 path.close();
7322 path.moveTo(24.3378f, 44.3646f);
7323 path.lineTo(24.3204f, 43.3648f);
7324 path.conicTo(24.3029f, 42.3649f, 25.3028f, 42.3475f, 0.707107f);
7325 path.conicTo(26.3026f, 42.33f, 26.3201f, 43.3298f, 0.707107f);
7326 path.lineTo(26.3375f, 44.3297f);
7327 path.conicTo(26.355f, 45.3295f, 25.3551f, 45.347f, 0.707107f);
7328 path.conicTo(24.3553f, 45.3645f, 24.3378f, 44.3646f, 0.707107f);
7329 path.close();
7330 path.moveTo(24.2855f, 41.3651f);
7331 path.lineTo(24.268f, 40.3652f);
7332 path.conicTo(24.2506f, 39.3654f, 25.2504f, 39.3479f, 0.707107f);
7333 path.conicTo(26.2503f, 39.3305f, 26.2677f, 40.3303f, 0.707107f);
7334 path.lineTo(26.2852f, 41.3302f);
7335 path.conicTo(26.3026f, 42.33f, 25.3028f, 42.3475f, 0.707107f);
7336 path.conicTo(24.3029f, 42.3649f, 24.2855f, 41.3651f, 0.707107f);
7337 path.close();
7338 path.moveTo(24.2331f, 38.3655f);
7339 path.lineTo(24.2157f, 37.3657f);
7340 path.conicTo(24.1982f, 36.3658f, 25.1981f, 36.3484f, 0.707107f);
7341 path.conicTo(26.1979f, 36.3309f, 26.2154f, 37.3308f, 0.707107f);
7342 path.lineTo(26.2328f, 38.3306f);
7343 path.conicTo(26.2503f, 39.3305f, 25.2504f, 39.3479f, 0.707107f);
7344 path.conicTo(24.2506f, 39.3654f, 24.2331f, 38.3655f, 0.707107f);
7345 path.close();
7346 path.moveTo(24.1808f, 35.366f);
7347 path.lineTo(24.1633f, 34.3661f);
7348 path.conicTo(24.1459f, 33.3663f, 25.1457f, 33.3488f, 0.707107f);
7349 path.conicTo(26.1456f, 33.3314f, 26.163f, 34.3312f, 0.707107f);
7350 path.lineTo(26.1805f, 35.3311f);
7351 path.conicTo(26.1979f, 36.3309f, 25.1981f, 36.3484f, 0.707107f);
7352 path.conicTo(24.1982f, 36.3658f, 24.1808f, 35.366f, 0.707107f);
7353 path.close();
7354 path.moveTo(24.1284f, 32.3664f);
7355 path.lineTo(24.111f, 31.3666f);
7356 path.conicTo(24.0935f, 30.3667f, 25.0934f, 30.3493f, 0.707107f);
7357 path.conicTo(26.0932f, 30.3318f, 26.1107f, 31.3317f, 0.707107f);
7358 path.lineTo(26.1281f, 32.3315f);
7359 path.conicTo(26.1456f, 33.3314f, 25.1457f, 33.3488f, 0.707107f);
7360 path.conicTo(24.1459f, 33.3663f, 24.1284f, 32.3664f, 0.707107f);
7361 path.close();
7362 path.moveTo(24.0761f, 29.3669f);
7363 path.lineTo(24.0586f, 28.367f);
7364 path.conicTo(24.0412f, 27.3672f, 25.041f, 27.3497f, 0.707107f);
7365 path.conicTo(26.0409f, 27.3323f, 26.0583f, 28.3321f, 0.707107f);
7366 path.lineTo(26.0758f, 29.332f);
7367 path.conicTo(26.0932f, 30.3318f, 25.0934f, 30.3493f, 0.707107f);
7368 path.conicTo(24.0935f, 30.3667f, 24.0761f, 29.3669f, 0.707107f);
7369 path.close();
7370 path.moveTo(24.0237f, 26.3673f);
7371 path.lineTo(24.0063f, 25.3675f);
7372 path.conicTo(23.9888f, 24.3676f, 24.9887f, 24.3502f, 0.707107f);
7373 path.conicTo(25.9885f, 24.3327f, 26.006f, 25.3326f, 0.707107f);
7374 path.lineTo(26.0234f, 26.3324f);
7375 path.conicTo(26.0409f, 27.3323f, 25.041f, 27.3497f, 0.707107f);
7376 path.conicTo(24.0412f, 27.3672f, 24.0237f, 26.3673f, 0.707107f);
7377 path.close();
7378 path1 = path;
7379 path.reset();
7380 path.setFillType(SkPathFillType::kWinding);
7381 path.moveTo(25.0098f, 23.1973f);
7382 path.lineTo(25.5689f, 22.3682f);
7383 path.conicTo(26.1281f, 21.5392f, 26.9572f, 22.0984f, 0.707107f);
7384 path.conicTo(27.7862f, 22.6576f, 27.227f, 23.4866f, 0.707107f);
7385 path.lineTo(26.6678f, 24.3156f);
7386 path.conicTo(26.1086f, 25.1447f, 25.2796f, 24.5855f, 0.707107f);
7387 path.conicTo(24.4506f, 24.0263f, 25.0098f, 23.1973f, 0.707107f);
7388 path.close();
7389 path.moveTo(26.6873f, 20.7101f);
7390 path.lineTo(27.2465f, 19.8811f);
7391 path.conicTo(27.8057f, 19.0521f, 28.6348f, 19.6113f, 0.707107f);
7392 path.conicTo(29.4638f, 20.1704f, 28.9046f, 20.9995f, 0.707107f);
7393 path.lineTo(28.3454f, 21.8285f);
7394 path.conicTo(27.7862f, 22.6576f, 26.9572f, 22.0984f, 0.707107f);
7395 path.conicTo(26.1281f, 21.5392f, 26.6873f, 20.7101f, 0.707107f);
7396 path.close();
7397 path.moveTo(28.3649f, 18.223f);
7398 path.lineTo(28.9241f, 17.394f);
7399 path.conicTo(29.4833f, 16.565f, 30.3123f, 17.1241f, 0.707107f);
7400 path.conicTo(31.1414f, 17.6833f, 30.5822f, 18.5124f, 0.707107f);
7401 path.lineTo(30.023f, 19.3414f);
7402 path.conicTo(29.4638f, 20.1704f, 28.6348f, 19.6113f, 0.707107f);
7403 path.conicTo(27.8057f, 19.0521f, 28.3649f, 18.223f, 0.707107f);
7404 path.close();
7405 path.moveTo(30.0425f, 15.7359f);
7406 path.lineTo(30.6017f, 14.9069f);
7407 path.conicTo(31.1609f, 14.0778f, 31.9899f, 14.637f, 0.707107f);
7408 path.conicTo(32.8189f, 15.1962f, 32.2598f, 16.0253f, 0.707107f);
7409 path.lineTo(31.7006f, 16.8543f);
7410 path.conicTo(31.1414f, 17.6833f, 30.3123f, 17.1241f, 0.707107f);
7411 path.conicTo(29.4833f, 16.565f, 30.0425f, 15.7359f, 0.707107f);
7412 path.close();
7413 path.moveTo(31.7201f, 13.2488f);
7414 path.lineTo(32.2793f, 12.4198f);
7415 path.conicTo(32.8385f, 11.5907f, 33.6675f, 12.1499f, 0.707107f);
7416 path.conicTo(34.4965f, 12.7091f, 33.9373f, 13.5381f, 0.707107f);
7417 path.lineTo(33.3781f, 14.3672f);
7418 path.conicTo(32.8189f, 15.1962f, 31.9899f, 14.637f, 0.707107f);
7419 path.conicTo(31.1609f, 14.0778f, 31.7201f, 13.2488f, 0.707107f);
7420 path.close();
7421 path.moveTo(33.3976f, 10.7617f);
7422 path.lineTo(33.9568f, 9.93265f);
7423 path.conicTo(34.516f, 9.10361f, 35.3451f, 9.6628f, 0.707107f);
7424 path.conicTo(36.1741f, 10.222f, 35.6149f, 11.051f, 0.707107f);
7425 path.lineTo(35.0557f, 11.8801f);
7426 path.conicTo(34.4965f, 12.7091f, 33.6675f, 12.1499f, 0.707107f);
7427 path.conicTo(32.8385f, 11.5907f, 33.3976f, 10.7617f, 0.707107f);
7428 path.close();
7429 path.moveTo(35.0752f, 8.27457f);
7430 path.lineTo(35.6344f, 7.44554f);
7431 path.conicTo(36.1936f, 6.6165f, 37.0226f, 7.17569f, 0.707107f);
7432 path.conicTo(37.8517f, 7.73488f, 37.2925f, 8.56392f, 0.707107f);
7433 path.lineTo(36.7333f, 9.39296f);
7434 path.conicTo(36.1741f, 10.222f, 35.3451f, 9.6628f, 0.707107f);
7435 path.conicTo(34.516f, 9.10361f, 35.0752f, 8.27457f, 0.707107f);
7436 path.close();
7437 path.moveTo(36.7528f, 5.78746f);
7438 path.lineTo(37.312f, 4.95842f);
7439 path.conicTo(37.8712f, 4.12939f, 38.7002f, 4.68858f, 0.707107f);
7440 path.conicTo(39.5293f, 5.24777f, 38.9701f, 6.07681f, 0.707107f);
7441 path.lineTo(38.4109f, 6.90585f);
7442 path.conicTo(37.8517f, 7.73488f, 37.0226f, 7.17569f, 0.707107f);
7443 path.conicTo(36.1936f, 6.6165f, 36.7528f, 5.78746f, 0.707107f);
7444 path.close();
7445 path.moveTo(39.9447f, 3.72429f);
7446 path.quadTo(40.3524f, 4.01069f, 40.7489f, 4.31248f);
7447 path.conicTo(41.5445f, 4.9182f, 40.9388f, 5.71387f, 0.707107f);
7448 path.conicTo(40.3331f, 6.50955f, 39.5374f, 5.90383f, 0.707107f);
7449 path.quadTo(39.1714f, 5.62521f, 38.7951f, 5.36088f);
7450 path.conicTo(37.9768f, 4.78608f, 38.5516f, 3.96779f, 0.707107f);
7451 path.conicTo(39.1264f, 3.14949f, 39.9447f, 3.72429f, 0.707107f);
7452 path.close();
7453 path.moveTo(42.3194f, 5.60826f);
7454 path.quadTo(42.707f, 5.95446f, 43.0804f, 6.31583f);
7455 path.conicTo(43.7991f, 7.01122f, 43.1037f, 7.72985f, 0.707107f);
7456 path.conicTo(42.4083f, 8.44848f, 41.6896f, 7.75308f, 0.707107f);
7457 path.quadTo(41.3448f, 7.41944f, 40.9871f, 7.09992f);
7458 path.conicTo(40.2413f, 6.43379f, 40.9074f, 5.68796f, 0.707107f);
7459 path.conicTo(41.5735f, 4.94212f, 42.3194f, 5.60826f, 0.707107f);
7460 path.close();
7461 path.moveTo(44.5406f, 7.84871f);
7462 path.quadTo(44.8959f, 8.25352f, 45.2341f, 8.67266f);
7463 path.conicTo(45.862f, 9.4509f, 45.0838f, 10.0789f, 0.707107f);
7464 path.conicTo(44.3056f, 10.7068f, 43.6776f, 9.9286f, 0.707107f);
7465 path.quadTo(43.3654f, 9.54174f, 43.0374f, 9.16805f);
7466 path.conicTo(42.3778f, 8.41649f, 43.1293f, 7.75682f, 0.707107f);
7467 path.conicTo(43.8809f, 7.09715f, 44.5406f, 7.84871f, 0.707107f);
7468 path.close();
7469 path.moveTo(46.528f, 10.4211f);
7470 path.quadTo(46.815f, 10.8449f, 47.0851f, 11.2796f);
7471 path.conicTo(47.6128f, 12.129f, 46.7633f, 12.6567f, 0.707107f);
7472 path.conicTo(45.9139f, 13.1844f, 45.3862f, 12.335f, 0.707107f);
7473 path.quadTo(45.1369f, 11.9337f, 44.872f, 11.5426f);
7474 path.conicTo(44.3113f, 10.7146f, 45.1393f, 10.1538f, 0.707107f);
7475 path.conicTo(45.9673f, 9.5931f, 46.528f, 10.4211f, 0.707107f);
7476 path.close();
7477 path.moveTo(48.1056f, 13.0782f);
7478 path.quadTo(48.3449f, 13.542f, 48.5654f, 14.015f);
7479 path.conicTo(48.9879f, 14.9213f, 48.0816f, 15.3438f, 0.707107f);
7480 path.conicTo(47.1752f, 15.7663f, 46.7527f, 14.86f, 0.707107f);
7481 path.quadTo(46.5492f, 14.4234f, 46.3283f, 13.9953f);
7482 path.conicTo(45.8698f, 13.1066f, 46.7584f, 12.6481f, 0.707107f);
7483 path.conicTo(47.6471f, 12.1895f, 48.1056f, 13.0782f, 0.707107f);
7484 path.close();
7485 path.moveTo(49.3755f, 15.9538f);
7486 path.quadTo(49.5594f, 16.4493f, 49.7229f, 16.9516f);
7487 path.conicTo(50.0325f, 17.9025f, 49.0816f, 18.2121f, 0.707107f);
7488 path.conicTo(48.1307f, 18.5216f, 47.8212f, 17.5707f, 0.707107f);
7489 path.quadTo(47.6702f, 17.1069f, 47.5005f, 16.6497f);
7490 path.conicTo(47.1526f, 15.7122f, 48.0901f, 15.3642f, 0.707107f);
7491 path.conicTo(49.0276f, 15.0163f, 49.3755f, 15.9538f, 0.707107f);
7492 path.close();
7493 path.moveTo(50.2964f, 18.9923f);
7494 path.quadTo(50.4191f, 19.5089f, 50.5206f, 20.0302f);
7495 path.conicTo(50.7117f, 21.0117f, 49.7302f, 21.2029f, 0.707107f);
7496 path.conicTo(48.7486f, 21.394f, 48.5575f, 20.4125f, 0.707107f);
7497 path.quadTo(48.4638f, 19.9313f, 48.3505f, 19.4544f);
7498 path.conicTo(48.1194f, 18.4815f, 49.0924f, 18.2504f, 0.707107f);
7499 path.conicTo(50.0653f, 18.0193f, 50.2964f, 18.9923f, 0.707107f);
7500 path.close();
7501 path.moveTo(50.8373f, 22.0956f);
7502 path.quadTo(50.8955f, 22.6138f, 50.933f, 23.1341f);
7503 path.conicTo(51.0047f, 24.1315f, 50.0073f, 24.2033f, 0.707107f);
7504 path.conicTo(49.0099f, 24.275f, 48.9381f, 23.2776f, 0.707107f);
7505 path.quadTo(48.9036f, 22.7975f, 48.8498f, 22.3191f);
7506 path.conicTo(48.7381f, 21.3253f, 49.7318f, 21.2136f, 0.707107f);
7507 path.conicTo(50.7255f, 21.1019f, 50.8373f, 22.0956f, 0.707107f);
7508 path.close();
7509 path.moveTo(50.9992f, 25.2099f);
7510 path.quadTo(50.9949f, 25.7358f, 50.9694f, 26.2608f);
7511 path.conicTo(50.9209f, 27.2596f, 49.9221f, 27.2111f, 0.707107f);
7512 path.conicTo(48.9233f, 27.1626f, 48.9718f, 26.1638f, 0.707107f);
7513 path.quadTo(48.9953f, 25.679f, 48.9992f, 25.1938f);
7514 path.conicTo(49.0073f, 24.1938f, 50.0073f, 24.2019f, 0.707107f);
7515 path.conicTo(51.0072f, 24.21f, 50.9992f, 25.2099f, 0.707107f);
7516 path.close();
7517 path.moveTo(50.7839f, 28.3454f);
7518 path.quadTo(50.7172f, 28.8596f, 50.63f, 29.3708f);
7519 path.conicTo(50.4619f, 30.3565f, 49.4761f, 30.1884f, 0.707107f);
7520 path.conicTo(48.4903f, 30.0203f, 48.6584f, 29.0346f, 0.707107f);
7521 path.quadTo(48.7389f, 28.5627f, 48.8005f, 28.088f);
7522 path.conicTo(48.9292f, 27.0963f, 49.9209f, 27.225f, 0.707107f);
7523 path.conicTo(50.9126f, 27.3537f, 50.7839f, 28.3454f, 0.707107f);
7524 path.close();
7525 path.moveTo(50.1906f, 31.437f);
7526 path.quadTo(50.0558f, 31.9646f, 49.899f, 32.4861f);
7527 path.conicTo(49.611f, 33.4438f, 48.6534f, 33.1558f, 0.707107f);
7528 path.conicTo(47.6957f, 32.8679f, 47.9837f, 31.9103f, 0.707107f);
7529 path.quadTo(48.1284f, 31.4289f, 48.2528f, 30.9418f);
7530 path.conicTo(48.5004f, 29.9729f, 49.4693f, 30.2205f, 0.707107f);
7531 path.conicTo(50.4382f, 30.4681f, 50.1906f, 31.437f, 0.707107f);
7532 path.close();
7533 path.moveTo(49.1978f, 34.5114f);
7534 path.quadTo(49.0051f, 35.0016f, 48.7927f, 35.4837f);
7535 path.conicTo(48.3895f, 36.3988f, 47.4744f, 35.9956f, 0.707107f);
7536 path.conicTo(46.5593f, 35.5923f, 46.9625f, 34.6772f, 0.707107f);
7537 path.quadTo(47.1586f, 34.2323f, 47.3364f, 33.7797f);
7538 path.conicTo(47.7023f, 32.849f, 48.6329f, 33.2149f, 0.707107f);
7539 path.conicTo(49.5636f, 33.5807f, 49.1978f, 34.5114f, 0.707107f);
7540 path.close();
7541 path.moveTo(47.8852f, 37.3397f);
7542 path.quadTo(47.6449f, 37.7853f, 47.3876f, 38.2211f);
7543 path.conicTo(46.879f, 39.0821f, 46.018f, 38.5736f, 0.707107f);
7544 path.conicTo(45.1569f, 38.0651f, 45.6655f, 37.204f, 0.707107f);
7545 path.quadTo(45.903f, 36.8018f, 46.1248f, 36.3906f);
7546 path.conicTo(46.5993f, 35.5103f, 47.4796f, 35.9849f, 0.707107f);
7547 path.conicTo(48.3598f, 36.4595f, 47.8852f, 37.3397f, 0.707107f);
7548 path.close();
7549 path.moveTo(46.3154f, 39.8881f);
7550 path.quadTo(46.0303f, 40.2962f, 45.7299f, 40.693f);
7551 path.conicTo(45.1264f, 41.4903f, 44.3291f, 40.8867f, 0.707107f);
7552 path.conicTo(43.5318f, 40.2831f, 44.1353f, 39.4858f, 0.707107f);
7553 path.quadTo(44.4126f, 39.1195f, 44.6757f, 38.7428f);
7554 path.conicTo(45.2483f, 37.923f, 46.0682f, 38.4956f, 0.707107f);
7555 path.conicTo(46.888f, 39.0682f, 46.3154f, 39.8881f, 0.707107f);
7556 path.close();
7557 path.moveTo(44.4398f, 42.2654f);
7558 path.quadTo(44.095f, 42.6536f, 43.7349f, 43.0278f);
7559 path.conicTo(43.0415f, 43.7484f, 42.321f, 43.055f, 0.707107f);
7560 path.conicTo(41.6004f, 42.3616f, 42.2938f, 41.641f, 0.707107f);
7561 path.quadTo(42.6261f, 41.2957f, 42.9444f, 40.9374f);
7562 path.conicTo(43.6084f, 40.1897f, 44.3561f, 40.8537f, 0.707107f);
7563 path.conicTo(45.1038f, 41.5177f, 44.4398f, 42.2654f, 0.707107f);
7564 path.close();
7565 path.moveTo(42.2075f, 44.4911f);
7566 path.quadTo(41.804f, 44.8473f, 41.3862f, 45.1865f);
7567 path.conicTo(40.6098f, 45.8167f, 39.9795f, 45.0403f, 0.707107f);
7568 path.conicTo(39.3493f, 44.2639f, 40.1257f, 43.6336f, 0.707107f);
7569 path.quadTo(40.5114f, 43.3205f, 40.8838f, 42.9918f);
7570 path.conicTo(41.6335f, 42.3299f, 42.2953f, 43.0796f, 0.707107f);
7571 path.conicTo(42.9572f, 43.8292f, 42.2075f, 44.4911f, 0.707107f);
7572 path.close();
7573 path.moveTo(39.6379f, 46.488f);
7574 path.quadTo(39.2151f, 46.776f, 38.7814f, 47.0471f);
7575 path.conicTo(37.9334f, 47.5771f, 37.4034f, 46.7292f, 0.707107f);
7576 path.conicTo(36.8733f, 45.8812f, 37.7213f, 45.3511f, 0.707107f);
7577 path.quadTo(38.1217f, 45.1009f, 38.5119f, 44.835f);
7578 path.conicTo(39.3383f, 44.2721f, 39.9013f, 45.0985f, 0.707107f);
7579 path.conicTo(40.4643f, 45.925f, 39.6379f, 46.488f, 0.707107f);
7580 path.close();
7581 path.moveTo(36.9864f, 48.0722f);
7582 path.quadTo(36.5234f, 48.3127f, 36.0513f, 48.5344f);
7583 path.conicTo(35.1461f, 48.9595f, 34.7211f, 48.0543f, 0.707107f);
7584 path.conicTo(34.296f, 47.1491f, 35.2012f, 46.7241f, 0.707107f);
7585 path.quadTo(35.6371f, 46.5194f, 36.0644f, 46.2974f);
7586 path.conicTo(36.9518f, 45.8364f, 37.4128f, 46.7238f, 0.707107f);
7587 path.conicTo(37.8738f, 47.6112f, 36.9864f, 48.0722f, 0.707107f);
7588 path.close();
7589 path.moveTo(34.1153f, 49.3498f);
7590 path.quadTo(33.6206f, 49.535f, 33.1187f, 49.6999f);
7591 path.conicTo(32.1687f, 50.0122f, 31.8565f, 49.0622f, 0.707107f);
7592 path.conicTo(31.5442f, 48.1122f, 32.4942f, 47.7999f, 0.707107f);
7593 path.quadTo(32.9575f, 47.6477f, 33.4141f, 47.4767f);
7594 path.conicTo(34.3507f, 47.1261f, 34.7012f, 48.0627f, 0.707107f);
7595 path.conicTo(35.0518f, 48.9992f, 34.1153f, 49.3498f, 0.707107f);
7596 path.close();
7597 path.moveTo(31.08f, 50.2791f);
7598 path.quadTo(30.5637f, 50.4033f, 30.0427f, 50.5063f);
7599 path.conicTo(29.0617f, 50.7002f, 28.8678f, 49.7192f, 0.707107f);
7600 path.conicTo(28.6738f, 48.7382f, 29.6548f, 48.5443f, 0.707107f);
7601 path.quadTo(30.1357f, 48.4492f, 30.6122f, 48.3346f);
7602 path.conicTo(31.5845f, 48.1007f, 31.8184f, 49.073f, 0.707107f);
7603 path.conicTo(32.0522f, 50.0453f, 31.08f, 50.2791f, 0.707107f);
7604 path.close();
7605 path.moveTo(27.9769f, 50.829f);
7606 path.quadTo(27.4588f, 50.8887f, 26.9386f, 50.9276f);
7607 path.conicTo(25.9414f, 51.0022f, 25.8668f, 50.005f, 0.707107f);
7608 path.conicTo(25.7923f, 49.0078f, 26.7895f, 48.9332f, 0.707107f);
7609 path.quadTo(27.2696f, 48.8973f, 27.7479f, 48.8422f);
7610 path.conicTo(28.7413f, 48.7277f, 28.8558f, 49.7211f, 0.707107f);
7611 path.conicTo(28.9703f, 50.7145f, 27.9769f, 50.829f, 0.707107f);
7612 path.close();
7613 path.moveTo(24.8625f, 50.9996f);
7614 path.quadTo(24.3373f, 50.9969f, 23.8128f, 50.9729f);
7615 path.conicTo(22.8138f, 50.9272f, 22.8595f, 49.9283f, 0.707107f);
7616 path.conicTo(22.9051f, 48.9293f, 23.9041f, 48.975f, 0.707107f);
7617 path.quadTo(24.3884f, 48.9971f, 24.8731f, 48.9997f);
7618 path.conicTo(25.8731f, 49.005f, 25.8678f, 50.005f, 0.707107f);
7619 path.conicTo(25.8624f, 51.0049f, 24.8625f, 50.9996f, 0.707107f);
7620 path.close();
7621 path.moveTo(21.7268f, 50.7931f);
7622 path.quadTo(21.2121f, 50.7278f, 20.7005f, 50.642f);
7623 path.conicTo(19.7143f, 50.4767f, 19.8796f, 49.4905f, 0.707107f);
7624 path.conicTo(20.045f, 48.5042f, 21.0312f, 48.6696f, 0.707107f);
7625 path.quadTo(21.5036f, 48.7488f, 21.9786f, 48.8091f);
7626 path.conicTo(22.9707f, 48.9349f, 22.8448f, 49.927f, 0.707107f);
7627 path.conicTo(22.7189f, 50.919f, 21.7268f, 50.7931f, 0.707107f);
7628 path.close();
7629 path.moveTo(18.6372f, 50.2094f);
7630 path.quadTo(18.1089f, 50.0761f, 17.5865f, 49.9207f);
7631 path.conicTo(16.628f, 49.6356f, 16.9132f, 48.6771f, 0.707107f);
7632 path.conicTo(17.1983f, 47.7186f, 18.1568f, 48.0037f, 0.707107f);
7633 path.quadTo(18.639f, 48.1472f, 19.1267f, 48.2702f);
7634 path.conicTo(20.0963f, 48.515f, 19.8516f, 49.4846f, 0.707107f);
7635 path.conicTo(19.6068f, 50.4542f, 18.6372f, 50.2094f, 0.707107f);
7636 path.close();
7637 path.moveTo(15.5577f, 49.2248f);
7638 path.quadTo(15.0665f, 49.0334f, 14.5834f, 48.8222f);
7639 path.conicTo(13.6672f, 48.4215f, 14.0678f, 47.5053f, 0.707107f);
7640 path.conicTo(14.4684f, 46.589f, 15.3847f, 46.9897f, 0.707107f);
7641 path.quadTo(15.8306f, 47.1846f, 16.284f, 47.3614f);
7642 path.conicTo(17.2158f, 47.7246f, 16.8526f, 48.6563f, 0.707107f);
7643 path.conicTo(16.4894f, 49.588f, 15.5577f, 49.2248f, 0.707107f);
7644 path.close();
7645 path.moveTo(12.7231f, 47.9189f);
7646 path.quadTo(12.2765f, 47.6797f, 11.8395f, 47.4233f);
7647 path.conicTo(10.9771f, 46.9171f, 11.4833f, 46.0547f, 0.707107f);
7648 path.conicTo(11.9894f, 45.1922f, 12.8519f, 45.6984f, 0.707107f);
7649 path.quadTo(13.2552f, 45.9351f, 13.6675f, 46.156f);
7650 path.conicTo(14.549f, 46.6282f, 14.0768f, 47.5096f, 0.707107f);
7651 path.conicTo(13.6046f, 48.3911f, 12.7231f, 47.9189f, 0.707107f);
7652 path.close();
7653 path.moveTo(10.1686f, 46.3548f);
7654 path.quadTo(9.76024f, 46.0712f, 9.363f, 45.7722f);
7655 path.conicTo(8.56406f, 45.1708f, 9.16549f, 44.3718f, 0.707107f);
7656 path.conicTo(9.76691f, 43.5729f, 10.5658f, 44.1743f, 0.707107f);
7657 path.quadTo(10.9325f, 44.4504f, 11.3095f, 44.7122f);
7658 path.conicTo(12.1308f, 45.2826f, 11.5604f, 46.1039f, 0.707107f);
7659 path.conicTo(10.9899f, 46.9253f, 10.1686f, 46.3548f, 0.707107f);
7660 path.close();
7661 path.moveTo(7.78853f, 44.4876f);
7662 path.quadTo(7.39972f, 44.1442f, 7.02492f, 43.7855f);
7663 path.conicTo(6.3024f, 43.0942f, 6.99374f, 42.3717f, 0.707107f);
7664 path.conicTo(7.68509f, 41.6492f, 8.40761f, 42.3405f, 0.707107f);
7665 path.quadTo(8.7536f, 42.6715f, 9.11249f, 42.9885f);
7666 path.conicTo(9.86201f, 43.6505f, 9.20003f, 44.4f, 0.707107f);
7667 path.conicTo(8.53805f, 45.1496f, 7.78853f, 44.4876f, 0.707107f);
7668 path.close();
7669 path.moveTo(5.55855f, 42.2635f);
7670 path.quadTo(5.20148f, 41.8614f, 4.86131f, 41.4449f);
7671 path.conicTo(4.22883f, 40.6703f, 5.0034f, 40.0378f, 0.707107f);
7672 path.conicTo(5.77797f, 39.4053f, 6.41046f, 40.1799f, 0.707107f);
7673 path.quadTo(6.72443f, 40.5644f, 7.05403f, 40.9356f);
7674 path.conicTo(7.71802f, 41.6833f, 6.97028f, 42.3473f, 0.707107f);
7675 path.conicTo(6.22254f, 43.0113f, 5.55855f, 42.2635f, 0.707107f);
7676 path.close();
7677 path.moveTo(3.55261f, 39.6973f);
7678 path.quadTo(3.26341f, 39.2752f, 2.99107f, 38.8422f);
7679 path.conicTo(2.45867f, 37.9957f, 3.30517f, 37.4633f, 0.707107f);
7680 path.conicTo(4.15167f, 36.9309f, 4.68406f, 37.7774f, 0.707107f);
7681 path.quadTo(4.93548f, 38.1772f, 5.20241f, 38.5667f);
7682 path.conicTo(5.76769f, 39.3916f, 4.94279f, 39.9569f, 0.707107f);
7683 path.conicTo(4.11789f, 40.5222f, 3.55261f, 39.6973f, 0.707107f);
7684 path.close();
7685 path.moveTo(1.96145f, 37.0509f);
7686 path.quadTo(1.71975f, 36.5889f, 1.49677f, 36.1175f);
7687 path.conicTo(1.06917f, 35.2135f, 1.97315f, 34.7859f, 0.707107f);
7688 path.conicTo(2.87712f, 34.3583f, 3.30471f, 35.2623f, 0.707107f);
7689 path.quadTo(3.51053f, 35.6974f, 3.73364f, 36.1239f);
7690 path.conicTo(4.19714f, 37.01f, 3.31105f, 37.4735f, 0.707107f);
7691 path.conicTo(2.42495f, 37.937f, 1.96145f, 37.0509f, 0.707107f);
7692 path.close();
7693 path.moveTo(0.676191f, 34.1844f);
7694 path.quadTo(0.489621f, 33.6902f, 0.323275f, 33.189f);
7695 path.conicTo(0.00831527f, 32.2399f, 0.95742f, 31.9249f, 0.707107f);
7696 path.conicTo(1.90653f, 31.6099f, 2.22149f, 32.559f, 0.707107f);
7697 path.quadTo(2.37504f, 33.0218f, 2.54726f, 33.4779f);
7698 path.conicTo(2.9005f, 34.4134f, 1.96497f, 34.7666f, 0.707107f);
7699 path.conicTo(1.02943f, 35.1199f, 0.676191f, 34.1844f, 0.707107f);
7700 path.close();
7701 path.moveTo(-0.261658f, 31.1521f);
7702 path.quadTo(-0.387304f, 30.6362f, -0.491779f, 30.1156f);
7703 path.conicTo(-0.68853f, 29.1351f, 0.291923f, 28.9384f, 0.707107f);
7704 path.conicTo(1.27238f, 28.7416f, 1.46913f, 29.7221f, 0.707107f);
7705 path.quadTo(1.56557f, 30.2026f, 1.68155f, 30.6789f);
7706 path.conicTo(1.91817f, 31.6505f, 0.946565f, 31.8871f, 0.707107f);
7707 path.conicTo(-0.0250367f, 32.1237f, -0.261658f, 31.1521f, 0.707107f);
7708 path.close();
7709 path.moveTo(-0.820549f, 28.0495f);
7710 path.quadTo(-0.881733f, 27.5314f, -0.922089f, 27.0113f);
7711 path.conicTo(-0.999449f, 26.0143f, -0.00244591f, 25.9369f, 0.707107f);
7712 path.conicTo(0.994557f, 25.8596f, 1.07192f, 26.8566f, 0.707107f);
7713 path.quadTo(1.10917f, 27.3367f, 1.16565f, 27.8149f);
7714 path.conicTo(1.28293f, 28.808f, 0.289834f, 28.9253f, 0.707107f);
7715 path.conicTo(-0.703265f, 29.0426f, -0.820549f, 28.0495f, 0.707107f);
7716 path.close();
7717 path.moveTo(-0.999918f, 24.9349f);
7718 path.quadTo(-0.998605f, 24.4104f, -0.976138f, 23.8863f);
7719 path.conicTo(-0.933305f, 22.8873f, 0.0657772f, 22.9301f, 0.707107f);
7720 path.conicTo(1.06486f, 22.9729f, 1.02203f, 23.972f, 0.707107f);
7721 path.quadTo(1.00129f, 24.4557f, 1.00008f, 24.9399f);
7722 path.conicTo(0.997572f, 25.9399f, -0.0024244f, 25.9374f, 0.707107f);
7723 path.conicTo(-1.00242f, 25.9349f, -0.999918f, 24.9349f, 0.707107f);
7724 path.close();
7725 path.moveTo(-0.802212f, 21.7991f);
7726 path.quadTo(-0.738311f, 21.284f, -0.653903f, 20.7719f);
7727 path.conicTo(-0.491283f, 19.7852f, 0.495406f, 19.9478f, 0.707107f);
7728 path.conicTo(1.48209f, 20.1104f, 1.31948f, 21.0971f, 0.707107f);
7729 path.quadTo(1.24156f, 21.5698f, 1.18257f, 22.0453f);
7730 path.conicTo(1.05946f, 23.0377f, 0.0670681f, 22.9146f, 0.707107f);
7731 path.conicTo(-0.925325f, 22.7915f, -0.802212f, 21.7991f, 0.707107f);
7732 path.close();
7733 path.moveTo(-0.228066f, 18.7115f);
7734 path.quadTo(-0.096172f, 18.1824f, 0.0577899f, 17.6593f);
7735 path.conicTo(0.340124f, 16.7f, 1.29944f, 16.9823f, 0.707107f);
7736 path.conicTo(2.25876f, 17.2646f, 1.97642f, 18.2239f, 0.707107f);
7737 path.quadTo(1.8343f, 18.7068f, 1.71255f, 19.1953f);
7738 path.conicTo(1.47069f, 20.1656f, 0.50038f, 19.9237f, 0.707107f);
7739 path.conicTo(-0.46993f, 19.6819f, -0.228066f, 18.7115f, 0.707107f);
7740 path.close();
7741 path.moveTo(0.74831f, 15.6269f);
7742 path.quadTo(0.938539f, 15.1347f, 1.14857f, 14.6506f);
7743 path.conicTo(1.54662f, 13.7333f, 2.46398f, 14.1313f, 0.707107f);
7744 path.conicTo(3.38135f, 14.5294f, 2.9833f, 15.4467f, 0.707107f);
7745 path.quadTo(2.78942f, 15.8936f, 2.61382f, 16.3479f);
7746 path.conicTo(2.25331f, 17.2806f, 1.32056f, 16.9201f, 0.707107f);
7747 path.conicTo(0.387801f, 16.5596f, 0.74831f, 15.6269f, 0.707107f);
7748 path.close();
7749 path.moveTo(2.04744f, 12.7861f);
7750 path.quadTo(2.28569f, 12.3384f, 2.5412f, 11.9003f);
7751 path.conicTo(3.04504f, 11.0365f, 3.90884f, 11.5403f, 0.707107f);
7752 path.conicTo(4.77264f, 12.0442f, 4.26881f, 12.908f, 0.707107f);
7753 path.quadTo(4.03293f, 13.3123f, 3.81302f, 13.7256f);
7754 path.conicTo(3.34325f, 14.6084f, 2.46046f, 14.1386f, 0.707107f);
7755 path.conicTo(1.57767f, 13.6689f, 2.04744f, 12.7861f, 0.707107f);
7756 path.close();
7757 path.moveTo(3.60589f, 10.2253f);
7758 path.quadTo(3.88812f, 9.81661f, 4.18576f, 9.419f);
7759 path.conicTo(4.78503f, 8.61845f, 5.58558f, 9.21772f, 0.707107f);
7760 path.conicTo(6.38613f, 9.81699f, 5.78686f, 10.6175f, 0.707107f);
7761 path.quadTo(5.51211f, 10.9846f, 5.25159f, 11.3618f);
7762 path.conicTo(4.68333f, 12.1847f, 3.86048f, 11.6164f, 0.707107f);
7763 path.conicTo(3.03763f, 11.0481f, 3.60589f, 10.2253f, 0.707107f);
7764 path.close();
7765 path.moveTo(5.46482f, 7.84259f);
7766 path.quadTo(5.80682f, 7.4532f, 6.16407f, 7.07773f);
7767 path.conicTo(6.85339f, 6.35327f, 7.57785f, 7.04259f, 0.707107f);
7768 path.conicTo(8.30231f, 7.73191f, 7.61299f, 8.45636f, 0.707107f);
7769 path.quadTo(7.28322f, 8.80295f, 6.96752f, 9.16239f);
7770 path.conicTo(6.30762f, 9.91375f, 5.55627f, 9.25385f, 0.707107f);
7771 path.conicTo(4.80492f, 8.59395f, 5.46482f, 7.84259f, 0.707107f);
7772 path.close();
7773 path.moveTo(7.68062f, 5.60827f);
7774 path.quadTo(8.08142f, 5.25031f, 8.49666f, 4.90921f);
7775 path.conicTo(9.26938f, 4.27447f, 9.90412f, 5.04719f, 0.707107f);
7776 path.conicTo(10.5389f, 5.81992f, 9.76614f, 6.45466f, 0.707107f);
7777 path.quadTo(9.38285f, 6.76951f, 9.01289f, 7.09994f);
7778 path.conicTo(8.26705f, 7.76607f, 7.60092f, 7.02024f, 0.707107f);
7779 path.conicTo(6.93479f, 6.2744f, 7.68062f, 5.60827f, 0.707107f);
7780 path.close();
7781 path.moveTo(10.2392f, 3.59627f);
7782 path.quadTo(10.6626f, 3.30433f, 11.0971f, 3.02935f);
7783 path.conicTo(11.9421f, 2.49463f, 12.4768f, 3.33965f, 0.707107f);
7784 path.conicTo(13.0116f, 4.18467f, 12.1666f, 4.7194f, 0.707107f);
7785 path.quadTo(11.7654f, 4.97322f, 11.3747f, 5.24271f);
7786 path.conicTo(10.5515f, 5.81043f, 9.98373f, 4.98721f, 0.707107f);
7787 path.conicTo(9.41601f, 4.16399f, 10.2392f, 3.59627f, 0.707107f);
7788 path.close();
7789 path.moveTo(12.8847f, 1.99524f);
7790 path.quadTo(13.3459f, 1.75234f, 13.8165f, 1.52812f);
7791 path.conicTo(14.7193f, 1.09799f, 15.1494f, 2.00075f, 0.707107f);
7792 path.conicTo(15.5795f, 2.90352f, 14.6768f, 3.33365f, 0.707107f);
7793 path.quadTo(14.2424f, 3.54063f, 13.8166f, 3.76484f);
7794 path.conicTo(12.9318f, 4.23081f, 12.4658f, 3.34601f, 0.707107f);
7795 path.conicTo(11.9999f, 2.46122f, 12.8847f, 1.99524f, 0.707107f);
7796 path.close();
7797 path.moveTo(15.7467f, 0.702339f);
7798 path.quadTo(16.2402f, 0.514409f, 16.7409f, 0.346672f);
7799 path.conicTo(17.6891f, 0.029011f, 18.0067f, 0.977215f, 0.707107f);
7800 path.conicTo(18.3244f, 1.92542f, 17.3762f, 2.24308f, 0.707107f);
7801 path.quadTo(16.914f, 2.39792f, 16.4585f, 2.57139f);
7802 path.conicTo(15.524f, 2.92729f, 15.1681f, 1.99276f, 0.707107f);
7803 path.conicTo(14.8122f, 1.05824f, 15.7467f, 0.702339f, 0.707107f);
7804 path.close();
7805 path.moveTo(18.7758f, -0.24399f);
7806 path.quadTo(19.2913f, -0.371107f, 19.8116f, -0.477061f);
7807 path.conicTo(20.7915f, -0.676608f, 20.9911f, 0.303281f, 0.707107f);
7808 path.conicTo(21.1906f, 1.28317f, 20.2107f, 1.48272f, 0.707107f);
7809 path.quadTo(19.7304f, 1.58052f, 19.2546f, 1.69785f);
7810 path.conicTo(18.2836f, 1.93725f, 18.0443f, 0.966329f, 0.707107f);
7811 path.conicTo(17.8049f, -0.00459272f, 18.7758f, -0.24399f, 0.707107f);
7812 path.close();
7813 path.moveTo(21.878f, -0.811882f);
7814 path.quadTo(22.396f, -0.874528f, 22.916f, -0.916348f);
7815 path.conicTo(23.9128f, -0.996504f, 23.993f, 0.000278629f, 0.707107f);
7816 path.conicTo(24.0731f, 0.997061f, 23.0764f, 1.07722f, 0.707107f);
7817 path.quadTo(22.5963f, 1.11582f, 22.1182f, 1.17365f);
7818 path.conicTo(21.1254f, 1.29372f, 21.0053f, 0.300958f, 0.707107f);
7819 path.conicTo(20.8853f, -0.691807f, 21.878f, -0.811882f, 0.707107f);
7820 path.close();
7821 path.moveTo(24.9926f, -0.999999f);
7822 path.quadTo(25.5166f, -1.00015f, 26.0401f, -0.979188f);
7823 path.conicTo(27.0393f, -0.939179f, 26.9992f, 0.0600199f, 0.707107f);
7824 path.conicTo(26.9592f, 1.05922f, 25.96f, 1.01921f, 0.707107f);
7825 path.quadTo(25.4768f, 0.999863f, 24.9932f, 1);
7826 path.conicTo(23.9932f, 1.00029f, 23.9929f, 0.000287339f, 0.707107f);
7827 path.conicTo(23.9926f, -0.999713f, 24.9926f, -0.999999f, 0.707107f);
7828 path.close();
7829 path.moveTo(28.1286f, -0.811081f);
7830 path.quadTo(28.6441f, -0.748593f, 29.1567f, -0.665572f);
7831 path.conicTo(30.1439f, -0.505698f, 29.984f, 0.48144f, 0.707107f);
7832 path.conicTo(29.8241f, 1.46858f, 28.837f, 1.3087f, 0.707107f);
7833 path.quadTo(28.3638f, 1.23207f, 27.8879f, 1.17439f);
7834 path.conicTo(26.8952f, 1.05406f, 27.0155f, 0.0613233f, 0.707107f);
7835 path.conicTo(27.1359f, -0.931411f, 28.1286f, -0.811081f, 0.707107f);
7836 path.close();
7837 path.moveTo(31.214f, -0.246499f);
7838 path.quadTo(31.7439f, -0.116076f, 32.2679f, 0.0364622f);
7839 path.conicTo(33.228f, 0.315996f, 32.9485f, 1.27613f, 0.707107f);
7840 path.conicTo(32.6689f, 2.23627f, 31.7088f, 1.95673f, 0.707107f);
7841 path.quadTo(31.2252f, 1.81593f, 30.736f, 1.69554f);
7842 path.conicTo(29.765f, 1.45654f, 30.004f, 0.48552f, 0.707107f);
7843 path.conicTo(30.243f, -0.485499f, 31.214f, -0.246499f, 0.707107f);
7844 path.close();
7845 path.moveTo(34.3038f, 0.721629f);
7846 path.quadTo(34.797f, 0.910612f, 35.282f, 1.11946f);
7847 path.conicTo(36.2005f, 1.51493f, 35.805f, 2.43341f, 0.707107f);
7848 path.conicTo(35.4096f, 3.35189f, 34.4911f, 2.95642f, 0.707107f);
7849 path.quadTo(34.0434f, 2.76365f, 33.5881f, 2.5892f);
7850 path.conicTo(32.6543f, 2.23137f, 33.0122f, 1.29758f, 0.707107f);
7851 path.conicTo(33.37f, 0.363796f, 34.3038f, 0.721629f, 0.707107f);
7852 path.close();
7853 path.moveTo(37.1508f, 2.01396f);
7854 path.quadTo(37.5996f, 2.2512f, 38.0388f, 2.50578f);
7855 path.conicTo(38.904f, 3.00727f, 38.4025f, 3.87244f, 0.707107f);
7856 path.conicTo(37.901f, 4.7376f, 37.0358f, 4.23612f, 0.707107f);
7857 path.quadTo(36.6304f, 4.00111f, 36.2161f, 3.78211f);
7858 path.conicTo(35.332f, 3.31476f, 35.7994f, 2.43069f, 0.707107f);
7859 path.conicTo(36.2667f, 1.54661f, 37.1508f, 2.01396f, 0.707107f);
7860 path.close();
7861 path.moveTo(39.718f, 3.56681f);
7862 path.quadTo(40.1269f, 3.84765f, 40.5249f, 4.14392f);
7863 path.conicTo(41.3271f, 4.74104f, 40.73f, 5.54319f, 0.707107f);
7864 path.conicTo(40.1329f, 6.34535f, 39.3307f, 5.74823f, 0.707107f);
7865 path.quadTo(38.9634f, 5.47478f, 38.5858f, 5.21552f);
7866 path.conicTo(37.7615f, 4.64945f, 38.3275f, 3.82509f, 0.707107f);
7867 path.conicTo(38.8936f, 3.00074f, 39.718f, 3.56681f, 0.707107f);
7868 path.close();
7869 path.moveTo(42.1033f, 5.41741f);
7870 path.quadTo(42.4933f, 5.75802f, 42.8694f, 6.11388f);
7871 path.conicTo(43.5958f, 6.80115f, 42.9085f, 7.52755f, 0.707107f);
7872 path.conicTo(42.2212f, 8.25394f, 41.4948f, 7.56667f, 0.707107f);
7873 path.quadTo(41.1476f, 7.23817f, 40.7876f, 6.92375f);
7874 path.conicTo(40.0345f, 6.26593f, 40.6923f, 5.51275f, 0.707107f);
7875 path.conicTo(41.3501f, 4.75958f, 42.1033f, 5.41741f, 0.707107f);
7876 path.close();
7877 path.moveTo(44.3419f, 7.62498f);
7878 path.quadTo(44.7007f, 8.02444f, 45.0428f, 8.43835f);
7879 path.conicTo(45.6797f, 9.20922f, 44.9089f, 9.84622f, 0.707107f);
7880 path.conicTo(44.138f, 10.4832f, 43.501f, 9.71234f, 0.707107f);
7881 path.quadTo(43.1852f, 9.3302f, 42.854f, 8.96151f);
7882 path.conicTo(42.1858f, 8.21759f, 42.9297f, 7.54932f, 0.707107f);
7883 path.conicTo(43.6736f, 6.88106f, 44.3419f, 7.62498f, 0.707107f);
7884 path.close();
7885 path.moveTo(46.3599f, 10.1759f);
7886 path.quadTo(46.6546f, 10.6005f, 46.9322f, 11.0366f);
7887 path.conicTo(47.4693f, 11.8801f, 46.6257f, 12.4172f, 0.707107f);
7888 path.conicTo(45.7822f, 12.9542f, 45.2451f, 12.1107f, 0.707107f);
7889 path.quadTo(44.9889f, 11.7082f, 44.7168f, 11.3162f);
7890 path.conicTo(44.1467f, 10.4947f, 44.9682f, 9.92452f, 0.707107f);
7891 path.conicTo(45.7897f, 9.35435f, 46.3599f, 10.1759f, 0.707107f);
7892 path.close();
7893 path.moveTo(47.9708f, 12.8204f);
7894 path.quadTo(48.2149f, 13.2808f, 48.4403f, 13.7506f);
7895 path.conicTo(48.873f, 14.6521f, 47.9715f, 15.0848f, 0.707107f);
7896 path.conicTo(47.0699f, 15.5174f, 46.6372f, 14.6159f, 0.707107f);
7897 path.quadTo(46.4291f, 14.1822f, 46.2038f, 13.7573f);
7898 path.conicTo(45.7354f, 12.8738f, 46.6188f, 12.4054f, 0.707107f);
7899 path.conicTo(47.5023f, 11.9369f, 47.9708f, 12.8204f, 0.707107f);
7900 path.close();
7901 path.moveTo(49.2713f, 15.6778f);
7902 path.quadTo(49.4606f, 16.1706f, 49.6297f, 16.6708f);
7903 path.conicTo(49.9501f, 17.6181f, 49.0028f, 17.9384f, 0.707107f);
7904 path.conicTo(48.0555f, 18.2588f, 47.7351f, 17.3115f, 0.707107f);
7905 path.quadTo(47.5791f, 16.8499f, 47.4043f, 16.3949f);
7906 path.conicTo(47.0458f, 15.4614f, 47.9793f, 15.1029f, 0.707107f);
7907 path.conicTo(48.9128f, 14.7443f, 49.2713f, 15.6778f, 0.707107f);
7908 path.close();
7909 path.moveTo(50.2261f, 18.7037f);
7910 path.quadTo(50.3547f, 19.2188f, 50.4621f, 19.7388f);
7911 path.conicTo(50.6645f, 20.7182f, 49.6852f, 20.9205f, 0.707107f);
7912 path.conicTo(48.7059f, 21.1229f, 48.5035f, 20.1436f, 0.707107f);
7913 path.quadTo(48.4043f, 19.6636f, 48.2856f, 19.1881f);
7914 path.conicTo(48.0435f, 18.2178f, 49.0137f, 17.9757f, 0.707107f);
7915 path.conicTo(49.984f, 17.7335f, 50.2261f, 18.7037f, 0.707107f);
7916 path.close();
7917 path.moveTo(50.803f, 21.8055f);
7918 path.quadTo(50.8671f, 22.3234f, 50.9104f, 22.8434f);
7919 path.conicTo(50.9934f, 23.8399f, 49.9968f, 23.9229f, 0.707107f);
7920 path.conicTo(49.0002f, 24.0058f, 48.9173f, 23.0093f, 0.707107f);
7921 path.quadTo(48.8773f, 22.5293f, 48.8182f, 22.0513f);
7922 path.conicTo(48.6953f, 21.0588f, 49.6877f, 20.936f, 0.707107f);
7923 path.conicTo(50.6801f, 20.8131f, 50.803f, 21.8055f, 0.707107f);
7924 path.close();
7925 path.moveTo(50.9999f, 24.9202f);
7926 path.quadTo(51.0015f, 25.4434f, 50.982f, 25.9664f);
7927 path.conicTo(50.9449f, 26.9657f, 49.9456f, 26.9286f, 0.707107f);
7928 path.conicTo(48.9463f, 26.8914f, 48.9834f, 25.8921f, 0.707107f);
7929 path.quadTo(49.0014f, 25.4094f, 48.9999f, 24.9263f);
7930 path.conicTo(48.9968f, 23.9263f, 49.9968f, 23.9232f, 0.707107f);
7931 path.conicTo(50.9968f, 23.9202f, 50.9999f, 24.9202f, 0.707107f);
7932 path.close();
7933 path.moveTo(50.8198f, 28.0562f);
7934 path.quadTo(50.7587f, 28.5721f, 50.677f, 29.0852f);
7935 path.conicTo(50.5199f, 30.0728f, 49.5323f, 29.9157f, 0.707107f);
7936 path.conicTo(48.5448f, 29.7586f, 48.7019f, 28.771f, 0.707107f);
7937 path.quadTo(48.7772f, 28.2974f, 48.8336f, 27.8211f);
7938 path.conicTo(48.9512f, 26.8281f, 49.9442f, 26.9456f, 0.707107f);
7939 path.conicTo(50.9373f, 27.0632f, 50.8198f, 28.0562f, 0.707107f);
7940 path.close();
7941 path.moveTo(50.2647f, 31.1395f);
7942 path.quadTo(50.1358f, 31.6701f, 49.9847f, 32.1949f);
7943 path.conicTo(49.7079f, 33.1558f, 48.747f, 32.8791f, 0.707107f);
7944 path.conicTo(47.786f, 32.6024f, 48.0628f, 31.6414f, 0.707107f);
7945 path.quadTo(48.2022f, 31.1571f, 48.3213f, 30.6672f);
7946 path.conicTo(48.5574f, 29.6955f, 49.5291f, 29.9317f, 0.707107f);
7947 path.conicTo(50.5009f, 30.1678f, 50.2647f, 31.1395f, 0.707107f);
7948 path.close();
7949 path.moveTo(49.3049f, 34.2343f);
7950 path.quadTo(49.1171f, 34.7285f, 48.9095f, 35.2145f);
7951 path.conicTo(48.5166f, 36.1341f, 47.597f, 35.7412f, 0.707107f);
7952 path.conicTo(46.6774f, 35.3483f, 47.0703f, 34.4288f, 0.707107f);
7953 path.quadTo(47.262f, 33.9801f, 47.4353f, 33.524f);
7954 path.conicTo(47.7904f, 32.5892f, 48.7252f, 32.9444f, 0.707107f);
7955 path.conicTo(49.66f, 33.2995f, 49.3049f, 34.2343f, 0.707107f);
7956 path.close();
7957 path.moveTo(48.0194f, 37.0875f);
7958 path.quadTo(47.7831f, 37.5374f, 47.5295f, 37.9777f);
7959 path.conicTo(47.0304f, 38.8443f, 46.1638f, 38.3451f, 0.707107f);
7960 path.conicTo(45.2973f, 37.846f, 45.7965f, 36.9795f, 0.707107f);
7961 path.quadTo(46.0306f, 36.5729f, 46.2487f, 36.1577f);
7962 path.conicTo(46.7136f, 35.2723f, 47.5989f, 35.7372f, 0.707107f);
7963 path.conicTo(48.4843f, 36.2021f, 48.0194f, 37.0875f, 0.707107f);
7964 path.close();
7965 path.moveTo(46.4721f, 39.6612f);
7966 path.quadTo(46.1926f, 40.0705f, 45.8977f, 40.4688f);
7967 path.conicTo(45.3028f, 41.2726f, 44.499f, 40.6776f, 0.707107f);
7968 path.conicTo(43.6953f, 40.0827f, 44.2902f, 39.2789f, 0.707107f);
7969 path.quadTo(44.5624f, 38.9112f, 44.8204f, 38.5334f);
7970 path.conicTo(45.3843f, 37.7075f, 46.2101f, 38.2714f, 0.707107f);
7971 path.conicTo(47.036f, 38.8353f, 46.4721f, 39.6612f, 0.707107f);
7972 path.close();
7973 path.moveTo(44.6298f, 42.0491f);
7974 path.quadTo(44.2906f, 42.4396f, 43.9361f, 42.8164f);
7975 path.conicTo(43.2509f, 43.5447f, 42.5226f, 42.8595f, 0.707107f);
7976 path.conicTo(41.7942f, 42.1742f, 42.4795f, 41.4459f, 0.707107f);
7977 path.quadTo(42.8067f, 41.0981f, 43.1198f, 40.7376f);
7978 path.conicTo(43.7756f, 39.9826f, 44.5306f, 40.6383f, 0.707107f);
7979 path.conicTo(45.2856f, 41.2941f, 44.6298f, 42.0491f, 0.707107f);
7980 path.close();
7981 path.moveTo(42.4305f, 44.2919f);
7982 path.quadTo(42.0324f, 44.6516f, 41.6198f, 44.9946f);
7983 path.conicTo(40.8507f, 45.6338f, 40.2115f, 44.8648f, 0.707107f);
7984 path.conicTo(39.5723f, 44.0958f, 40.3413f, 43.4566f, 0.707107f);
7985 path.quadTo(40.7222f, 43.1399f, 41.0897f, 42.8079f);
7986 path.conicTo(41.8317f, 42.1375f, 42.5021f, 42.8795f, 0.707107f);
7987 path.conicTo(43.1725f, 43.6215f, 42.4305f, 44.2919f, 0.707107f);
7988 path.close();
7989 path.moveTo(39.8873f, 46.3159f);
7990 path.quadTo(39.4613f, 46.6134f, 39.0238f, 46.8936f);
7991 path.conicTo(38.1818f, 47.433f, 37.6424f, 46.5909f, 0.707107f);
7992 path.conicTo(37.103f, 45.7489f, 37.9451f, 45.2095f, 0.707107f);
7993 path.quadTo(38.3489f, 44.9508f, 38.7421f, 44.6763f);
7994 path.conicTo(39.5619f, 44.1037f, 40.1345f, 44.9235f, 0.707107f);
7995 path.conicTo(40.7071f, 45.7434f, 39.8873f, 46.3159f, 0.707107f);
7996 path.close();
7997 path.moveTo(37.2437f, 47.9367f);
7998 path.quadTo(36.7842f, 48.182f, 36.3153f, 48.4086f);
7999 path.conicTo(35.415f, 48.8439f, 34.9797f, 47.9435f, 0.707107f);
8000 path.conicTo(34.5445f, 47.0432f, 35.4449f, 46.608f, 0.707107f);
8001 path.quadTo(35.8778f, 46.3987f, 36.3019f, 46.1723f);
8002 path.conicTo(37.1841f, 45.7014f, 37.655f, 46.5836f, 0.707107f);
8003 path.conicTo(38.1259f, 47.4658f, 37.2437f, 47.9367f, 0.707107f);
8004 path.close();
8005 path.moveTo(34.3909f, 49.2448f);
8006 path.quadTo(33.8988f, 49.4354f, 33.3992f, 49.606f);
8007 path.conicTo(32.4528f, 49.929f, 32.1298f, 48.9826f, 0.707107f);
8008 path.conicTo(31.8068f, 48.0362f, 32.7532f, 47.7132f, 0.707107f);
8009 path.quadTo(33.2142f, 47.5558f, 33.6685f, 47.3798f);
8010 path.conicTo(34.601f, 47.0186f, 34.9622f, 47.9511f, 0.707107f);
8011 path.conicTo(35.3234f, 48.8836f, 34.3909f, 49.2448f, 0.707107f);
8012 path.close();
8013 path.moveTo(31.3682f, 50.208f);
8014 path.quadTo(30.8535f, 50.3381f, 30.3338f, 50.447f);
8015 path.conicTo(29.3551f, 50.6521f, 29.15f, 49.6734f, 0.707107f);
8016 path.conicTo(28.9448f, 48.6947f, 29.9236f, 48.4895f, 0.707107f);
8017 path.quadTo(30.4033f, 48.389f, 30.8784f, 48.269f);
8018 path.conicTo(31.8479f, 48.024f, 32.0929f, 48.9936f, 0.707107f);
8019 path.conicTo(32.3378f, 49.9631f, 31.3682f, 50.208f, 0.707107f);
8020 path.close();
8021 path.moveTo(28.2669f, 50.7939f);
8022 path.quadTo(27.7491f, 50.8595f, 27.2292f, 50.9043f);
8023 path.conicTo(26.2329f, 50.99f, 26.1472f, 49.9937f, 0.707107f);
8024 path.conicTo(26.0615f, 48.9973f, 27.0578f, 48.9116f, 0.707107f);
8025 path.quadTo(27.5378f, 48.8703f, 28.0156f, 48.8098f);
8026 path.conicTo(29.0077f, 48.6841f, 29.1334f, 49.6762f, 0.707107f);
8027 path.conicTo(29.259f, 50.6683f, 28.2669f, 50.7939f, 0.707107f);
8028 path.close();
8029 path.moveTo(25.1523f, 50.9996f);
8030 path.quadTo(24.6297f, 51.0026f, 24.1072f, 50.9847f);
8031 path.conicTo(23.1078f, 50.9503f, 23.1422f, 49.9509f, 0.707107f);
8032 path.conicTo(23.1765f, 48.9515f, 24.1759f, 48.9858f, 0.707107f);
8033 path.quadTo(24.658f, 49.0024f, 25.1406f, 48.9996f);
8034 path.conicTo(26.1406f, 48.9937f, 26.1464f, 49.9937f, 0.707107f);
8035 path.conicTo(26.1523f, 50.9937f, 25.1523f, 50.9996f, 0.707107f);
8036 path.close();
8037 path.moveTo(22.0162f, 50.8282f);
8038 path.quadTo(21.4999f, 50.7686f, 20.9863f, 50.6883f);
8039 path.conicTo(19.9983f, 50.5339f, 20.1527f, 49.5459f, 0.707107f);
8040 path.conicTo(20.307f, 48.5579f, 21.295f, 48.7123f, 0.707107f);
8041 path.quadTo(21.7691f, 48.7864f, 22.2457f, 48.8414f);
8042 path.conicTo(23.2391f, 48.9562f, 23.1243f, 49.9496f, 0.707107f);
8043 path.conicTo(23.0096f, 50.943f, 22.0162f, 50.8282f, 0.707107f);
8044 path.close();
8045 path.moveTo(18.9351f, 50.2827f);
8046 path.quadTo(18.4037f, 50.1553f, 17.8782f, 50.0056f);
8047 path.conicTo(16.9164f, 49.7317f, 17.1904f, 48.7699f, 0.707107f);
8048 path.conicTo(17.4643f, 47.8082f, 18.426f, 48.0821f, 0.707107f);
8049 path.quadTo(18.9112f, 48.2203f, 19.4016f, 48.3379f);
8050 path.conicTo(20.374f, 48.5712f, 20.1408f, 49.5436f, 0.707107f);
8051 path.conicTo(19.9075f, 50.516f, 18.9351f, 50.2827f, 0.707107f);
8052 path.close();
8053 path.moveTo(15.8352f, 49.3312f);
8054 path.quadTo(15.3403f, 49.1448f, 14.8531f, 48.9383f);
8055 path.conicTo(13.9324f, 48.548f, 14.3227f, 47.6273f, 0.707107f);
8056 path.conicTo(14.713f, 46.7066f, 15.6337f, 47.0969f, 0.707107f);
8057 path.quadTo(16.0832f, 47.2874f, 16.5402f, 47.4596f);
8058 path.conicTo(17.476f, 47.812f, 17.1235f, 48.7479f, 0.707107f);
8059 path.conicTo(16.771f, 49.6837f, 15.8352f, 49.3312f, 0.707107f);
8060 path.close();
8061 path.moveTo(12.9759f, 48.0526f);
8062 path.quadTo(12.5249f, 47.8173f, 12.0835f, 47.5647f);
8063 path.conicTo(11.2156f, 47.0679f, 11.7124f, 46.2f, 0.707107f);
8064 path.conicTo(12.2092f, 45.3321f, 13.0771f, 45.8289f, 0.707107f);
8065 path.quadTo(13.4846f, 46.0622f, 13.9009f, 46.2793f);
8066 path.conicTo(14.7875f, 46.7418f, 14.325f, 47.6284f, 0.707107f);
8067 path.conicTo(13.8626f, 48.5151f, 12.9759f, 48.0526f, 0.707107f);
8068 path.close();
8069 path.moveTo(10.3957f, 46.5108f);
8070 path.quadTo(9.9861f, 46.2327f, 9.58733f, 45.9392f);
8071 path.conicTo(8.78198f, 45.3464f, 9.37478f, 44.541f, 0.707107f);
8072 path.conicTo(9.96757f, 43.7357f, 10.7729f, 44.3285f, 0.707107f);
8073 path.quadTo(11.141f, 44.5994f, 11.5191f, 44.8561f);
8074 path.conicTo(12.3464f, 45.4178f, 11.7847f, 46.2451f, 0.707107f);
8075 path.conicTo(11.223f, 47.0725f, 10.3957f, 46.5108f, 0.707107f);
8076 path.close();
8077 path.moveTo(8.00525f, 44.6769f);
8078 path.quadTo(7.6141f, 44.339f, 7.23672f, 43.9859f);
8079 path.conicTo(6.50649f, 43.3027f, 7.18969f, 42.5725f, 0.707107f);
8080 path.conicTo(7.87289f, 41.8423f, 8.60312f, 42.5255f, 0.707107f);
8081 path.quadTo(8.95149f, 42.8514f, 9.31254f, 43.1632f);
8082 path.conicTo(10.0693f, 43.8169f, 9.4157f, 44.5737f, 0.707107f);
8083 path.conicTo(8.76206f, 45.3305f, 8.00525f, 44.6769f, 0.707107f);
8084 path.close();
8085 path.moveTo(5.75818f, 42.4858f);
8086 path.quadTo(5.39763f, 42.089f, 5.05371f, 41.6777f);
8087 path.conicTo(4.41226f, 40.9105f, 5.17942f, 40.2691f, 0.707107f);
8088 path.conicTo(5.94658f, 39.6276f, 6.58804f, 40.3948f, 0.707107f);
8089 path.quadTo(6.90548f, 40.7744f, 7.23832f, 41.1407f);
8090 path.conicTo(7.91085f, 41.8808f, 7.17078f, 42.5533f, 0.707107f);
8091 path.conicTo(6.43071f, 43.2258f, 5.75818f, 42.4858f, 0.707107f);
8092 path.close();
8093 path.moveTo(3.72821f, 39.9503f);
8094 path.quadTo(3.42794f, 39.523f, 3.1451f, 39.0842f);
8095 path.conicTo(2.6034f, 38.2436f, 3.44397f, 37.7019f, 0.707107f);
8096 path.conicTo(4.28454f, 37.1602f, 4.82624f, 38.0008f, 0.707107f);
8097 path.quadTo(5.08734f, 38.4059f, 5.3645f, 38.8003f);
8098 path.conicTo(5.93951f, 39.6184f, 5.12137f, 40.1934f, 0.707107f);
8099 path.conicTo(4.30322f, 40.7684f, 3.72821f, 39.9503f, 0.707107f);
8100 path.close();
8101 path.moveTo(2.09762f, 37.3078f);
8102 path.quadTo(1.85114f, 36.8491f, 1.62324f, 36.381f);
8103 path.conicTo(1.18551f, 35.4819f, 2.08461f, 35.0442f, 0.707107f);
8104 path.conicTo(2.98372f, 34.6064f, 3.42145f, 35.5055f, 0.707107f);
8105 path.quadTo(3.63184f, 35.9377f, 3.85934f, 36.361f);
8106 path.conicTo(4.33272f, 37.2419f, 3.45185f, 37.7153f, 0.707107f);
8107 path.conicTo(2.57099f, 38.1886f, 2.09762f, 37.3078f, 0.707107f);
8108 path.close();
8109 path.moveTo(0.781912f, 34.4596f);
8110 path.quadTo(0.589924f, 33.9681f, 0.418029f, 33.4692f);
8111 path.conicTo(0.0922952f, 32.5237f, 1.03776f, 32.198f, 0.707107f);
8112 path.conicTo(1.98322f, 31.8722f, 2.30895f, 32.8177f, 0.707107f);
8113 path.quadTo(2.46761f, 33.2782f, 2.64484f, 33.7319f);
8114 path.conicTo(3.00867f, 34.6634f, 2.07721f, 35.0272f, 0.707107f);
8115 path.conicTo(1.14575f, 35.3911f, 0.781912f, 34.4596f, 0.707107f);
8116 path.close();
8117 path.moveTo(-0.189761f, 31.4402f);
8118 path.quadTo(-0.321263f, 30.9258f, -0.431662f, 30.4065f);
8119 path.conicTo(-0.639608f, 29.4284f, 0.338532f, 29.2205f, 0.707107f);
8120 path.conicTo(1.31667f, 29.0125f, 1.52462f, 29.9906f, 0.707107f);
8121 path.quadTo(1.62653f, 30.47f, 1.74791f, 30.9448f);
8122 path.conicTo(1.99561f, 31.9136f, 1.02677f, 32.1613f, 0.707107f);
8123 path.conicTo(0.0579369f, 32.409f, -0.189761f, 31.4402f, 0.707107f);
8124 path.close();
8125 path.moveTo(-0.784658f, 28.3394f);
8126 path.quadTo(-0.851693f, 27.8218f, -0.897902f, 27.3019f);
8127 path.conicTo(-0.986437f, 26.3058f, 0.00963629f, 26.2173f, 0.707107f);
8128 path.conicTo(1.00571f, 26.1288f, 1.09424f, 27.1248f, 0.707107f);
8129 path.quadTo(1.1369f, 27.6047f, 1.19878f, 28.0825f);
8130 path.conicTo(1.32721f, 29.0742f, 0.335496f, 29.2027f, 0.707107f);
8131 path.conicTo(-0.656222f, 29.3311f, -0.784658f, 28.3394f, 0.707107f);
8132 path.close();
8133 path.moveTo(-0.999031f, 25.2248f);
8134 path.quadTo(-1.00354f, 24.7027f, -0.987098f, 24.1809f);
8135 path.conicTo(-0.955596f, 23.1814f, 0.0439078f, 23.2129f, 0.707107f);
8136 path.conicTo(1.04341f, 23.2444f, 1.01191f, 24.2439f, 0.707107f);
8137 path.quadTo(0.996728f, 24.7256f, 1.00089f, 25.2075f);
8138 path.conicTo(1.00954f, 26.2075f, 0.00957754f, 26.2161f, 0.707107f);
8139 path.conicTo(-0.990385f, 26.2248f, -0.999031f, 25.2248f, 0.707107f);
8140 path.close();
8141 path.moveTo(-0.836492f, 22.0887f);
8142 path.quadTo(-0.778263f, 21.5719f, -0.699419f, 21.0579f);
8143 path.conicTo(-0.5478f, 20.0695f, 0.440639f, 20.2211f, 0.707107f);
8144 path.conicTo(1.42908f, 20.3727f, 1.27746f, 21.3612f, 0.707107f);
8145 path.quadTo(1.20468f, 21.8356f, 1.15093f, 22.3126f);
8146 path.conicTo(1.03896f, 23.3063f, 0.0452449f, 23.1944f, 0.707107f);
8147 path.conicTo(-0.948466f, 23.0824f, -0.836492f, 22.0887f, 0.707107f);
8148 path.close();
8149 path.moveTo(-0.300548f, 19.0098f);
8150 path.quadTo(-0.174573f, 18.4777f, -0.0263361f, 17.9514f);
8151 path.conicTo(0.244762f, 16.9889f, 1.20731f, 17.26f, 0.707107f);
8152 path.conicTo(2.16987f, 17.5311f, 1.89877f, 18.4936f, 0.707107f);
8153 path.quadTo(1.76193f, 18.9794f, 1.64565f, 19.4706f);
8154 path.conicTo(1.41526f, 20.4437f, 0.442159f, 20.2133f, 0.707107f);
8155 path.conicTo(-0.530939f, 19.9829f, -0.300548f, 19.0098f, 0.707107f);
8156 path.close();
8157 path.moveTo(0.642658f, 15.9049f);
8158 path.quadTo(0.827861f, 15.409f, 1.0331f, 14.9209f);
8159 path.conicTo(1.42076f, 13.9991f, 2.34256f, 14.3868f, 0.707107f);
8160 path.conicTo(3.26437f, 14.7744f, 2.87671f, 15.6962f, 0.707107f);
8161 path.quadTo(2.68726f, 16.1467f, 2.5163f, 16.6046f);
8162 path.conicTo(2.16648f, 17.5414f, 1.22967f, 17.1916f, 0.707107f);
8163 path.conicTo(0.292846f, 16.8418f, 0.642658f, 15.9049f, 0.707107f);
8164 path.close();
8165 path.moveTo(1.91434f, 13.0395f);
8166 path.quadTo(2.14856f, 12.5875f, 2.40031f, 12.1449f);
8167 path.conicTo(2.89473f, 11.2757f, 3.76395f, 11.7701f, 0.707107f);
8168 path.conicTo(4.63317f, 12.2645f, 4.13875f, 13.1337f, 0.707107f);
8169 path.quadTo(3.90637f, 13.5423f, 3.69016f, 13.9596f);
8170 path.conicTo(3.23014f, 14.8475f, 2.34223f, 14.3875f, 0.707107f);
8171 path.conicTo(1.45432f, 13.9275f, 1.91434f, 13.0395f, 0.707107f);
8172 path.close();
8173 path.moveTo(3.45073f, 10.4525f);
8174 path.quadTo(3.72744f, 10.0426f, 4.01954f, 9.64356f);
8175 path.conicTo(4.61017f, 8.83661f, 5.41711f, 9.42725f, 0.707107f);
8176 path.conicTo(6.22405f, 10.0179f, 5.63342f, 10.8248f, 0.707107f);
8177 path.quadTo(5.36379f, 11.1932f, 5.10836f, 11.5716f);
8178 path.conicTo(4.54884f, 12.4004f, 3.72003f, 11.8409f, 0.707107f);
8179 path.conicTo(2.89121f, 11.2813f, 3.45073f, 10.4525f, 0.707107f);
8180 path.close();
8181 path.moveTo(5.2763f, 8.05964f);
8182 path.quadTo(5.61273f, 7.66793f, 5.96445f, 7.2899f);
8183 path.conicTo(6.6456f, 6.55776f, 7.37774f, 7.23892f, 0.707107f);
8184 path.conicTo(8.10988f, 7.92008f, 7.42872f, 8.65221f, 0.707107f);
8185 path.quadTo(7.10407f, 9.00116f, 6.79351f, 9.36274f);
8186 path.conicTo(6.14196f, 10.1213f, 5.38336f, 9.46979f, 0.707107f);
8187 path.conicTo(4.62475f, 8.81824f, 5.2763f, 8.05964f, 0.707107f);
8188 path.close();
8189 path.moveTo(7.45913f, 5.80839f);
8190 path.quadTo(7.85457f, 5.44696f, 8.26455f, 5.10214f);
8191 path.conicTo(9.02985f, 4.45847f, 9.67352f, 5.22377f, 0.707107f);
8192 path.conicTo(10.3172f, 5.98907f, 9.5519f, 6.63274f, 0.707107f);
8193 path.quadTo(9.17345f, 6.95105f, 8.80843f, 7.28467f);
8194 path.conicTo(8.07029f, 7.95931f, 7.39564f, 7.22117f, 0.707107f);
8195 path.conicTo(6.72099f, 6.48303f, 7.45913f, 5.80839f, 0.707107f);
8196 path.close();
8197 path.moveTo(9.98688f, 3.77251f);
8198 path.quadTo(10.4153f, 3.46948f, 10.8557f, 3.18397f);
8199 path.conicTo(11.6948f, 2.63996f, 12.2388f, 3.47904f, 0.707107f);
8200 path.conicTo(12.7828f, 4.31812f, 11.9437f, 4.86213f, 0.707107f);
8201 path.quadTo(11.5373f, 5.12566f, 11.1417f, 5.40539f);
8202 path.conicTo(10.3253f, 5.98282f, 9.74787f, 5.16638f, 0.707107f);
8203 path.conicTo(9.17044f, 4.34994f, 9.98688f, 3.77251f, 0.707107f);
8204 path.close();
8205 path.moveTo(12.6283f, 2.13208f);
8206 path.quadTo(13.0861f, 1.88442f, 13.5534f, 1.65529f);
8207 path.conicTo(14.4513f, 1.21504f, 14.8915f, 2.11291f, 0.707107f);
8208 path.conicTo(15.3318f, 3.01078f, 14.4339f, 3.45104f, 0.707107f);
8209 path.quadTo(14.0025f, 3.66255f, 13.58f, 3.89115f);
8210 path.conicTo(12.7005f, 4.36698f, 12.2246f, 3.48744f, 0.707107f);
8211 path.conicTo(11.7488f, 2.60791f, 12.6283f, 2.13208f, 0.707107f);
8212 path.close();
8213 path.moveTo(15.4718f, 0.808815f);
8214 path.quadTo(15.9627f, 0.615476f, 16.461f, 0.442208f);
8215 path.conicTo(17.4055f, 0.113784f, 17.7339f, 1.05831f, 0.707107f);
8216 path.conicTo(18.0624f, 2.00284f, 17.1178f, 2.33127f, 0.707107f);
8217 path.quadTo(16.6578f, 2.49121f, 16.2047f, 2.66968f);
8218 path.conicTo(15.2743f, 3.03614f, 14.9078f, 2.10571f, 0.707107f);
8219 path.conicTo(14.5414f, 1.17528f, 15.4718f, 0.808815f, 0.707107f);
8220 path.close();
8221 path.moveTo(18.4879f, -0.171272f);
8222 path.quadTo(19.0019f, -0.304236f, 19.5208f, -0.416111f);
8223 path.conicTo(20.4984f, -0.62685f, 20.7091f, 0.350692f, 0.707107f);
8224 path.conicTo(20.9198f, 1.32823f, 19.9423f, 1.53897f, 0.707107f);
8225 path.quadTo(19.4633f, 1.64224f, 18.9889f, 1.76498f);
8226 path.conicTo(18.0207f, 2.01544f, 17.7703f, 1.04732f, 0.707107f);
8227 path.conicTo(17.5198f, 0.0791926f, 18.4879f, -0.171272f, 0.707107f);
8228 path.close();
8229 path.moveTo(21.5882f, -0.77517f);
8230 path.quadTo(22.1056f, -0.843665f, 22.6254f, -0.891339f);
8231 path.conicTo(23.6212f, -0.982672f, 23.7126f, 0.0131486f, 0.707107f);
8232 path.conicTo(23.8039f, 1.00897f, 22.8081f, 1.1003f, 0.707107f);
8233 path.quadTo(22.3283f, 1.14431f, 21.8506f, 1.20754f);
8234 path.conicTo(20.8592f, 1.33876f, 20.728f, 0.347405f, 0.707107f);
8235 path.conicTo(20.5968f, -0.643948f, 21.5882f, -0.77517f, 0.707107f);
8236 path.close();
8237 path.moveTo(24.7026f, -0.998301f);
8238 path.quadTo(25.2241f, -1.00426f, 25.7453f, -0.989316f);
8239 path.conicTo(26.7449f, -0.960651f, 26.7162f, 0.0389383f, 0.707107f);
8240 path.conicTo(26.6876f, 1.03853f, 25.688f, 1.00986f, 0.707107f);
8241 path.quadTo(25.2068f, 0.996064f, 24.7255f, 1.00157f);
8242 path.conicTo(23.7256f, 1.013f, 23.7141f, 0.0130688f, 0.707107f);
8243 path.conicTo(23.7027f, -0.986866f, 24.7026f, -0.998301f, 0.707107f);
8244 path.close();
8245 path.moveTo(27.8388f, -0.844563f);
8246 path.quadTo(28.3559f, -0.787759f, 28.8704f, -0.710314f);
8247 path.conicTo(29.8592f, -0.561454f, 29.7104f, 0.427404f, 0.707107f);
8248 path.conicTo(29.5615f, 1.41626f, 28.5726f, 1.2674f, 0.707107f);
8249 path.quadTo(28.0978f, 1.19591f, 27.6204f, 1.14348f);
8250 path.conicTo(26.6264f, 1.0343f, 26.7356f, 0.0402742f, 0.707107f);
8251 path.conicTo(26.8447f, -0.953747f, 27.8388f, -0.844563f, 0.707107f);
8252 path.close();
8253 path.moveTo(30.9153f, -0.318153f);
8254 path.quadTo(31.4481f, -0.193671f, 31.9752f, -0.046875f);
8255 path.conicTo(32.9386f, 0.221405f, 32.6703f, 1.18475f, 0.707107f);
8256 path.conicTo(32.402f, 2.14809f, 31.4387f, 1.87981f, 0.707107f);
8257 path.quadTo(30.9521f, 1.74431f, 30.4603f, 1.6294f);
8258 path.conicTo(29.4865f, 1.40189f, 29.714f, 0.428111f, 0.707107f);
8259 path.conicTo(29.9416f, -0.545664f, 30.9153f, -0.318153f, 0.707107f);
8260 path.close();
8261 path.moveTo(34.0252f, 0.616677f);
8262 path.quadTo(34.5221f, 0.800609f, 35.0111f, 1.00465f);
8263 path.conicTo(35.934f, 1.3897f, 35.549f, 2.31259f, 0.707107f);
8264 path.conicTo(35.1639f, 3.23549f, 34.241f, 2.85044f, 0.707107f);
8265 path.quadTo(33.7896f, 2.66211f, 33.3309f, 2.49232f);
8266 path.conicTo(32.3931f, 2.1452f, 32.7402f, 1.20738f, 0.707107f);
8267 path.conicTo(33.0873f, 0.269559f, 34.0252f, 0.616677f, 0.707107f);
8268 path.close();
8269 path.moveTo(36.8967f, 1.88141f);
8270 path.quadTo(37.3499f, 2.11462f, 37.7936f, 2.3654f);
8271 path.conicTo(38.6641f, 2.85746f, 38.1721f, 3.72802f, 0.707107f);
8272 path.conicTo(37.68f, 4.59858f, 36.8094f, 4.10652f, 0.707107f);
8273 path.quadTo(36.3999f, 3.87504f, 35.9815f, 3.65976f);
8274 path.conicTo(35.0924f, 3.2022f, 35.5499f, 2.31302f, 0.707107f);
8275 path.conicTo(36.0075f, 1.42384f, 36.8967f, 1.88141f, 0.707107f);
8276 path.close();
8277 path.moveTo(39.4914f, 3.413f);
8278 path.lineTo(39.5381f, 3.44439f);
8279 path.quadTo(39.9244f, 3.70494f, 40.3002f, 3.97845f);
8280 path.conicTo(41.1087f, 4.56692f, 40.5202f, 5.37544f, 0.707107f);
8281 path.conicTo(39.9317f, 6.18396f, 39.1232f, 5.59549f, 0.707107f);
8282 path.quadTo(38.7763f, 5.34298f, 38.4215f, 5.10371f);
8283 path.lineTo(38.3749f, 5.07232f);
8284 path.conicTo(37.5452f, 4.51406f, 38.1035f, 3.68439f, 0.707107f);
8285 path.conicTo(38.6618f, 2.85473f, 39.4914f, 3.413f, 0.707107f);
8286 path.close();
8287 path.moveTo(41.8859f, 5.22965f);
8288 path.quadTo(42.2782f, 5.56471f, 42.6568f, 5.91499f);
8289 path.conicTo(43.3908f, 6.5941f, 42.7117f, 7.32814f, 0.707107f);
8290 path.conicTo(42.0326f, 8.06218f, 41.2986f, 7.38308f, 0.707107f);
8291 path.quadTo(40.949f, 7.05968f, 40.587f, 6.75043f);
8292 path.conicTo(39.8266f, 6.10097f, 40.476f, 5.34058f, 0.707107f);
8293 path.conicTo(41.1255f, 4.58018f, 41.8859f, 5.22965f, 0.707107f);
8294 path.close();
8295 path.moveTo(44.1413f, 7.40421f);
8296 path.quadTo(44.5035f, 7.79829f, 44.8493f, 8.20695f);
8297 path.conicTo(45.4952f, 8.97038f, 44.7317f, 9.61627f, 0.707107f);
8298 path.conicTo(43.9683f, 10.2622f, 43.3224f, 9.49874f, 0.707107f);
8299 path.quadTo(43.0033f, 9.1215f, 42.6689f, 8.75773f);
8300 path.conicTo(41.9921f, 8.02152f, 42.7283f, 7.34476f, 0.707107f);
8301 path.conicTo(43.4645f, 6.668f, 44.1413f, 7.40421f, 0.707107f);
8302 path.close();
8303 path.moveTo(46.183f, 9.9242f);
8304 path.quadTo(46.4888f, 10.3539f, 46.777f, 10.7957f);
8305 path.conicTo(47.3233f, 11.6332f, 46.4857f, 12.1796f, 0.707107f);
8306 path.conicTo(45.6482f, 12.7259f, 45.1018f, 11.8883f, 0.707107f);
8307 path.quadTo(44.8358f, 11.4805f, 44.5535f, 11.0839f);
8308 path.conicTo(43.9737f, 10.2691f, 44.7884f, 9.6893f, 0.707107f);
8309 path.conicTo(45.6032f, 9.10947f, 46.183f, 9.9242f, 0.707107f);
8310 path.close();
8311 path.moveTo(47.8333f, 12.5645f);
8312 path.quadTo(48.0821f, 13.0214f, 48.3125f, 13.4879f);
8313 path.conicTo(48.7552f, 14.3845f, 47.8586f, 14.8273f, 0.707107f);
8314 path.conicTo(46.962f, 15.2701f, 46.5192f, 14.3734f, 0.707107f);
8315 path.quadTo(46.3065f, 13.9428f, 46.0769f, 13.5211f);
8316 path.conicTo(45.5986f, 12.6429f, 46.4768f, 12.1646f, 0.707107f);
8317 path.conicTo(47.355f, 11.6863f, 47.8333f, 12.5645f, 0.707107f);
8318 path.close();
8319 path.moveTo(49.1641f, 15.4033f);
8320 path.quadTo(49.3588f, 15.8935f, 49.5334f, 16.3912f);
8321 path.conicTo(49.8645f, 17.3348f, 48.9209f, 17.6659f, 0.707107f);
8322 path.conicTo(47.9773f, 17.997f, 47.6462f, 17.0534f, 0.707107f);
8323 path.quadTo(47.485f, 16.5939f, 47.3053f, 16.1415f);
8324 path.conicTo(46.9362f, 15.2121f, 47.8656f, 14.843f, 0.707107f);
8325 path.conicTo(48.795f, 14.4739f, 49.1641f, 15.4033f, 0.707107f);
8326 path.close();
8327 path.moveTo(50.1526f, 18.4161f);
8328 path.quadTo(50.287f, 18.9296f, 50.4003f, 19.4482f);
8329 path.conicTo(50.6139f, 20.4252f, 49.6369f, 20.6387f, 0.707107f);
8330 path.conicTo(48.66f, 20.8522f, 48.4465f, 19.8753f, 0.707107f);
8331 path.quadTo(48.3419f, 19.3966f, 48.2178f, 18.9225f);
8332 path.conicTo(47.9645f, 17.9551f, 48.9319f, 17.7019f, 0.707107f);
8333 path.conicTo(49.8993f, 17.4487f, 50.1526f, 18.4161f, 0.707107f);
8334 path.close();
8335 path.moveTo(50.7655f, 21.5157f);
8336 path.quadTo(50.8354f, 22.033f, 50.8846f, 22.5528f);
8337 path.conicTo(50.9787f, 23.5483f, 49.9831f, 23.6425f, 0.707107f);
8338 path.conicTo(48.9876f, 23.7366f, 48.8935f, 22.741f, 0.707107f);
8339 path.quadTo(48.8481f, 22.2613f, 48.7835f, 21.7837f);
8340 path.conicTo(48.6495f, 20.7928f, 49.6405f, 20.6587f, 0.707107f);
8341 path.conicTo(50.6315f, 20.5247f, 50.7655f, 21.5157f, 0.707107f);
8342 path.close();
8343 path.moveTo(50.9974f, 24.6301f);
8344 path.quadTo(51.0048f, 25.1509f, 50.9913f, 25.6715f);
8345 path.conicTo(50.9655f, 26.6712f, 49.9658f, 26.6454f, 0.707107f);
8346 path.conicTo(48.9662f, 26.6196f, 48.992f, 25.6199f, 0.707107f);
8347 path.quadTo(49.0044f, 25.1393f, 48.9976f, 24.6585f);
8348 path.conicTo(48.9834f, 23.6586f, 49.9833f, 23.6444f, 0.707107f);
8349 path.conicTo(50.9832f, 23.6302f, 50.9974f, 24.6301f, 0.707107f);
8350 path.close();
8351 path.moveTo(50.8524f, 27.7662f);
8352 path.quadTo(50.7971f, 28.2837f, 50.721f, 28.7986f);
8353 path.conicTo(50.5749f, 29.7879f, 49.5856f, 29.6418f, 0.707107f);
8354 path.conicTo(48.5963f, 29.4957f, 48.7425f, 28.5064f, 0.707107f);
8355 path.quadTo(48.8127f, 28.0311f, 48.8638f, 27.5534f);
8356 path.conicTo(48.9702f, 26.5591f, 49.9645f, 26.6655f, 0.707107f);
8357 path.conicTo(50.9588f, 26.7718f, 50.8524f, 27.7662f, 0.707107f);
8358 path.close();
8359 path.moveTo(50.3355f, 30.8404f);
8360 path.quadTo(50.2125f, 31.3739f, 50.0672f, 31.9018f);
8361 path.conicTo(49.8018f, 32.8659f, 48.8376f, 32.6005f, 0.707107f);
8362 path.conicTo(47.8735f, 32.335f, 48.139f, 31.3709f, 0.707107f);
8363 path.quadTo(48.2731f, 30.8836f, 48.3867f, 30.3912f);
8364 path.conicTo(48.6113f, 29.4167f, 49.5857f, 29.6413f, 0.707107f);
8365 path.conicTo(50.5602f, 29.866f, 50.3355f, 30.8404f, 0.707107f);
8366 path.close();
8367 path.moveTo(49.4091f, 33.9552f);
8368 path.quadTo(49.2264f, 34.4531f, 49.0236f, 34.9431f);
8369 path.conicTo(48.6412f, 35.8671f, 47.7172f, 35.4846f, 0.707107f);
8370 path.conicTo(46.7932f, 35.1022f, 47.1757f, 34.1782f, 0.707107f);
8371 path.quadTo(47.3629f, 33.7259f, 47.5315f, 33.2663f);
8372 path.conicTo(47.8759f, 32.3275f, 48.8147f, 32.672f, 0.707107f);
8373 path.conicTo(49.7535f, 33.0164f, 49.4091f, 33.9552f, 0.707107f);
8374 path.close();
8375 path.moveTo(48.1514f, 36.8328f);
8376 path.quadTo(47.9191f, 37.2871f, 47.6694f, 37.7318f);
8377 path.conicTo(47.1797f, 38.6038f, 46.3078f, 38.1141f, 0.707107f);
8378 path.conicTo(45.4359f, 37.6244f, 45.9256f, 36.7525f, 0.707107f);
8379 path.quadTo(46.1562f, 36.3418f, 46.3705f, 35.9226f);
8380 path.conicTo(46.8256f, 35.0321f, 47.716f, 35.4872f, 0.707107f);
8381 path.conicTo(48.6065f, 35.9423f, 48.1514f, 36.8328f, 0.707107f);
8382 path.close();
8383 path.moveTo(46.6245f, 39.4354f);
8384 path.lineTo(46.5563f, 39.537f);
8385 path.quadTo(46.3146f, 39.8955f, 46.0624f, 40.2438f);
8386 path.conicTo(45.4761f, 41.0539f, 44.666f, 40.4676f, 0.707107f);
8387 path.conicTo(43.8559f, 39.8813f, 44.4422f, 39.0712f, 0.707107f);
8388 path.quadTo(44.6749f, 38.7498f, 44.8955f, 38.4226f);
8389 path.lineTo(44.9637f, 38.3211f);
8390 path.conicTo(45.5209f, 37.4907f, 46.3513f, 38.0479f, 0.707107f);
8391 path.conicTo(47.1817f, 38.605f, 46.6245f, 39.4354f, 0.707107f);
8392 path.close();
8393 path.moveTo(44.8168f, 41.8314f);
8394 path.quadTo(44.4832f, 42.2241f, 44.1342f, 42.6034f);
8395 path.conicTo(43.4572f, 43.3394f, 42.7212f, 42.6623f, 0.707107f);
8396 path.conicTo(41.9853f, 41.9853f, 42.6623f, 41.2494f, 0.707107f);
8397 path.quadTo(42.9845f, 40.8992f, 43.2924f, 40.5366f);
8398 path.conicTo(43.9398f, 39.7745f, 44.702f, 40.4218f, 0.707107f);
8399 path.conicTo(45.4642f, 41.0692f, 44.8168f, 41.8314f, 0.707107f);
8400 path.close();
8401 path.moveTo(42.6505f, 44.0908f);
8402 path.quadTo(42.2577f, 44.454f, 41.8504f, 44.8006f);
8403 path.conicTo(41.0888f, 45.4487f, 40.4408f, 44.6871f, 0.707107f);
8404 path.conicTo(39.7927f, 43.9256f, 40.5542f, 43.2775f, 0.707107f);
8405 path.quadTo(40.9302f, 42.9575f, 41.2928f, 42.6223f);
8406 path.conicTo(42.027f, 41.9434f, 42.7059f, 42.6777f, 0.707107f);
8407 path.conicTo(43.3848f, 43.412f, 42.6505f, 44.0908f, 0.707107f);
8408 path.close();
8409 path.moveTo(40.1383f, 46.1384f);
8410 path.quadTo(39.7073f, 46.4471f, 39.2641f, 46.7378f);
8411 path.conicTo(38.4281f, 47.2865f, 37.8795f, 46.4504f, 0.707107f);
8412 path.conicTo(37.3308f, 45.6143f, 38.1669f, 45.0657f, 0.707107f);
8413 path.quadTo(38.576f, 44.7972f, 38.9738f, 44.5124f);
8414 path.conicTo(39.7868f, 43.9301f, 40.369f, 44.7432f, 0.707107f);
8415 path.conicTo(40.9513f, 45.5562f, 40.1383f, 46.1384f, 0.707107f);
8416 path.close();
8417 path.moveTo(37.4991f, 47.7985f);
8418 path.quadTo(37.0431f, 48.0485f, 36.5775f, 48.2801f);
8419 path.conicTo(35.6821f, 48.7254f, 35.2368f, 47.83f, 0.707107f);
8420 path.conicTo(34.7915f, 46.9346f, 35.6869f, 46.4893f, 0.707107f);
8421 path.quadTo(36.1167f, 46.2755f, 36.5376f, 46.0448f);
8422 path.conicTo(37.4145f, 45.5641f, 37.8952f, 46.4409f, 0.707107f);
8423 path.conicTo(38.376f, 47.3178f, 37.4991f, 47.7985f, 0.707107f);
8424 path.close();
8425 path.moveTo(34.6651f, 49.1368f);
8426 path.quadTo(34.1756f, 49.3328f, 33.6785f, 49.5089f);
8427 path.conicTo(32.7358f, 49.8427f, 32.402f, 48.9f, 0.707107f);
8428 path.conicTo(32.0682f, 47.9574f, 33.0109f, 47.6236f, 0.707107f);
8429 path.quadTo(33.4697f, 47.4611f, 33.9216f, 47.2801f);
8430 path.conicTo(34.85f, 46.9084f, 35.2217f, 47.8368f, 0.707107f);
8431 path.conicTo(35.5934f, 48.7651f, 34.6651f, 49.1368f, 0.707107f);
8432 path.close();
8433 path.moveTo(31.6557f, 50.1337f);
8434 path.quadTo(31.1425f, 50.2696f, 30.6243f, 50.3844f);
8435 path.conicTo(29.648f, 50.6007f, 29.4317f, 49.6244f, 0.707107f);
8436 path.conicTo(29.2153f, 48.6481f, 30.1917f, 48.4317f, 0.707107f);
8437 path.quadTo(30.6701f, 48.3257f, 31.1437f, 48.2003f);
8438 path.conicTo(32.1104f, 47.9443f, 32.3664f, 48.911f, 0.707107f);
8439 path.conicTo(32.6223f, 49.8777f, 31.6557f, 50.1337f, 0.707107f);
8440 path.close();
8441 path.moveTo(28.5567f, 50.7556f);
8442 path.quadTo(28.0395f, 50.827f, 27.5198f, 50.8776f);
8443 path.conicTo(26.5245f, 50.9745f, 26.4276f, 49.9792f, 0.707107f);
8444 path.conicTo(26.3307f, 48.9839f, 27.326f, 48.887f, 0.707107f);
8445 path.quadTo(27.8056f, 48.8403f, 28.2831f, 48.7744f);
8446 path.conicTo(29.2737f, 48.6376f, 29.4105f, 49.6282f, 0.707107f);
8447 path.conicTo(29.5473f, 50.6188f, 28.5567f, 50.7556f, 0.707107f);
8448 path.close();
8449 path.moveTo(25.4424f, 50.9962f);
8450 path.quadTo(24.9222f, 51.0051f, 24.4022f, 50.9931f);
8451 path.conicTo(23.4025f, 50.9701f, 23.4255f, 49.9704f, 0.707107f);
8452 path.conicTo(23.4485f, 48.9707f, 24.4482f, 48.9937f, 0.707107f);
8453 path.quadTo(24.9283f, 49.0047f, 25.4084f, 48.9965f);
8454 path.conicTo(26.4083f, 48.9795f, 26.4253f, 49.9794f, 0.707107f);
8455 path.conicTo(26.4423f, 50.9792f, 25.4424f, 50.9962f, 0.707107f);
8456 path.close();
8457 path.moveTo(22.3065f, 50.8601f);
8458 path.quadTo(21.7885f, 50.8062f, 21.2732f, 50.7315f);
8459 path.conicTo(20.2835f, 50.5882f, 20.4268f, 49.5985f, 0.707107f);
8460 path.conicTo(20.5702f, 48.6088f, 21.5599f, 48.7522f, 0.707107f);
8461 path.quadTo(22.0355f, 48.8211f, 22.5136f, 48.8709f);
8462 path.conicTo(23.5083f, 48.9745f, 23.4047f, 49.9691f, 0.707107f);
8463 path.conicTo(23.3011f, 50.9637f, 22.3065f, 50.8601f, 0.707107f);
8464 path.close();
8465 path.moveTo(19.2346f, 50.3527f);
8466 path.quadTo(18.7003f, 50.2312f, 18.1717f, 50.0873f);
8467 path.conicTo(17.2068f, 49.8247f, 17.4694f, 48.8598f, 0.707107f);
8468 path.conicTo(17.732f, 47.8949f, 18.6969f, 48.1575f, 0.707107f);
8469 path.quadTo(19.185f, 48.2904f, 19.6781f, 48.4025f);
8470 path.conicTo(20.6532f, 48.6243f, 20.4314f, 49.5994f, 0.707107f);
8471 path.conicTo(20.2097f, 50.5745f, 19.2346f, 50.3527f, 0.707107f);
8472 path.close();
8473 path.moveTo(16.1149f, 49.4347f);
8474 path.quadTo(15.6161f, 49.2533f, 15.1251f, 49.0517f);
8475 path.conicTo(14.2f, 48.6719f, 14.5798f, 47.7469f, 0.707107f);
8476 path.conicTo(14.9596f, 46.8218f, 15.8847f, 47.2016f, 0.707107f);
8477 path.quadTo(16.3379f, 47.3877f, 16.7984f, 47.5551f);
8478 path.conicTo(17.7382f, 47.8969f, 17.3964f, 48.8366f, 0.707107f);
8479 path.conicTo(17.0547f, 49.7764f, 16.1149f, 49.4347f, 0.707107f);
8480 path.close();
8481 path.moveTo(13.2313f, 48.184f);
8482 path.quadTo(12.776f, 47.9529f, 12.33f, 47.704f);
8483 path.conicTo(11.4568f, 47.2167f, 11.9441f, 46.3434f, 0.707107f);
8484 path.conicTo(12.4314f, 45.4702f, 13.3046f, 45.9575f, 0.707107f);
8485 path.quadTo(13.7162f, 46.1872f, 14.1365f, 46.4006f);
8486 path.conicTo(15.0282f, 46.8532f, 14.5756f, 47.7449f, 0.707107f);
8487 path.conicTo(14.123f, 48.6366f, 13.2313f, 48.184f, 0.707107f);
8488 path.close();
8489 path.moveTo(10.6208f, 46.6619f);
8490 path.lineTo(10.4641f, 46.5571f);
8491 path.quadTo(10.1333f, 46.334f, 9.81253f, 46.1031f);
8492 path.conicTo(9.00087f, 45.519f, 9.585f, 44.7073f, 0.707107f);
8493 path.conicTo(10.1691f, 43.8957f, 10.9808f, 44.4798f, 0.707107f);
8494 path.quadTo(11.2769f, 44.6929f, 11.5763f, 44.8948f);
8495 path.lineTo(11.7329f, 44.9996f);
8496 path.conicTo(12.564f, 45.5557f, 12.008f, 46.3868f, 0.707107f);
8497 path.conicTo(11.4519f, 47.2179f, 10.6208f, 46.6619f, 0.707107f);
8498 path.close();
8499 path.moveTo(8.22326f, 44.8631f);
8500 path.quadTo(7.82986f, 44.5308f, 7.44999f, 44.1833f);
8501 path.conicTo(6.71217f, 43.5082f, 7.38718f, 42.7704f, 0.707107f);
8502 path.conicTo(8.06219f, 42.0326f, 8.8f, 42.7076f, 0.707107f);
8503 path.quadTo(9.15066f, 43.0284f, 9.51375f, 43.3351f);
8504 path.conicTo(10.2777f, 43.9804f, 9.63248f, 44.7443f, 0.707107f);
8505 path.conicTo(8.98724f, 45.5083f, 8.22326f, 44.8631f, 0.707107f);
8506 path.close();
8507 path.moveTo(5.95972f, 42.705f);
8508 path.quadTo(5.59577f, 42.3136f, 5.24823f, 41.9076f);
8509 path.conicTo(4.59793f, 41.148f, 5.3576f, 40.4977f, 0.707107f);
8510 path.conicTo(6.11728f, 39.8473f, 6.76758f, 40.607f, 0.707107f);
8511 path.quadTo(7.08843f, 40.9818f, 7.42436f, 41.3431f);
8512 path.conicTo(8.10532f, 42.0754f, 7.373f, 42.7564f, 0.707107f);
8513 path.conicTo(6.64068f, 43.4373f, 5.95972f, 42.705f, 0.707107f);
8514 path.close();
8515 path.moveTo(3.90635f, 40.2006f);
8516 path.quadTo(3.59492f, 39.7684f, 3.30147f, 39.3239f);
8517 path.conicTo(2.75055f, 38.4893f, 3.58511f, 37.9384f, 0.707107f);
8518 path.conicTo(4.41967f, 37.3875f, 4.97059f, 38.222f, 0.707107f);
8519 path.quadTo(5.24148f, 38.6324f, 5.52894f, 39.0313f);
8520 path.conicTo(6.11358f, 39.8426f, 5.30228f, 40.4272f, 0.707107f);
8521 path.conicTo(4.49099f, 41.0119f, 3.90635f, 40.2006f, 0.707107f);
8522 path.close();
8523 path.moveTo(2.23643f, 37.5626f);
8524 path.quadTo(1.98525f, 37.1075f, 1.75248f, 36.6427f);
8525 path.conicTo(1.30469f, 35.7486f, 2.19883f, 35.3008f, 0.707107f);
8526 path.conicTo(3.09296f, 34.853f, 3.54076f, 35.7471f, 0.707107f);
8527 path.quadTo(3.75563f, 36.1762f, 3.98747f, 36.5963f);
8528 path.conicTo(4.47065f, 37.4718f, 3.59513f, 37.955f, 0.707107f);
8529 path.conicTo(2.71961f, 38.4382f, 2.23643f, 37.5626f, 0.707107f);
8530 path.close();
8531 path.moveTo(0.890647f, 34.7334f);
8532 path.quadTo(0.69328f, 34.2445f, 0.515902f, 33.7481f);
8533 path.conicTo(0.179435f, 32.8064f, 1.12113f, 32.4699f, 0.707107f);
8534 path.conicTo(2.06282f, 32.1335f, 2.39929f, 33.0752f, 0.707107f);
8535 path.quadTo(2.56303f, 33.5334f, 2.74521f, 33.9847f);
8536 path.conicTo(3.11957f, 34.912f, 2.19229f, 35.2863f, 0.707107f);
8537 path.conicTo(1.26501f, 35.6607f, 0.890647f, 34.7334f, 0.707107f);
8538 path.close();
8539 path.moveTo(-0.114587f, 31.7274f);
8540 path.quadTo(-0.251922f, 31.2147f, -0.368218f, 30.6968f);
8541 path.conicTo(-0.587327f, 29.7211f, 0.388373f, 29.502f, 0.707107f);
8542 path.conicTo(1.36407f, 29.2829f, 1.58318f, 30.2586f, 0.707107f);
8543 path.quadTo(1.69053f, 30.7366f, 1.8173f, 31.2099f);
8544 path.conicTo(2.07605f, 32.1758f, 1.1101f, 32.4346f, 0.707107f);
8545 path.conicTo(0.144159f, 32.6933f, -0.114587f, 31.7274f, 0.707107f);
8546 path.close();
8547 path.moveTo(-0.745485f, 28.6291f);
8548 path.quadTo(-0.818367f, 28.112f, -0.870432f, 27.5925f);
8549 path.conicTo(-0.970142f, 26.5974f, 0.0248742f, 26.4977f, 0.707107f);
8550 path.conicTo(1.01989f, 26.398f, 1.1196f, 27.393f, 0.707107f);
8551 path.quadTo(1.16766f, 27.8726f, 1.23494f, 28.3499f);
8552 path.conicTo(1.37452f, 29.3401f, 0.384305f, 29.4797f, 0.707107f);
8553 path.conicTo(-0.605905f, 29.6193f, -0.745485f, 28.6291f, 0.707107f);
8554 path.close();
8555 path.moveTo(-0.994901f, 25.515f);
8556 path.quadTo(-1.00519f, 24.9955f, -0.994722f, 24.4761f);
8557 path.conicTo(-0.97457f, 23.4763f, 0.0252273f, 23.4964f, 0.707107f);
8558 path.conicTo(1.02502f, 23.5166f, 1.00487f, 24.5164f, 0.707107f);
8559 path.quadTo(0.995207f, 24.9959f, 1.00471f, 25.4754f);
8560 path.conicTo(1.02451f, 26.4752f, 0.0247103f, 26.495f, 0.707107f);
8561 path.conicTo(-0.975093f, 26.5148f, -0.994901f, 25.515f, 0.707107f);
8562 path.close();
8563 path.moveTo(-0.867571f, 22.3792f);
8564 path.quadTo(-0.81506f, 21.8609f, -0.741825f, 21.3451f);
8565 path.conicTo(-0.60125f, 20.355f, 0.38882f, 20.4956f, 0.707107f);
8566 path.conicTo(1.37889f, 20.6361f, 1.23831f, 21.6262f, 0.707107f);
8567 path.quadTo(1.17071f, 22.1023f, 1.12224f, 22.5807f);
8568 path.conicTo(1.02144f, 23.5757f, 0.026537f, 23.4749f, 0.707107f);
8569 path.conicTo(-0.96837f, 23.3741f, -0.867571f, 22.3792f, 0.707107f);
8570 path.close();
8571 path.moveTo(-0.369678f, 19.3097f);
8572 path.quadTo(-0.249693f, 18.7748f, -0.107265f, 18.2453f);
8573 path.conicTo(0.152529f, 17.2797f, 1.11819f, 17.5395f, 0.707107f);
8574 path.conicTo(2.08386f, 17.7993f, 1.82406f, 18.7649f, 0.707107f);
8575 path.quadTo(1.69259f, 19.2536f, 1.58184f, 19.7474f);
8576 path.conicTo(1.36298f, 20.7232f, 0.387221f, 20.5043f, 0.707107f);
8577 path.conicTo(-0.588536f, 20.2855f, -0.369678f, 19.3097f, 0.707107f);
8578 path.close();
8579 path.moveTo(0.539863f, 16.1851f);
8580 path.quadTo(0.719962f, 15.6854f, 0.920307f, 15.1934f);
8581 path.conicTo(1.29748f, 14.2673f, 2.22362f, 14.6445f, 0.707107f);
8582 path.conicTo(3.14976f, 15.0216f, 2.7726f, 15.9478f, 0.707107f);
8583 path.quadTo(2.58765f, 16.4019f, 2.42141f, 16.8632f);
8584 path.conicTo(2.08237f, 17.804f, 1.1416f, 17.4649f, 0.707107f);
8585 path.conicTo(0.200823f, 17.1259f, 0.539863f, 16.1851f, 0.707107f);
8586 path.close();
8587 path.moveTo(1.78353f, 13.2955f);
8588 path.quadTo(2.01364f, 12.8391f, 2.26151f, 12.392f);
8589 path.conicTo(2.74643f, 11.5175f, 3.62099f, 12.0024f, 0.707107f);
8590 path.conicTo(4.49555f, 12.4873f, 4.01063f, 13.3618f, 0.707107f);
8591 path.quadTo(3.78183f, 13.7745f, 3.56941f, 14.1958f);
8592 path.conicTo(3.11923f, 15.0888f, 2.22629f, 14.6386f, 0.707107f);
8593 path.conicTo(1.33336f, 14.1884f, 1.78353f, 13.2955f, 0.707107f);
8594 path.close();
8595 path.moveTo(3.30083f, 10.6771f);
8596 path.lineTo(3.44218f, 10.4652f);
8597 path.quadTo(3.6466f, 10.1621f, 3.85641f, 9.86895f);
8598 path.conicTo(4.43837f, 9.05574f, 5.25159f, 9.6377f, 0.707107f);
8599 path.conicTo(6.0648f, 10.2197f, 5.48284f, 11.0329f, 0.707107f);
8600 path.quadTo(5.28917f, 11.3035f, 5.10592f, 11.5752f);
8601 path.lineTo(4.96457f, 11.787f);
8602 path.conicTo(4.4096f, 12.6189f, 3.57773f, 12.0639f, 0.707107f);
8603 path.conicTo(2.74586f, 11.509f, 3.30083f, 10.6771f, 0.707107f);
8604 path.close();
8605 path.moveTo(5.0909f, 8.27793f);
8606 path.quadTo(5.42174f, 7.88403f, 5.76791f, 7.50353f);
8607 path.conicTo(6.44085f, 6.76383f, 7.18054f, 7.43678f, 0.707107f);
8608 path.conicTo(7.92024f, 8.10972f, 7.24729f, 8.84942f, 0.707107f);
8609 path.quadTo(6.92775f, 9.20065f, 6.62237f, 9.56424f);
8610 path.conicTo(5.97921f, 10.33f, 5.21348f, 9.68682f, 0.707107f);
8611 path.conicTo(4.44774f, 9.04367f, 5.0909f, 8.27793f, 0.707107f);
8612 path.close();
8613 path.moveTo(7.24064f, 6.0104f);
8614 path.quadTo(7.63069f, 5.64561f, 8.03537f, 5.29717f);
8615 path.conicTo(8.79318f, 4.64469f, 9.44566f, 5.40249f, 0.707107f);
8616 path.conicTo(10.0981f, 6.16029f, 9.34034f, 6.81278f, 0.707107f);
8617 path.quadTo(8.96678f, 7.13442f, 8.60675f, 7.47113f);
8618 path.conicTo(7.87638f, 8.15419f, 7.19332f, 7.42382f, 0.707107f);
8619 path.conicTo(6.51027f, 6.69345f, 7.24064f, 6.0104f, 0.707107f);
8620 path.close();
8621 path.moveTo(9.73726f, 3.95128f);
8622 path.quadTo(10.1706f, 3.63704f, 10.6165f, 3.34092f);
8623 path.conicTo(11.4496f, 2.78771f, 12.0028f, 3.62075f, 0.707107f);
8624 path.conicTo(12.556f, 4.4538f, 11.7229f, 5.007f, 0.707107f);
8625 path.quadTo(11.3113f, 5.28035f, 10.9113f, 5.57041f);
8626 path.conicTo(10.1018f, 6.15744f, 9.51472f, 5.34787f, 0.707107f);
8627 path.conicTo(8.92769f, 4.53831f, 9.73726f, 3.95128f, 0.707107f);
8628 path.close();
8629 path.moveTo(12.374f, 2.27153f);
8630 path.quadTo(12.8282f, 2.01921f, 13.2921f, 1.78522f);
8631 path.conicTo(14.185f, 1.33492f, 14.6353f, 2.22779f, 0.707107f);
8632 path.conicTo(15.0856f, 3.12067f, 14.1927f, 3.57097f, 0.707107f);
8633 path.quadTo(13.7645f, 3.78696f, 13.3452f, 4.01988f);
8634 path.conicTo(12.471f, 4.5055f, 11.9854f, 3.63132f, 0.707107f);
8635 path.conicTo(11.4998f, 2.75715f, 12.374f, 2.27153f, 0.707107f);
8636 path.close();
8637 path.moveTo(15.1984f, 0.918296f);
8638 path.quadTo(15.6866f, 0.719602f, 16.1824f, 0.540851f);
8639 path.conicTo(17.1231f, 0.20171f, 17.4623f, 1.14245f, 0.707107f);
8640 path.conicTo(17.8014f, 2.08318f, 16.8607f, 2.42232f, 0.707107f);
8641 path.quadTo(16.403f, 2.58733f, 15.9524f, 2.77074f);
8642 path.conicTo(15.0261f, 3.14772f, 14.6492f, 2.2215f, 0.707107f);
8643 path.conicTo(14.2722f, 1.29528f, 15.1984f, 0.918296f, 0.707107f);
8644 path.close();
8645 path.moveTo(18.201f, -0.0952874f);
8646 path.quadTo(18.7132f, -0.234075f, 19.2308f, -0.351842f);
8647 path.conicTo(20.2058f, -0.573734f, 20.4277f, 0.401338f, 0.707107f);
8648 path.conicTo(20.6496f, 1.37641f, 19.6745f, 1.5983f, 0.707107f);
8649 path.quadTo(19.1968f, 1.70701f, 18.724f, 1.83512f);
8650 path.conicTo(17.7588f, 2.09662f, 17.4973f, 1.13142f, 0.707107f);
8651 path.conicTo(17.2358f, 0.166216f, 18.201f, -0.0952874f, 0.707107f);
8652 path.close();
8653 path.moveTo(21.2986f, -0.73518f);
8654 path.quadTo(21.8155f, -0.809526f, 22.3349f, -0.863052f);
8655 path.conicTo(23.3297f, -0.965552f, 23.4322f, 0.029181f, 0.707107f);
8656 path.conicTo(23.5347f, 1.02391f, 22.5399f, 1.12641f, 0.707107f);
8657 path.quadTo(22.0604f, 1.17582f, 21.5833f, 1.24445f);
8658 path.conicTo(20.5935f, 1.38681f, 20.4511f, 0.397f, 0.707107f);
8659 path.conicTo(20.3088f, -0.592814f, 21.2986f, -0.73518f, 0.707107f);
8660 path.close();
8661 path.moveTo(24.4124f, -0.993361f);
8662 path.quadTo(24.9312f, -1.00509f, 25.4501f, -0.996107f);
8663 path.conicTo(26.4499f, -0.978799f, 26.4326f, 0.0210512f, 0.707107f);
8664 path.conicTo(26.4153f, 1.0209f, 25.4155f, 1.00359f, 0.707107f);
8665 path.quadTo(24.9365f, 0.995302f, 24.4576f, 1.00613f);
8666 path.conicTo(23.4578f, 1.02873f, 23.4352f, 0.0289853f, 0.707107f);
8667 path.conicTo(23.4126f, -0.970759f, 24.4124f, -0.993361f, 0.707107f);
8668 path.close();
8669 path.moveTo(27.5481f, -0.87484f);
8670 path.quadTo(28.0668f, -0.823762f, 28.583f, -0.75194f);
8671 path.conicTo(29.5734f, -0.614138f, 29.4356f, 0.376322f, 0.707107f);
8672 path.conicTo(29.2978f, 1.36678f, 28.3074f, 1.22898f, 0.707107f);
8673 path.quadTo(27.8309f, 1.16268f, 27.3521f, 1.11553f);
8674 path.conicTo(26.3569f, 1.01753f, 26.4549f, 0.0223428f, 0.707107f);
8675 path.conicTo(26.5529f, -0.972843f, 27.5481f, -0.87484f, 0.707107f);
8676 path.close();
8677 path.moveTo(30.6151f, -0.386432f);
8678 path.quadTo(31.1507f, -0.267954f, 31.6809f, -0.126991f);
8679 path.conicTo(32.6473f, 0.129965f, 32.3904f, 1.09639f, 0.707107f);
8680 path.conicTo(32.1334f, 2.06281f, 31.167f, 1.80585f, 0.707107f);
8681 path.quadTo(30.6776f, 1.67574f, 30.1832f, 1.56637f);
8682 path.conicTo(29.2068f, 1.35041f, 29.4227f, 0.374005f, 0.707107f);
8683 path.conicTo(29.6387f, -0.602396f, 30.6151f, -0.386432f, 0.707107f);
8684 path.close();
8685 path.moveTo(33.7445f, 0.514616f);
8686 path.quadTo(34.2452f, 0.693421f, 34.7381f, 0.892536f);
8687 path.conicTo(35.6653f, 1.26708f, 35.2908f, 2.19429f, 0.707107f);
8688 path.conicTo(34.9162f, 3.1215f, 33.989f, 2.74696f, 0.707107f);
8689 path.quadTo(33.534f, 2.56316f, 33.0718f, 2.3981f);
8690 path.conicTo(32.1301f, 2.06177f, 32.4664f, 1.12003f, 0.707107f);
8691 path.conicTo(32.8027f, 0.178285f, 33.7445f, 0.514616f, 0.707107f);
8692 path.close();
8693 path.moveTo(36.6402f, 1.7512f);
8694 path.quadTo(37.0977f, 1.98026f, 37.5458f, 2.22715f);
8695 path.conicTo(38.4217f, 2.70968f, 37.9392f, 3.58556f, 0.707107f);
8696 path.conicTo(37.4566f, 4.46144f, 36.5808f, 3.97891f, 0.707107f);
8697 path.quadTo(36.1671f, 3.75102f, 35.7448f, 3.53956f);
8698 path.conicTo(34.8506f, 3.09185f, 35.2983f, 2.19767f, 0.707107f);
8699 path.conicTo(35.746f, 1.30349f, 36.6402f, 1.7512f, 0.707107f);
8700 path.close();
8701 path.moveTo(39.2611f, 3.26012f);
8702 path.quadTo(39.4005f, 3.35159f, 39.539f, 3.44501f);
8703 path.quadTo(39.8091f, 3.62717f, 40.0746f, 3.81611f);
8704 path.conicTo(40.8893f, 4.3959f, 40.3096f, 5.21067f, 0.707107f);
8705 path.conicTo(39.7298f, 6.02543f, 38.915f, 5.44564f, 0.707107f);
8706 path.quadTo(38.67f, 5.2713f, 38.4206f, 5.10309f);
8707 path.quadTo(38.293f, 5.017f, 38.164f, 4.9324f);
8708 path.conicTo(37.3279f, 4.38388f, 37.8764f, 3.54775f, 0.707107f);
8709 path.conicTo(38.4249f, 2.71161f, 39.2611f, 3.26012f, 0.707107f);
8710 path.close();
8711 path.moveTo(41.6673f, 5.04503f);
8712 path.quadTo(42.0618f, 5.37449f, 42.4428f, 5.71927f);
8713 path.conicTo(43.1844f, 6.39015f, 42.5135f, 7.13171f, 0.707107f);
8714 path.conicTo(41.8426f, 7.87327f, 41.1011f, 7.20239f, 0.707107f);
8715 path.quadTo(40.7493f, 6.88414f, 40.3852f, 6.58004f);
8716 path.conicTo(39.6177f, 5.93899f, 40.2588f, 5.17149f, 0.707107f);
8717 path.conicTo(40.8998f, 4.40399f, 41.6673f, 5.04503f, 0.707107f);
8718 path.close();
8719 path.moveTo(43.9388f, 7.1865f);
8720 path.quadTo(44.3044f, 7.57519f, 44.6538f, 7.97856f);
8721 path.conicTo(45.3084f, 8.73448f, 44.5525f, 9.38914f, 0.707107f);
8722 path.conicTo(43.7966f, 10.0438f, 43.1419f, 9.28789f, 0.707107f);
8723 path.quadTo(42.8195f, 8.91555f, 42.482f, 8.55677f);
8724 path.conicTo(41.7969f, 7.82836f, 42.5253f, 7.14322f, 0.707107f);
8725 path.conicTo(43.2537f, 6.45808f, 43.9388f, 7.1865f, 0.707107f);
8726 path.close();
8727 path.moveTo(46.0036f, 9.6753f);
8728 path.quadTo(46.3207f, 10.1098f, 46.6195f, 10.5571f);
8729 path.conicTo(47.175f, 11.3886f, 46.3435f, 11.9441f, 0.707107f);
8730 path.conicTo(45.5119f, 12.4996f, 44.9564f, 11.6681f, 0.707107f);
8731 path.quadTo(44.6806f, 11.2552f, 44.388f, 10.8541f);
8732 path.conicTo(43.7986f, 10.0463f, 44.6064f, 9.45688f, 0.707107f);
8733 path.conicTo(45.4142f, 8.86747f, 46.0036f, 9.6753f, 0.707107f);
8734 path.close();
8735 path.moveTo(47.6932f, 12.3107f);
8736 path.quadTo(47.9467f, 12.764f, 48.1819f, 13.2271f);
8737 path.conicTo(48.6347f, 14.1187f, 47.7431f, 14.5715f, 0.707107f);
8738 path.conicTo(46.8514f, 15.0243f, 46.3986f, 14.1327f, 0.707107f);
8739 path.quadTo(46.1816f, 13.7053f, 45.9476f, 13.2868f);
8740 path.conicTo(45.4595f, 12.414f, 46.3323f, 11.9259f, 0.707107f);
8741 path.conicTo(47.2051f, 11.4379f, 47.6932f, 12.3107f, 0.707107f);
8742 path.close();
8743 path.moveTo(49.0539f, 15.1303f);
8744 path.quadTo(49.2539f, 15.6178f, 49.434f, 16.113f);
8745 path.conicTo(49.7758f, 17.0527f, 48.836f, 17.3946f, 0.707107f);
8746 path.conicTo(47.8963f, 17.7364f, 47.5545f, 16.7966f, 0.707107f);
8747 path.quadTo(47.3882f, 16.3395f, 47.2036f, 15.8895f);
8748 path.conicTo(46.824f, 14.9643f, 47.7491f, 14.5847f, 0.707107f);
8749 path.conicTo(48.6743f, 14.2051f, 49.0539f, 15.1303f, 0.707107f);
8750 path.close();
8751 path.moveTo(50.0758f, 18.1294f);
8752 path.quadTo(50.216f, 18.6412f, 50.3352f, 19.1584f);
8753 path.conicTo(50.5599f, 20.1328f, 49.5855f, 20.3575f, 0.707107f);
8754 path.conicTo(48.6111f, 20.5821f, 48.3864f, 19.6077f, 0.707107f);
8755 path.quadTo(48.2763f, 19.1304f, 48.1469f, 18.6579f);
8756 path.conicTo(47.8826f, 17.6935f, 48.8471f, 17.4292f, 0.707107f);
8757 path.conicTo(49.8115f, 17.165f, 50.0758f, 18.1294f, 0.707107f);
8758 path.close();
8759 path.moveTo(50.7247f, 21.2262f);
8760 path.quadTo(50.8005f, 21.743f, 50.8555f, 22.2623f);
8761 path.conicTo(50.9607f, 23.2568f, 49.9663f, 23.3621f, 0.707107f);
8762 path.conicTo(48.9719f, 23.4673f, 48.8666f, 22.4729f, 0.707107f);
8763 path.quadTo(48.8158f, 21.9935f, 48.7458f, 21.5165f);
8764 path.conicTo(48.6007f, 20.5271f, 49.5901f, 20.382f, 0.707107f);
8765 path.conicTo(50.5795f, 20.2368f, 50.7247f, 21.2262f, 0.707107f);
8766 path.close();
8767 path.moveTo(50.9916f, 24.3398f);
8768 path.quadTo(51.0048f, 24.858f, 50.9973f, 25.3762f);
8769 path.conicTo(50.9828f, 26.3761f, 49.9829f, 26.3616f, 0.707107f);
8770 path.conicTo(48.983f, 26.3472f, 48.9975f, 25.3473f, 0.707107f);
8771 path.quadTo(49.0044f, 24.8687f, 48.9923f, 24.3906f);
8772 path.conicTo(48.9669f, 23.3909f, 49.9665f, 23.3655f, 0.707107f);
8773 path.conicTo(50.9662f, 23.3401f, 50.9916f, 24.3398f, 0.707107f);
8774 path.close();
8775 path.moveTo(50.8819f, 27.4753f);
8776 path.quadTo(50.8323f, 27.9943f, 50.7618f, 28.511f);
8777 path.conicTo(50.6268f, 29.5018f, 49.636f, 29.3668f, 0.707107f);
8778 path.conicTo(48.6451f, 29.2317f, 48.7802f, 28.2409f, 0.707107f);
8779 path.quadTo(48.8452f, 27.7641f, 48.891f, 27.2849f);
8780 path.conicTo(48.9862f, 26.2894f, 49.9816f, 26.3846f, 0.707107f);
8781 path.conicTo(50.9771f, 26.4798f, 50.8819f, 27.4753f, 0.707107f);
8782 path.close();
8783 path.moveTo(50.4023f, 30.5429f);
8784 path.quadTo(50.2856f, 31.0775f, 50.1465f, 31.607f);
8785 path.conicTo(49.8924f, 32.5742f, 48.9252f, 32.3201f, 0.707107f);
8786 path.conicTo(47.9581f, 32.066f, 48.2122f, 31.0988f, 0.707107f);
8787 path.quadTo(48.3405f, 30.6102f, 48.4483f, 30.1165f);
8788 path.conicTo(48.6614f, 29.1395f, 49.6385f, 29.3527f, 0.707107f);
8789 path.conicTo(50.6155f, 29.5659f, 50.4023f, 30.5429f, 0.707107f);
8790 path.close();
8791 path.moveTo(49.5104f, 33.674f);
8792 path.quadTo(49.3329f, 34.1756f, 49.1351f, 34.6695f);
8793 path.conicTo(48.7632f, 35.5977f, 47.8349f, 35.2258f, 0.707107f);
8794 path.conicTo(46.9066f, 34.854f, 47.2785f, 33.9257f, 0.707107f);
8795 path.quadTo(47.4612f, 33.4697f, 47.625f, 33.0067f);
8796 path.conicTo(47.9587f, 32.064f, 48.9014f, 32.3977f, 0.707107f);
8797 path.conicTo(49.8441f, 32.7313f, 49.5104f, 33.674f, 0.707107f);
8798 path.close();
8799 path.moveTo(48.281f, 36.5756f);
8800 path.quadTo(48.053f, 37.0342f, 47.8071f, 37.4835f);
8801 path.conicTo(47.3269f, 38.3607f, 46.4497f, 37.8805f, 0.707107f);
8802 path.conicTo(45.5725f, 37.4004f, 46.0527f, 36.5232f, 0.707107f);
8803 path.quadTo(46.2797f, 36.1085f, 46.4901f, 35.6852f);
8804 path.conicTo(46.9353f, 34.7898f, 47.8307f, 35.235f, 0.707107f);
8805 path.conicTo(48.7262f, 35.6802f, 48.281f, 36.5756f, 0.707107f);
8806 path.close();
8807 path.moveTo(46.7777f, 39.2033f);
8808 path.quadTo(46.6677f, 39.3719f, 46.555f, 39.539f);
8809 path.quadTo(46.3865f, 39.7888f, 46.2121f, 40.0349f);
8810 path.conicTo(45.6338f, 40.8507f, 44.818f, 40.2724f, 0.707107f);
8811 path.conicTo(44.0021f, 39.6942f, 44.5804f, 38.8783f, 0.707107f);
8812 path.quadTo(44.7413f, 38.6513f, 44.8969f, 38.4206f);
8813 path.quadTo(45.0008f, 38.2665f, 45.1025f, 38.1107f);
8814 path.conicTo(45.6488f, 37.2731f, 46.4864f, 37.8194f, 0.707107f);
8815 path.conicTo(47.324f, 38.3657f, 46.7777f, 39.2033f, 0.707107f);
8816 path.close();
8817 path.moveTo(44.9527f, 41.6701f);
8818 path.quadTo(44.6177f, 42.0709f, 44.267f, 42.458f);
8819 path.conicTo(43.5955f, 43.1991f, 42.8545f, 42.5276f, 0.707107f);
8820 path.conicTo(42.1135f, 41.8561f, 42.7849f, 41.1151f, 0.707107f);
8821 path.quadTo(43.1087f, 40.7578f, 43.4178f, 40.3878f);
8822 path.conicTo(44.059f, 39.6203f, 44.8264f, 40.2615f, 0.707107f);
8823 path.conicTo(45.5938f, 40.9027f, 44.9527f, 41.6701f, 0.707107f);
8824 path.close();
8825 path.moveTo(42.7884f, 43.9624f);
8826 path.quadTo(42.4083f, 44.319f, 42.014f, 44.6602f);
8827 path.conicTo(41.2578f, 45.3146f, 40.6034f, 44.5585f, 0.707107f);
8828 path.conicTo(39.949f, 43.8023f, 40.7052f, 43.1479f, 0.707107f);
8829 path.quadTo(41.0691f, 42.833f, 41.4201f, 42.5037f);
8830 path.conicTo(42.1494f, 41.8196f, 42.8336f, 42.5489f, 0.707107f);
8831 path.conicTo(43.5178f, 43.2782f, 42.7884f, 43.9624f, 0.707107f);
8832 path.close();
8833 path.moveTo(40.3892f, 45.9564f);
8834 path.quadTo(39.9683f, 46.2655f, 39.5354f, 46.5574f);
8835 path.conicTo(38.7062f, 47.1165f, 38.1472f, 46.2873f, 0.707107f);
8836 path.conicTo(37.5881f, 45.4582f, 38.4173f, 44.8992f, 0.707107f);
8837 path.quadTo(38.8169f, 44.6297f, 39.2054f, 44.3444f);
8838 path.conicTo(40.0114f, 43.7525f, 40.6033f, 44.5585f, 0.707107f);
8839 path.conicTo(41.1952f, 45.3645f, 40.3892f, 45.9564f, 0.707107f);
8840 path.close();
8841 path.moveTo(37.7543f, 47.6568f);
8842 path.quadTo(37.2977f, 47.9138f, 36.8312f, 48.1522f);
8843 path.conicTo(35.9407f, 48.6072f, 35.4857f, 47.7167f, 0.707107f);
8844 path.conicTo(35.0306f, 46.8263f, 35.9211f, 46.3712f, 0.707107f);
8845 path.quadTo(36.3518f, 46.1511f, 36.7732f, 45.9139f);
8846 path.conicTo(37.6446f, 45.4234f, 38.1351f, 46.2948f, 0.707107f);
8847 path.conicTo(38.6257f, 47.1662f, 37.7543f, 47.6568f, 0.707107f);
8848 path.close();
8849 path.moveTo(34.9311f, 49.0286f);
8850 path.quadTo(34.4488f, 49.2279f, 33.9589f, 49.4077f);
8851 path.conicTo(33.0202f, 49.7523f, 32.6756f, 48.8136f, 0.707107f);
8852 path.conicTo(32.331f, 47.8748f, 33.2698f, 47.5302f, 0.707107f);
8853 path.quadTo(33.722f, 47.3642f, 34.1672f, 47.1802f);
8854 path.conicTo(35.0914f, 46.7983f, 35.4733f, 47.7224f, 0.707107f);
8855 path.conicTo(35.8553f, 48.6466f, 34.9311f, 49.0286f, 0.707107f);
8856 path.close();
8857 path.moveTo(31.9824f, 50.0449f);
8858 path.quadTo(31.4774f, 50.1857f, 30.9668f, 50.3061f);
8859 path.conicTo(29.9935f, 50.5355f, 29.764f, 49.5622f, 0.707107f);
8860 path.conicTo(29.5346f, 48.5889f, 30.5079f, 48.3594f, 0.707107f);
8861 path.quadTo(30.9789f, 48.2484f, 31.4453f, 48.1184f);
8862 path.conicTo(32.4086f, 47.8498f, 32.6771f, 48.8131f, 0.707107f);
8863 path.conicTo(32.9457f, 49.7763f, 31.9824f, 50.0449f, 0.707107f);
8864 path.close();
8865 path.moveTo(28.899f, 50.706f);
8866 path.quadTo(28.3834f, 50.7842f, 27.8652f, 50.8416f);
8867 path.conicTo(26.8713f, 50.9518f, 26.7611f, 49.9579f, 0.707107f);
8868 path.conicTo(26.6509f, 48.964f, 27.6448f, 48.8538f, 0.707107f);
8869 path.quadTo(28.1231f, 48.8008f, 28.599f, 48.7286f);
8870 path.conicTo(29.5877f, 48.5786f, 29.7377f, 49.5673f, 0.707107f);
8871 path.conicTo(29.8877f, 50.556f, 28.899f, 50.706f, 0.707107f);
8872 path.close();
8873 path.moveTo(25.8106f, 50.9874f);
8874 path.quadTo(25.6321f, 50.9929f, 25.4537f, 50.996f);
8875 path.conicTo(24.4539f, 51.0135f, 24.4365f, 50.0136f, 0.707115f);
8876 path.lineTo(24.4251f, 49.3638f);
8877 path.conicTo(24.4077f, 48.364f, 25.4075f, 48.3465f, 0.707107f);
8878 path.conicTo(26.4073f, 48.3291f, 26.4248f, 49.3289f, 0.707107f);
8879 path.lineTo(26.4361f, 49.9787f);
8880 path.lineTo(25.4363f, 49.9962f);
8881 path.lineTo(25.4189f, 48.9963f);
8882 path.quadTo(25.5836f, 48.9935f, 25.7482f, 48.9883f);
8883 path.conicTo(26.7477f, 48.9571f, 26.7789f, 49.9567f, 0.707107f);
8884 path.conicTo(26.8101f, 50.9562f, 25.8106f, 50.9874f, 0.707107f);
8885 path.close();
8886 path.moveTo(24.3902f, 47.3641f);
8887 path.lineTo(24.3728f, 46.3643f);
8888 path.conicTo(24.3553f, 45.3645f, 25.3551f, 45.347f, 0.707107f);
8889 path.conicTo(26.355f, 45.3295f, 26.3724f, 46.3294f, 0.707107f);
8890 path.lineTo(26.3899f, 47.3292f);
8891 path.conicTo(26.4074f, 48.3291f, 25.4075f, 48.3465f, 0.707107f);
8892 path.conicTo(24.4077f, 48.364f, 24.3902f, 47.3641f, 0.707107f);
8893 path.close();
8894 path.moveTo(24.3378f, 44.3646f);
8895 path.lineTo(24.3204f, 43.3648f);
8896 path.conicTo(24.3029f, 42.3649f, 25.3028f, 42.3475f, 0.707107f);
8897 path.conicTo(26.3026f, 42.33f, 26.3201f, 43.3298f, 0.707107f);
8898 path.lineTo(26.3375f, 44.3297f);
8899 path.conicTo(26.355f, 45.3295f, 25.3551f, 45.347f, 0.707107f);
8900 path.conicTo(24.3553f, 45.3645f, 24.3378f, 44.3646f, 0.707107f);
8901 path.close();
8902 path.moveTo(24.2855f, 41.3651f);
8903 path.lineTo(24.268f, 40.3652f);
8904 path.conicTo(24.2506f, 39.3654f, 25.2504f, 39.3479f, 0.707107f);
8905 path.conicTo(26.2503f, 39.3305f, 26.2677f, 40.3303f, 0.707107f);
8906 path.lineTo(26.2852f, 41.3302f);
8907 path.conicTo(26.3026f, 42.33f, 25.3028f, 42.3475f, 0.707107f);
8908 path.conicTo(24.3029f, 42.3649f, 24.2855f, 41.3651f, 0.707107f);
8909 path.close();
8910 path.moveTo(24.2331f, 38.3655f);
8911 path.lineTo(24.2157f, 37.3657f);
8912 path.conicTo(24.1982f, 36.3658f, 25.1981f, 36.3484f, 0.707107f);
8913 path.conicTo(26.1979f, 36.3309f, 26.2154f, 37.3308f, 0.707107f);
8914 path.lineTo(26.2328f, 38.3306f);
8915 path.conicTo(26.2503f, 39.3305f, 25.2504f, 39.3479f, 0.707107f);
8916 path.conicTo(24.2506f, 39.3654f, 24.2331f, 38.3655f, 0.707107f);
8917 path.close();
8918 path.moveTo(24.1808f, 35.366f);
8919 path.lineTo(24.1633f, 34.3661f);
8920 path.conicTo(24.1459f, 33.3663f, 25.1457f, 33.3488f, 0.707107f);
8921 path.conicTo(26.1456f, 33.3314f, 26.163f, 34.3312f, 0.707107f);
8922 path.lineTo(26.1805f, 35.3311f);
8923 path.conicTo(26.1979f, 36.3309f, 25.1981f, 36.3484f, 0.707107f);
8924 path.conicTo(24.1982f, 36.3658f, 24.1808f, 35.366f, 0.707107f);
8925 path.close();
8926 path.moveTo(24.1284f, 32.3664f);
8927 path.lineTo(24.111f, 31.3666f);
8928 path.conicTo(24.0935f, 30.3667f, 25.0934f, 30.3493f, 0.707107f);
8929 path.conicTo(26.0932f, 30.3318f, 26.1107f, 31.3317f, 0.707107f);
8930 path.lineTo(26.1281f, 32.3315f);
8931 path.conicTo(26.1456f, 33.3314f, 25.1457f, 33.3488f, 0.707107f);
8932 path.conicTo(24.1459f, 33.3663f, 24.1284f, 32.3664f, 0.707107f);
8933 path.close();
8934 path.moveTo(24.0761f, 29.3669f);
8935 path.lineTo(24.0586f, 28.367f);
8936 path.conicTo(24.0412f, 27.3672f, 25.041f, 27.3497f, 0.707107f);
8937 path.conicTo(26.0409f, 27.3323f, 26.0583f, 28.3321f, 0.707107f);
8938 path.lineTo(26.0758f, 29.332f);
8939 path.conicTo(26.0932f, 30.3318f, 25.0934f, 30.3493f, 0.707107f);
8940 path.conicTo(24.0935f, 30.3667f, 24.0761f, 29.3669f, 0.707107f);
8941 path.close();
8942 path.moveTo(24.0237f, 26.3673f);
8943 path.lineTo(24.0063f, 25.3675f);
8944 path.conicTo(23.9888f, 24.3676f, 24.9887f, 24.3502f, 0.707107f);
8945 path.conicTo(25.9885f, 24.3327f, 26.006f, 25.3326f, 0.707107f);
8946 path.lineTo(26.0234f, 26.3324f);
8947 path.conicTo(26.0409f, 27.3323f, 25.041f, 27.3497f, 0.707107f);
8948 path.conicTo(24.0412f, 27.3672f, 24.0237f, 26.3673f, 0.707107f);
8949 path.close();
8950     testPathOpFail(reporter, path, path1, kXOR_SkPathOp, filename);
8954     SkPath path;
8955     path.setFillType((SkPathFillType) 0);
8956 path.setFillType(SkPathFillType::kWinding);
8957 path.moveTo(SkBits2Float(0x15e80300), SkBits2Float(0x400004dc));  // 9.37088e-26f, 2.0003f
8958 path.quadTo(SkBits2Float(0xe56c206c), SkBits2Float(0x646c5f40), SkBits2Float(0x6c80885e), SkBits2Float(0xb4bc576c));  // -6.96923e+22f, 1.74412e+22f, 1.24309e+27f, -3.50813e-07f
8960     SkPath path1(path);
8961     path.reset();
8962     path.setFillType((SkPathFillType) 0);
8963 path.setFillType(SkPathFillType::kWinding);
8964 path.moveTo(SkBits2Float(0x1b000010), SkBits2Float(0x6e5a5a1b));  // 1.05879e-22f, 1.68942e+28f
8965 path.quadTo(SkBits2Float(0xef646464), SkBits2Float(0xefefefef), SkBits2Float(0x000000ef), SkBits2Float(0x1bb4bc00));  // -7.06839e+28f, -1.48514e+29f, 3.3491e-43f, 2.99e-22f
8967     SkPath path2(path);
8973     SkPath path;
8974     path.setFillType((SkPathFillType) 1);
8975 path.setFillType(SkPathFillType::kEvenOdd);
8976 path.moveTo(SkBits2Float(0xeee3ef57), SkBits2Float(0xef6300f8));  // -3.52712e+28f, -7.02543e+28f
8977 path.quadTo(SkBits2Float(0xeeee9c6e), SkBits2Float(0xef609993), SkBits2Float(0x00000000), SkBits2Float(0x6e5a5a1b));  // -3.69233e+28f, -6.95103e+28f, 0, 1.68942e+28f
8978 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
8979 path.quadTo(SkBits2Float(0xe56c206c), SkBits2Float(0x646c5f40), SkBits2Float(0x6c80885e), SkBits2Float(0x00000000));  // -6.96923e+22f, 1.74412e+22f, 1.24309e+27f, 0
8980 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
8981 path.quadTo(SkBits2Float(0xeeda2c5a), SkBits2Float(0xef6533a7), SkBits2Float(0xeee3ef57), SkBits2Float(0xef6300f8));  // -3.37607e+28f, -7.09345e+28f, -3.52712e+28f, -7.02543e+28f
8982 path.close();
8984     SkPath path1(path);
8985     path.reset();
8986     path.setFillType((SkPathFillType) 0);
8987 path.setFillType(SkPathFillType::kWinding);
8988 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
8989 path.lineTo(SkBits2Float(0x1b1b1b00), SkBits2Float(0x1b5a5a1b));  // 1.283e-22f, 1.80617e-22f
8991     SkPath path2(path);
8997     SkPath path;
8998     path.setFillType((SkPathFillType) 1);
8999 path.setFillType(SkPathFillType::kEvenOdd);
9000 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6e5a5a1b));  // 0, 1.68942e+28f
9001 path.quadTo(SkBits2Float(0xeeee9c6e), SkBits2Float(0xef609993), SkBits2Float(0xeee3ef57), SkBits2Float(0xef6300f8));  // -3.69233e+28f, -6.95103e+28f, -3.52712e+28f, -7.02543e+28f
9002 path.quadTo(SkBits2Float(0xeeda2c5a), SkBits2Float(0xef6533a7), SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // -3.37607e+28f, -7.09345e+28f, 0, 0
9003 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6e5a5a1b));  // 0, 1.68942e+28f
9004 path.close();
9005 path.moveTo(SkBits2Float(0x6c80885e), SkBits2Float(0x00000000));  // 1.24309e+27f, 0
9006 path.quadTo(SkBits2Float(0xe56c206c), SkBits2Float(0x646c5f40), SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // -6.96923e+22f, 1.74412e+22f, 0, 0
9007 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
9008 path.lineTo(SkBits2Float(0x6c80885e), SkBits2Float(0x00000000));  // 1.24309e+27f, 0
9009 path.close();
9011     SkPath path1(path);
9012     path.reset();
9013     path.setFillType((SkPathFillType) 0);
9014 path.setFillType(SkPathFillType::kWinding);
9016     SkPath path2(path);
9083 SkPath path, path2;
9084 path.setFillType(SkPathFillType::kEvenOdd);
9085 path.moveTo(SkBits2Float(0xa6800000), SkBits2Float(0x43b0f22d));  // -8.88178e-16f, 353.892f
9086 path.lineTo(SkBits2Float(0x42fc0000), SkBits2Float(0x4116566d));  // 126, 9.3961f
9087 path.cubicTo(SkBits2Float(0x42fb439d), SkBits2Float(0x4114bbc7), SkBits2Float(0x42fa3ed7), SkBits2Float(0x411565bd), SkBits2Float(0x42f934d2), SkBits2Float(0x4116131e));  // 125.632f, 9.29584f, 125.123f, 9.33734f, 124.603f, 9.37967f
9088 path.cubicTo(SkBits2Float(0x42f84915), SkBits2Float(0x4116acc3), SkBits2Float(0x42f75939), SkBits2Float(0x41174918), SkBits2Float(0x42f693f8), SkBits2Float(0x4116566d));  // 124.143f, 9.41718f, 123.674f, 9.45535f, 123.289f, 9.3961f
9089 path.lineTo(SkBits2Float(0x42ec3cee), SkBits2Float(0x410127bb));  // 118.119f, 8.0722f
9090 path.lineTo(SkBits2Float(0x4102c0ec), SkBits2Float(0x42d06d0e));  // 8.1721f, 104.213f
9091 path.lineTo(SkBits2Float(0xa6000000), SkBits2Float(0x4381a63d));  // -4.44089e-16f, 259.299f
9092 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x43b0f22d));  // 0, 353.892f
9093 path.lineTo(SkBits2Float(0xa6800000), SkBits2Float(0x43b0f22d));  // -8.88178e-16f, 353.892f
9094 path.close();
9103     testPathOp(reporter, path, path2, kIntersect_SkPathOp, filename);
9622     SkPath path;
9623     path.addRect(0,0, 300,170141183460469231731687303715884105728.f);
9626     testPathOpFuzz(reporter, path, pathB, kUnion_SkPathOp, filename);
9673     SkPath path;
9674     path.setFillType((SkPathFillType) 0);
9675 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9676 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
9677 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333));
9678 path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc));
9679 path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff));
9680 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
9681 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
9682 path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000));
9683 path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000));
9684 path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000));
9685 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
9686 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
9687 path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000));
9688 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9689 path.close();
9691     SkPath path1(path);
9692     path.reset();
9693     path.setFillType((SkPathFillType) 0);
9694 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9695 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
9696 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a));
9697 path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a));
9698 path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd));
9699 path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000));
9700 path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a));
9701 path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333));
9702 path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000));
9703 path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000));
9704 path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a));
9705 path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334));
9706 path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd));
9707 path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd));
9708 path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd));
9709 path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334));
9710 path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000));
9711 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9712 path.close();
9714     SkPath path2(path);
9719     SkPath path;
9720     path.setFillType((SkPathFillType) 0);
9721 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9722 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
9723 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333));
9724 path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc));
9725 path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff));
9726 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
9727 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
9728 path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000));
9729 path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000));
9730 path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000));
9731 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
9732 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
9733 path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000));
9734 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9735 path.close();
9737     SkPath path1(path);
9738     path.reset();
9739     path.setFillType((SkPathFillType) 0);
9740 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9741 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
9742 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a));
9743 path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a));
9744 path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd));
9745 path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000));
9746 path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a));
9747 path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333));
9748 path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000));
9749 path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000));
9750 path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a));
9751 path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334));
9752 path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd));
9753 path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd));
9754 path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd));
9755 path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334));
9756 path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000));
9757 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9758 path.close();
9760     SkPath path2(path);
9765     SkPath path;
9766     path.setFillType((SkPathFillType) 1);
9767 path.moveTo(SkBits2Float(0x430c0000), SkBits2Float(0x42200000));
9768 path.lineTo(SkBits2Float(0x43480000), SkBits2Float(0x43520000));
9769 path.lineTo(SkBits2Float(0x42200000), SkBits2Float(0x42c80000));
9770 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x42c80000));  // 2.22222e+022f
9771 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x43520000));  // 2.22222e+022f
9772 path.lineTo(SkBits2Float(0x430c0000), SkBits2Float(0x42200000));
9773 path.close();
9775     SkPath path1(path);
9776     path.reset();
9777     path.setFillType((SkPathFillType) 0);
9778 path.moveTo(SkBits2Float(0x43200000), SkBits2Float(0x42700000));
9779 path.lineTo(SkBits2Float(0x435c0000), SkBits2Float(0x43660000));
9780 path.lineTo(SkBits2Float(0x42700000), SkBits2Float(0x42f00000));
9781 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x42f00000));  // 2.22222e+022f
9782 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x43660000));  // 2.22222e+022f
9783 path.lineTo(SkBits2Float(0x43200000), SkBits2Float(0x42700000));
9784 path.close();
9786     SkPath path2(path);
9791     SkPath path;
9792     path.setFillType((SkPathFillType) 0);
9793 path.moveTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
9794 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
9795 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
9796 path.quadTo(SkBits2Float(0xffc00000), SkBits2Float(0x7f800000), SkBits2Float(0xffc00000), SkBits2Float(0x7f800000));
9797 path.quadTo(SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000));
9798 path.quadTo(SkBits2Float(0xff000001), SkBits2Float(0xffc00000), SkBits2Float(0xffc00000), SkBits2Float(0xffc00000));
9799 path.quadTo(SkBits2Float(0xffc00000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xff000001));
9800 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xffc00000));
9801 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0xffc00000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
9802 path.close();
9804     SkPath path1(path);
9805     path.reset();
9806     path.setFillType((SkPathFillType) 0);
9808     SkPath path2(path);
9814     SkPath path;
9815     path.setFillType((SkPathFillType) 0);
9816 path.moveTo(SkBits2Float(0x42910000), SkBits2Float(0x00000000));  // 72.5f, 0
9817 path.lineTo(SkBits2Float(0x42166668), SkBits2Float(0x00000000));  // 37.6f, 0
9818 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
9819 path.lineTo(SkBits2Float(0x41840004), SkBits2Float(0xc291cccd));  // 16.5f, -72.9f
9820 path.lineTo(SkBits2Float(0x42fb6668), SkBits2Float(0x42c73334));  // 125.7f, 99.6f
9821 path.lineTo(SkBits2Float(0x43646668), SkBits2Float(0x43880ccd));  // 228.4f, 272.1f
9823     SkPath path1(path);
9824     path.reset();
9825     path.setFillType((SkPathFillType) 0);
9826 path.moveTo(SkBits2Float(0x428bf702), SkBits2Float(0xcf223cbf));  // 69.9824f, -2.72189e+09f
9827 path.lineTo(SkBits2Float(0x42112d68), SkBits2Float(0xcf223cbf));  // 36.2943f, -2.72189e+09f
9828 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
9829 path.lineTo(SkBits2Float(0x424a99e0), SkBits2Float(0xcf223cc0));  // 50.6503f, -2.72189e+09f
9830 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
9831 path.lineTo(SkBits2Float(0x40f8fbe0), SkBits2Float(0xcf223cc0));  // 7.78075f, -2.72189e+09f
9833     SkPath path2(path);
9838 SkPath path;
9839 path.setFillType((SkPathFillType) 0);
9840 path.moveTo(SkBits2Float(0x43b38000), SkBits2Float(0x433e0000));  // 359, 190
9841 path.lineTo(SkBits2Float(0x40c00000), SkBits2Float(0x449ce000));  // 6, 1255
9842 path.cubicTo(SkBits2Float(0x438c0000), SkBits2Float(0x4497a000), SkBits2Float(0x43e40000), SkBits2Float(0x44750000), SkBits2Float(0x41000000), SkBits2Float(0x44aa2000));  // 280, 1213, 456, 980, 8, 1361
9843 path.moveTo(SkBits2Float(0x43290000), SkBits2Float(0x4431c000));  // 169, 711
9844 path.lineTo(SkBits2Float(0xd987d6ba), SkBits2Float(0xd93d0ad4));  // -4.7794e+15f, -3.32567e+15f
9845 path.conicTo(SkBits2Float(0x43cc8000), SkBits2Float(0x445b8000), SkBits2Float(0xd888b096), SkBits2Float(0xd9a1ebfa), SkBits2Float(0x3ebcb199));  // 409, 878, -1.20234e+15f, -5.69712e+15f, 0.368542f
9846 path.cubicTo(SkBits2Float(0x43c00000), SkBits2Float(0x443a8000), SkBits2Float(0x42380000), SkBits2Float(0x4421c000), SkBits2Float(0x42500000), SkBits2Float(0x448ca000));  // 384, 746, 46, 647, 52, 1125
9847 path.quadTo(SkBits2Float(0x43948000), SkBits2Float(0x42ac0000), SkBits2Float(0x43880000), SkBits2Float(0x4487e000));  // 297, 86, 272, 1087
9848 SkPath path1(path);
9849 path.reset();
9850 path.setFillType((SkPathFillType) 0);
9851 path.moveTo(SkBits2Float(0xc51d735c), SkBits2Float(0xc49db029));  // -2519.21f, -1261.51f
9852 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
9853 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
9854 path.quadTo(SkBits2Float(0xc51bf7eb), SkBits2Float(0xc49cf010), SkBits2Float(0xc51ba866), SkBits2Float(0xc49cb9e6));  // -2495.49f, -1255.5f, -2490.52f, -1253.81f
9855 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
9856 SkPath path2(path);
9861 SkPath path;
9862 path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0xcf000000));  // 360, -2.14748e+09f
9863 path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0xcf000000), SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe), SkBits2Float(0x3f3504f4));  // 1.07374e+09f, -2.14748e+09f, 1.07374e+09f, -1.07374e+09f, 0.707107f
9864 path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0x43800001), SkBits2Float(0x43348000), SkBits2Float(0x43800001), SkBits2Float(0x3f3504f4));  // 1.07374e+09f, 256, 180.5f, 256, 0.707107f
9865 SkPath path1(path);
9866 path.reset();
9867 path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000));  // 360, 4140
9868 path.conicTo(SkBits2Float(0x43b40005), SkBits2Float(0x458a945d), SkBits2Float(0x45610000), SkBits2Float(0x458a945d), SkBits2Float(0x3f3504f3));  // 360, 4434.55f, 3600, 4434.55f, 0.707107f
9869 path.conicTo(SkBits2Float(0x45d5bfff), SkBits2Float(0x458a945d), SkBits2Float(0x45d5bfff), SkBits2Float(0x45816000), SkBits2Float(0x3f3504f3));  // 6840, 4434.55f, 6840, 4140, 0.707107f
9870 path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000));  // 100, 512
9871 path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000));  // 32, 16
9872 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000));  // 360, 1024
9873 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000));  // 360, 4140
9874 path.close();
9875 SkPath path2(path);
9880 SkPath path;
9881 path.setFillType(SkPathFillType::kEvenOdd);
9882 path.moveTo(SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe));  // 1.07374e+09f, -1.07374e+09f
9883 path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0xcf000000), SkBits2Float(0x43b40000), SkBits2Float(0xcf000000), SkBits2Float(0x3f3504f4));  // 1.07374e+09f, -2.14748e+09f, 360, -2.14748e+09f, 0.707107f
9884 path.lineTo(SkBits2Float(0x43348000), SkBits2Float(0x43800001));  // 180.5f, 256
9885 path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000));  // 32, 16
9886 path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000));  // 100, 512
9887 path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd));  // 213.229f, 572.949f
9888 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000));  // 360, 1024
9889 path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000));  // 360, 4140
9890 path.conicTo(SkBits2Float(0x43b40005), SkBits2Float(0x458a945d), SkBits2Float(0x45610000), SkBits2Float(0x458a945d), SkBits2Float(0x3f3504f3));  // 360, 4434.55f, 3600, 4434.55f, 0.707107f
9891 path.conicTo(SkBits2Float(0x45d5bfff), SkBits2Float(0x458a945d), SkBits2Float(0x45d5bfff), SkBits2Float(0x45816000), SkBits2Float(0x3f3504f3));  // 6840, 4434.55f, 6840, 4140, 0.707107f
9892 path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd));  // 213.229f, 572.949f
9893 path.lineTo(SkBits2Float(0x43348000), SkBits2Float(0x43800001));  // 180.5f, 256
9894 path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0x43800001), SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe), SkBits2Float(0x3f3504f4));  // 1.07374e+09f, 256, 1.07374e+09f, -1.07374e+09f, 0.707107f
9895 path.close();
9896 SkPath path1(path);
9897 path.reset();
9898 path.moveTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000));  // 127, 321
9899 path.lineTo(SkBits2Float(0x45d5c000), SkBits2Float(0x43870000));  // 6840, 270
9900 path.lineTo(SkBits2Float(0xd0a00000), SkBits2Float(0x4cbebc20));  // -2.14748e+10f, 1e+08
9901 path.lineTo(SkBits2Float(0x451f7000), SkBits2Float(0x42800000));  // 2551, 64
9902 path.lineTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000));  // 127, 321
9903 path.close();
9904 SkPath path2(path);
9909     SkPath path;
9910     path.setFillType((SkPathFillType) 1);
9912     SkPath path1(path);
9913     path.reset();
9914     path.setFillType((SkPathFillType) 0);
9915 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
9916 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
9917 path.lineTo(SkBits2Float(0x7bc00321), SkBits2Float(0xed7a6a4b));  // 1.99397e+36f, -4.84373e+27f
9918 path.lineTo(SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28));  // 9.4495e-15f, 0.000617492f
9919 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
9920 path.close();
9921 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
9922 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3), SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6));  // -8.10388e-33f, 0.00148185f, 2.25206e-21f, 5.54035e+21f
9923 path.moveTo(SkBits2Float(0x29272a81), SkBits2Float(0x2ab03a55));  // 3.71183e-14f, 3.13044e-13f
9924 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a214729), SkBits2Float(0xdf28282a), SkBits2Float(0x8a2f2121));  // 2.22225e-15f, 0.000615227f, -1.2117e+19f, -8.43217e-33f
9925 path.quadTo(SkBits2Float(0x373b3a27), SkBits2Float(0x201fc4c1), SkBits2Float(0x27576c2a), SkBits2Float(0x5921c25d));  // 1.11596e-05f, 1.35329e-19f, 2.98959e-15f, 2.8457e+15f
9926 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a214729), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21));  // 2.22225e-15f, 0.000615227f, -1.2117e+19f, 0.00105459f
9927 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
9928 path.quadTo(SkBits2Float(0xd912102a), SkBits2Float(0x284f9a28), SkBits2Float(0xb38a1f30), SkBits2Float(0x3a3ac23a));  // -2.56957e+15f, 1.15242e-14f, -6.4318e-08f, 0.000712428f
9929 path.lineTo(SkBits2Float(0xc809272a), SkBits2Float(0x29b02829));  // -140445, 7.82294e-14f
9931     SkPath path2(path);
9937     SkPath path;
9938     path.setFillType((SkPathFillType) 1);
9940     SkPath path1(path);
9941     path.reset();
9942     path.setFillType((SkPathFillType) 0);
9943 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
9944 path.lineTo(SkBits2Float(0x555b3a2d), SkBits2Float(0x2a212a8c));  // 1.50652e+13f, 1.43144e-13f
9945 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
9946 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac2b33a));  // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148544f
9947 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
9948 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
9949 path.close();
9950 path.moveTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968));  // 1.59674e+13f, 4.87407e+16f
9951 path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x2a21081f));  // 1.43144e-13f, 1.43025e-13f
9952 path.conicTo(SkBits2Float(0xde6a4b7b), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a));  // -4.22068e+18f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121589
9953 path.lineTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968));  // 1.59674e+13f, 4.87407e+16f
9954 path.close();
9955 path.moveTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968));  // 1.59674e+13f, 4.87407e+16f
9956 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3));  // -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
9957 path.lineTo(SkBits2Float(0x2928088c), SkBits2Float(0x2be61d2a));  // 3.73109e-14f, 1.63506e-12f
9958 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
9959 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
9960 path.lineTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968));  // 1.59674e+13f, 4.87407e+16f
9961 path.close();
9962 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a));  // 5.7784e-19f, 4.61198e-19f
9963 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
9965     SkPath path2(path);
9970     SkPath path;
9971     path.setFillType((SkPathFillType) 1);
9973     SkPath path1(path);
9974     path.reset();
9975     path.setFillType((SkPathFillType) 0);
9976 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
9977 path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c));  // 1.50606e+13f, 1.43144e-13f
9978 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
9979 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
9980 path.moveTo(SkBits2Float(0x25682929), SkBits2Float(0x212a8c5b));  // 2.01367e-16f, 5.7784e-19f
9981 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4a7bc0));  // 4.7323e-37f, 6.11969e+25f
9982 path.conicTo(SkBits2Float(0x032108ed), SkBits2Float(0x283a7bc0), SkBits2Float(0x47ed7a6a), SkBits2Float(0x282a3a21), SkBits2Float(0x3a21ff28));  // 4.73239e-37f, 1.03519e-14f, 121589, 9.4495e-15f, 0.000617968f
9983 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d));  // -8.10388e-33f, 0.00148185f, 1.50241e-13f, -1.38859e-25f
9984 path.lineTo(SkBits2Float(0x295b2d2a), SkBits2Float(0x2d296868));  // 4.86669e-14f, 9.62972e-12f
9985 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a));  // 5.7784e-19f, 4.61198e-19f
9986 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x898ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a));  // 6.14991e+25f, -3.39271e-33f, 4.61198e-19f, 0.00096035f, 121589
9987 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a));  // 5.7784e-19f, 4.61198e-19f
9988 path.close();
9989 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a));  // 5.7784e-19f, 4.61198e-19f
9990 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0xb38a281a), SkBits2Float(0x29283ac2));  // -1.2117e+19f, 0.00105459f, -6.43342e-08f, 3.73545e-14f
9991 path.moveTo(SkBits2Float(0x962be61d), SkBits2Float(0x432a2927));  // -1.38859e-25f, 170.161f
9992 path.conicTo(SkBits2Float(0x3a2a552a), SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x3b3ac527), SkBits2Float(0x1fc42236));  // 0.000649768f, 0.00241343f, 3.71093e-14f, 0.00284989f, 8.30658e-20f
9993 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
9994 path.lineTo(SkBits2Float(0x272927b0), SkBits2Float(0x5b392929));  // 2.3475e-15f, 5.21181e+16f
9995 path.moveTo(SkBits2Float(0x3a1127b4), SkBits2Float(0x2921ee3b));  // 0.000553723f, 3.59558e-14f
9996 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
9997 path.moveTo(SkBits2Float(0x21081f3f), SkBits2Float(0x9fd4e62a));  // 4.61199e-19f, -9.01663e-20f
9998 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
10000     SkPath path2(path);
10005     SkPath path;
10006     path.setFillType((SkPathFillType) 1);
10008     SkPath path1(path);
10009     path.reset();
10010     path.setFillType((SkPathFillType) 0);
10011 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55));  // 4.76191e+16f, 1.51477e-13f
10012 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
10013 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3));  // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
10014 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
10015 path.lineTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55));  // 4.76191e+16f, 1.51477e-13f
10016 path.close();
10017 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55));  // 4.76191e+16f, 1.51477e-13f
10018 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a));  // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121589
10019 path.lineTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55));  // 4.76191e+16f, 1.51477e-13f
10020 path.close();
10021 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55));  // 4.76191e+16f, 1.51477e-13f
10022 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3b21), SkBits2Float(0x28ee4f9a), SkBits2Float(0x68293b78));  // -1.2117e+19f, 0.00105462f, 2.64578e-14f, 3.19671e+24f
10023 path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x5b2d8c55));  // 4.87407e+16f, 4.88495e+16f
10025     SkPath path2(path);
10030     SkPath path;
10031     path.setFillType((SkPathFillType) 1);
10033     SkPath path1(path);
10034     path.reset();
10035     path.setFillType((SkPathFillType) 0);
10036 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10037 path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c));  // 1.50606e+13f, 1.43144e-13f
10038 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
10039 path.lineTo(SkBits2Float(0x081f2ad7), SkBits2Float(0x7bc00321));  // 4.78977e-34f, 1.99397e+36f
10040 path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828));  // 1.65317e-13f, -1.16126e+19f
10041 path.quadTo(SkBits2Float(0x4f1a3a8a), SkBits2Float(0x3ab38a28), SkBits2Float(0x29283ac2), SkBits2Float(0x962be62a));  // 2.58753e+09f, 0.00136978f, 3.73545e-14f, -1.38859e-25f
10042 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
10043 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
10044 path.lineTo(SkBits2Float(0x29292727), SkBits2Float(0x21475b3b));  // 3.75595e-14f, 6.75446e-19f
10045 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3));  // -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
10046 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
10047 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
10048 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
10049 path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21));  // 2.50338e-13f, 4.61198e-19f
10050 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
10051 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
10052 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
10053 path.quadTo(SkBits2Float(0x29210f21), SkBits2Float(0x282a085d), SkBits2Float(0xc2ab2127), SkBits2Float(0xa6800028));  // 3.57623e-14f, 9.43871e-15f, -85.5648f, -8.88183e-16f
10054 path.lineTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828));  // 1.65317e-13f, -1.16126e+19f
10055 path.close();
10056 path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828));  // 1.65317e-13f, -1.16126e+19f
10057 path.quadTo(SkBits2Float(0x216a2770), SkBits2Float(0x2ab73b28), SkBits2Float(0x4b28f427), SkBits2Float(0x283b5b28));  // 7.93345e-19f, 3.25484e-13f, 1.10726e+07f, 1.04004e-14f
10058 path.lineTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828));  // 1.65317e-13f, -1.16126e+19f
10059 path.close();
10060 path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828));  // 1.65317e-13f, -1.16126e+19f
10061 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
10062 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
10064     SkPath path2(path);
10070     SkPath path;
10071     path.setFillType((SkPathFillType) 0);
10073     SkPath path1(path);
10074     path.reset();
10075     path.setFillType((SkPathFillType) 0);
10076     path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10077     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
10078     path.moveTo(SkBits2Float(0x000010a1), SkBits2Float(0x19312000));  // 5.96533e-42f, 9.15715e-24f
10079     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
10080     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
10082     SkPath path2(path);
10088     SkPath path;
10089     path.setFillType((SkPathFillType) 0);
10090     path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10091     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
10092     path.lineTo(SkBits2Float(0xda1905ed), SkBits2Float(0x3c05fbfb));  // -1.0768e+16f, 0.00817775f
10093     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
10095     SkPath path1(path);
10096     path.reset();
10097     path.setFillType((SkPathFillType) 0);
10098     path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10099     path.quadTo(SkBits2Float(0x3c3c3c3c), SkBits2Float(0xfa253c3c), SkBits2Float(0xfefa00d3), SkBits2Float(0x25fad9df));  // 0.011489f, -2.14488e+35f, -1.66156e+38f, 4.35157e-16f
10100     path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10101     path.close();
10102     path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10103     path.lineTo(SkBits2Float(0x8dfefa00), SkBits2Float(0xf0f9fad9));  // -1.57141e-30f, -6.1892e+29f
10104     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
10106     SkPath path2(path);
10111     SkPath path;
10112     path.setFillType((SkPathFillType) 0);
10113     path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10114     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
10116     SkPath path1(path);
10117     path.reset();
10118     path.setFillType((SkPathFillType) 0);
10119     path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10120     path.quadTo(SkBits2Float(0x5559a419), SkBits2Float(0x59d55928), SkBits2Float(0xbd595959), SkBits2Float(0x3f3f3f09));  // 1.49562e+13f, 7.50652e+15f, -0.0530637f, 0.747056f
10121     path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0x3f3f3f3f));  // 0.747059f, 0.747059f
10122     path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f));  // 0.747059f, -2.54211e+38f
10123     path.lineTo(SkBits2Float(0x09090909), SkBits2Float(0x3038d509));  // 1.6495e-33f, 6.72416e-10f
10124     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
10125     path.lineTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f));  // 0.747059f, -2.54211e+38f
10126     path.close();
10127     path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f));  // 0.747059f, -2.54211e+38f
10128     path.lineTo(SkBits2Float(0x38d57f4b), SkBits2Float(0x59597f4b));  // 0.000101803f, 3.82625e+15f
10129     path.lineTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f));  // 0.747059f, -2.54211e+38f
10130     path.close();
10131     path.moveTo(SkBits2Float(0x384700ff), SkBits2Float(0x0108804b));  // 4.74462e-05f, 2.50713e-38f
10133     SkPath path2(path);
10139     SkPath path;
10140     path.setFillType((SkPathFillType) 1);
10142     SkPath path1(path);
10143     path.reset();
10144     path.setFillType((SkPathFillType) 0);
10145 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10146 path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c));  // 1.50606e+13f, 1.43144e-13f
10147 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
10148 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3));  // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
10149 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
10150 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
10151 path.moveTo(SkBits2Float(0x8adf2028), SkBits2Float(0x3a219a3a));  // -2.14862e-32f, 0.000616464f
10152 path.quadTo(SkBits2Float(0x3ab38e28), SkBits2Float(0x29283ac2), SkBits2Float(0x2be61d2a), SkBits2Float(0x812a4396));  // 0.0013699f, 3.73545e-14f, 1.63506e-12f, -3.12726e-38f
10154     SkPath path2(path);
10160     SkPath path;
10161     path.setFillType((SkPathFillType) 1);
10162 path.moveTo(SkBits2Float(0x38bd8610), SkBits2Float(0x00000000));  // 9.03719e-05f, 0
10163 path.conicTo(SkBits2Float(0x4183d871), SkBits2Float(0x41fea321), SkBits2Float(0xb700ff00), SkBits2Float(0x4240b8b8), SkBits2Float(0x3b058283));  // 16.4807f, 31.8297f, -7.68877e-06f, 48.1804f, 0.0020372f
10164 path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8));  // 0.000710409f, -8.80821e-05f
10165 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
10166 path.quadTo(SkBits2Float(0x3a51246a), SkBits2Float(0xb6da45a3), SkBits2Float(0x38bc5c3c), SkBits2Float(0x00000000));  // 0.000797814f, -6.50501e-06f, 8.98172e-05f, 0
10167 path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8));  // 0.000710409f, -8.80821e-05f
10168 path.quadTo(SkBits2Float(0x39a32d2d), SkBits2Float(0x00000000), SkBits2Float(0xb8a13a00), SkBits2Float(0x00000000));  // 0.000311234f, 0, -7.68788e-05f, 0
10169 path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8));  // 0.000710409f, -8.80821e-05f
10170 path.quadTo(SkBits2Float(0x39ba814c), SkBits2Float(0xb838fed2), SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0.00035573f, -4.41063e-05f, 0, 0
10171 path.lineTo(SkBits2Float(0x38bd8610), SkBits2Float(0x00000000));  // 9.03719e-05f, 0
10172 path.close();
10174     SkPath path1(path);
10175     path.reset();
10176     path.setFillType((SkPathFillType) 0);
10178     SkPath path2(path);
10184     SkPath path;
10185     path.setFillType((SkPathFillType) 1);
10187     SkPath path1(path);
10188     path.reset();
10189     path.setFillType((SkPathFillType) 0);
10190 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10191 path.quadTo(SkBits2Float(0x3e484500), SkBits2Float(0x164f3a30), SkBits2Float(0x49484801), SkBits2Float(0x7d0100c8));  // 0.195576f, 1.67397e-25f, 820352, 1.07172e+37f
10192 path.conicTo(SkBits2Float(0xff7f36fd), SkBits2Float(0x3e647d01), SkBits2Float(0x0c00f430), SkBits2Float(0x486b6448), SkBits2Float(0x00484848));  // -3.39239e+38f, 0.223133f, 9.93424e-32f, 241041, 6.63809e-39f
10193 path.lineTo(SkBits2Float(0x4f4f557d), SkBits2Float(0x48480112));  // 3.47849e+09f, 204804
10194 path.lineTo(SkBits2Float(0xf40c01ff), SkBits2Float(0x45008000));  // -4.43702e+31f, 2056
10195 path.moveTo(SkBits2Float(0x4bfffa00), SkBits2Float(0x7d4ac859));  // 3.35514e+07f, 1.68465e+37f
10196 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
10198     SkPath path2(path);
10204     SkPath path;
10205     path.setFillType((SkPathFillType) 1);
10207     SkPath path1(path);
10208     path.reset();
10209     path.setFillType((SkPathFillType) 0);
10210 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55));  // 4.76191e+16f, 5.7784e-19f
10211 path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003));  // 0.00245715f, 1.64987e+07f
10212 path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21));  // 2.50338e-13f, 4.61198e-19f
10213 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
10214 path.lineTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003));  // 0.00245715f, 1.64987e+07f
10215 path.close();
10216 path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003));  // 0.00245715f, 1.64987e+07f
10217 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
10218 path.lineTo(SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321));  // 4.78968e-34f, 1.99397e+36f
10219 path.lineTo(SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28));  // 9.4495e-15f, 0.000617492f
10220 path.lineTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003));  // 0.00245715f, 1.64987e+07f
10221 path.close();
10222 path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003));  // 0.00245715f, 1.64987e+07f
10223 path.quadTo(SkBits2Float(0x8a4fc29a), SkBits2Float(0x3ab3283a), SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6));  // -1.00033e-32f, 0.00136686f, 2.25206e-21f, 300.343f
10224 path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829));  // 4.87419e+16f, 3.71718e-14f
10225 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
10226 path.quadTo(SkBits2Float(0xc25d2757), SkBits2Float(0x3a705921), SkBits2Float(0x2a105152), SkBits2Float(0x28d91210));  // -55.2884f, 0.000916855f, 1.2818e-13f, 2.40997e-14f
10227 path.quadTo(SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21));  // 3.19905e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f
10228 path.lineTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829));  // 4.87419e+16f, 3.71718e-14f
10229 path.close();
10230 path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829));  // 4.87419e+16f, 3.71718e-14f
10231 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
10232 path.lineTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829));  // 4.87419e+16f, 3.71718e-14f
10233 path.close();
10234 path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829));  // 4.87419e+16f, 3.71718e-14f
10235 path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x2d8a3a21), SkBits2Float(0x5b682b68), SkBits2Float(0x5b292d55));  // -1.2117e+19f, 1.57146e-11f, 6.53499e+16f, 4.76191e+16f
10236 path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x0321081f));  // 1.43144e-13f, 4.7323e-37f
10237 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
10238 path.moveTo(SkBits2Float(0x21df2828), SkBits2Float(0x9a3a8a3a));  // 1.51217e-18f, -3.85756e-23f
10239 path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x28273ac2), SkBits2Float(0xe61d2a29), SkBits2Float(0x2a63962b));  // 0.00136978f, 9.2831e-15f, -1.85547e+23f, 2.02138e-13f
10240 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
10241 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10242 path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3));  // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
10243 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10244 path.close();
10246     SkPath path2(path);
10251     SkPath path;
10252     path.setFillType((SkPathFillType) 1);
10254 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x36344a4a));  // 0, 2.68653e-06f
10255 path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x364a4a4a), SkBits2Float(0x364a4a4a), SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0, 3.01436e-06f, 3.01436e-06f, 0, 0
10256 path.lineTo(SkBits2Float(0x364a4a4a), SkBits2Float(0x00000000));  // 3.01436e-06f, 0
10257 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
10258 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
10259 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
10260 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
10261 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
10262 path.close();
10263     SkPath path1(path);
10264     path.reset();
10265     path.setFillType((SkPathFillType) 0);
10266 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10267 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
10268 path.moveTo(SkBits2Float(0x000010a1), SkBits2Float(0x19312000));  // 5.96533e-42f, 9.15715e-24f
10269 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
10270 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
10271     SkPath path2(path);
10276     SkPath path;
10277     path.setFillType((SkPathFillType) 1);
10278 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f));  // 0, 5.14279e+25f
10279 path.cubicTo(SkBits2Float(0x68295b2d), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x68556829));  // 3.19905e+24f, 0, 0, 0, 0, 4.03114e+24f
10280 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a));  // 0, 4.03018e+24f
10281 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
10282 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
10283 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
10284 path.conicTo(SkBits2Float(0x68295b02), SkBits2Float(0x60f7f28b), SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f), SkBits2Float(0x42784f5a));  // 3.19903e+24f, 1.42932e+20f, 0, 5.14279e+25f, 62.0775f
10285 path.close();
10286 path.moveTo(SkBits2Float(0x654d6d10), SkBits2Float(0x00000000));  // 6.06311e+22f, 0
10287 path.lineTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000));  // 6.14991e+25f, 0
10288 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc0));  // 0, 6.14991e+25f
10289 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10291     SkPath path1(path);
10292     path.reset();
10293     path.setFillType((SkPathFillType) 0);
10294 path.moveTo(SkBits2Float(0x3ac23a55), SkBits2Float(0x2a292827));  // 0.00148184f, 1.50241e-13f
10295 path.lineTo(SkBits2Float(0x63962be6), SkBits2Float(0x272a812a));  // 5.54035e+21f, 2.36623e-15f
10297     SkPath path2(path);
10302     SkPath path;
10303     path.setFillType((SkPathFillType) 0);
10305     SkPath path1(path);
10306     path.reset();
10307     path.setFillType((SkPathFillType) 0);
10308 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
10309 path.moveTo(SkBits2Float(0x0f2a312a), SkBits2Float(0xc0032108));  // 8.39112e-30f, -2.04889f
10310 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
10311 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
10312 path.moveTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955));  // 3.40683e+24f, -2.87402e+29f
10313 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
10314 path.lineTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955));  // 3.40683e+24f, -2.87402e+29f
10315 path.close();
10316 path.moveTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955));  // 3.40683e+24f, -2.87402e+29f
10317 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55));  // 4.85282e+16f, 5.7784e-19f
10318 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10319 path.lineTo(SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a281a4f));  // 0.00105461f, -8.09385e-33f
10320 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529));  // 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f
10321 path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720));  // 6.3398e-19f, 2.34747e-15f
10322 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
10323 path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x683a5b2d));  // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.52017e+24f
10324 path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568));  // 4.86672e-14f, 5.15884e-14f
10325 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
10326 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
10327 path.quadTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21));  // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f
10328 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10329 path.close();
10330 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10331 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
10332 path.moveTo(SkBits2Float(0x2d212d08), SkBits2Float(0x5568295b));  // 9.16179e-12f, 1.5954e+13f
10333 path.moveTo(SkBits2Float(0x5529685b), SkBits2Float(0x11295b68));  // 1.16416e+13f, 1.33599e-28f
10334 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
10335 path.moveTo(SkBits2Float(0x555b8c55), SkBits2Float(0x21682929));  // 1.50872e+13f, 7.86591e-19f
10336 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10337 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
10338 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10339 path.close();
10340 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10341 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
10342 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10343 path.close();
10344 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10345 path.quadTo(SkBits2Float(0x2d28282a), SkBits2Float(0x5568295b), SkBits2Float(0x3a21df68), SkBits2Float(0x4f9a3a8a));  // 9.55861e-12f, 1.5954e+13f, 0.000617495f, 5.17506e+09f
10346 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10347 path.close();
10348 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10349 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
10351     SkPath path2(path);
10357     SkPath path;
10358 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa));  // 0, -6.51268e+35f
10359 path.close();
10360 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa));  // 0, -6.51268e+35f
10361 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
10362 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa));  // 0, -6.51268e+35f
10363 path.close();
10364 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa));  // 0, -6.51268e+35f
10365 path.lineTo(SkBits2Float(0x60601a1d), SkBits2Float(0x60606060));  // 6.4593e+19f, 6.46721e+19f
10366 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa));  // 0, -6.51268e+35f
10367 path.close();
10368 path.moveTo(SkBits2Float(0xe5e2f300), SkBits2Float(0xee244a40));  // -1.33967e+23f, -1.27113e+28f
10369 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a));  // -0.0011673f, -6.51573e+35f
10370 path.close();
10371 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a));  // -0.0011673f, -6.51573e+35f
10372 path.lineTo(SkBits2Float(0xfafafafa), SkBits2Float(0xe30000fa));  // -6.51582e+35f, -2.36125e+21f
10373 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
10374 path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a));  // -0.0011673f, -6.51573e+35f
10375 path.close();
10376 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a));  // -0.0011673f, -6.51573e+35f
10377 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
10378 path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a));  // -0.0011673f, -6.51573e+35f
10379 path.close();
10380 path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a));  // -0.0011673f, -6.51573e+35f
10381 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
10382 path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a));  // -0.0011673f, -6.51573e+35f
10383 path.close();
10384 SkPath path2(path);
10389     SkPath path;
10390     path.setFillType((SkPathFillType) 1);
10391 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x68556829));  // 0, 4.03114e+24f
10392 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10393 path.quadTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4));  // 6.14991e+25f, 0, 0, 6.14991e+25f
10394 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68556829));  // 0, 4.03114e+24f
10395 path.close();
10397     SkPath path1(path);
10398     path.reset();
10399     path.setFillType((SkPathFillType) 0);
10400 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10401 path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x2a8c8f55));  // 4.87407e+16f, 2.49685e-13f
10402 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10403 path.close();
10404 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03));  // -2.51765f, 6.14982e+25f
10405 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
10406 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03));  // -2.51765f, 6.14982e+25f
10407 path.close();
10408 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03));  // -2.51765f, 6.14982e+25f
10409 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a29));  // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121588
10410 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03));  // -2.51765f, 6.14982e+25f
10411 path.close();
10412 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03));  // -2.51765f, 6.14982e+25f
10413 path.quadTo(SkBits2Float(0x6829682d), SkBits2Float(0x292d555b), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a29));  // 3.20001e+24f, 3.84878e-14f, 2.49282e-13f, 4.78969e-34f
10414 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
10415 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03));  // -2.51765f, 6.14982e+25f
10416 path.close();
10417 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03));  // -2.51765f, 6.14982e+25f
10418 path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3a21df), SkBits2Float(0x2728282a), SkBits2Float(0x8a3a2129));  // 9.4456e-15f, -8.96194e-33f, 2.33365e-15f, -8.96181e-33f
10419 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3a3ac2b3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d));  // -8.10388e-33f, 0.000712435f, 1.50241e-13f, -1.38859e-25f
10420 path.lineTo(SkBits2Float(0x272a802a), SkBits2Float(0x2a8c2d29));  // 2.36617e-15f, 2.49003e-13f
10421 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03));  // -2.51765f, 6.14982e+25f
10422 path.close();
10423 path.moveTo(SkBits2Float(0x4f9a3a29), SkBits2Float(0x3ab38a28));  // 5.17501e+09f, 0.00136978f
10424 path.quadTo(SkBits2Float(0xc368305b), SkBits2Float(0x5b296855), SkBits2Float(0x2d8c5568), SkBits2Float(0x1f2a2172));  // -232.189f, 4.7684e+16f, 1.59541e-11f, 3.60266e-20f
10425 path.lineTo(SkBits2Float(0x29c00321), SkBits2Float(0x5b4b7b13));  // 8.52706e-14f, 5.72747e+16f
10427     SkPath path2(path);
10432     SkPath path;
10433     path.setFillType((SkPathFillType) 0);
10435     SkPath path1(path);
10436     path.reset();
10437     path.setFillType((SkPathFillType) 0);
10438 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
10439 path.moveTo(SkBits2Float(0x2a0f312a), SkBits2Float(0xc0032108));  // 1.2718e-13f, -2.04889f
10440 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
10441 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
10442 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955));  // 3.48239e+24f, 2.87402e+29f
10443 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
10444 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955));  // 3.48239e+24f, 2.87402e+29f
10445 path.close();
10446 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955));  // 3.48239e+24f, 2.87402e+29f
10447 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55));  // 4.85282e+16f, 5.7784e-19f
10448 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10449 path.lineTo(SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a281a4f));  // 0.00105461f, -8.09385e-33f
10450 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x2a812a3b), SkBits2Float(0x2a552927));  // 2.25206e-21f, 300.343f, 2.29443e-13f, 1.89325e-13f
10451 path.quadTo(SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x203a3b27), SkBits2Float(0x22c5381f));  // 0.00241343f, 3.71093e-14f, 1.57744e-19f, 5.34564e-18f
10452 path.moveTo(SkBits2Float(0x5d27ec2a), SkBits2Float(0x705921c2));  // 7.56256e+17f, 2.68796e+29f
10453 path.quadTo(SkBits2Float(0x102a5152), SkBits2Float(0x5b2dd912), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 3.35892e-29f, 4.89338e+16f, 4.03114e+24f, 1.50617e+13f
10454 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032127));  // 3.60396e-20f, -2.0489f
10455 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
10456 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
10457 path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955));  // 1.64629e-13f, -2.87402e+29f
10458 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
10459 path.lineTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955));  // 1.64629e-13f, -2.87402e+29f
10460 path.close();
10461 path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955));  // 1.64629e-13f, -2.87402e+29f
10462 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x2a21211f));  // 4.85282e+16f, 1.43112e-13f
10463 path.lineTo(SkBits2Float(0x03552a8c), SkBits2Float(0x6a4f7b28));  // 6.26439e-37f, 6.27073e+25f
10464 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
10465 path.lineTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955));  // 1.64629e-13f, -2.87402e+29f
10466 path.close();
10467 path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955));  // 1.64629e-13f, -2.87402e+29f
10468 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x262a812a), SkBits2Float(0x3a2a5529));  // 2.25206e-21f, 300.343f, 5.91556e-16f, 0.000649768f
10469 path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720));  // 6.3398e-19f, 2.34747e-15f
10470 path.conicTo(SkBits2Float(0x371f203a), SkBits2Float(0xc52a22c4), SkBits2Float(0xc25d27ec), SkBits2Float(0x3a705921), SkBits2Float(0x5210513a));  // 9.48464e-06f, -2722.17f, -55.289f, 0.000916855f, 1.5496e+11f
10471 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
10472 path.moveTo(SkBits2Float(0x682d6829), SkBits2Float(0x29685555));  // 3.27556e+24f, 5.15884e-14f
10473 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
10474 path.quadTo(SkBits2Float(0x2d685568), SkBits2Float(0x5568295b), SkBits2Float(0x2a552d29), SkBits2Float(0x295b2d27));  // 1.32066e-11f, 1.5954e+13f, 1.89339e-13f, 4.86669e-14f
10475 path.lineTo(SkBits2Float(0x682d6829), SkBits2Float(0x29685555));  // 3.27556e+24f, 5.15884e-14f
10476 path.close();
10478     SkPath path2(path);
10483     SkPath path;
10484     path.setFillType((SkPathFillType) 1);
10485 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10486 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a29082a));  // 0, 5.10868e+25f
10487 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
10488 path.conicTo(SkBits2Float(0x67aedf99), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x3f801112));  // 1.65163e+24f, 0, 0, 0, 1.00052f
10489 path.close();
10490 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10491 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 6.14991e+25f, 0, 0, 4.03114e+24f, 1.50617e+13f
10492 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a));  // 0, 4.03018e+24f
10493 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
10494 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
10495 path.cubicTo(SkBits2Float(0x679158b0), SkBits2Float(0x00000000), SkBits2Float(0x67531e34), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 1.37276e+24f, 0, 9.96976e+23f, 0, 0, 0
10496 path.close();
10498     SkPath path1(path);
10499     path.reset();
10500     path.setFillType((SkPathFillType) 0);
10501 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10502 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
10503 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10504 path.close();
10505 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10506 path.lineTo(SkBits2Float(0x3a6821df), SkBits2Float(0x2a8c3a8a));  // 0.000885514f, 2.49096e-13f
10507 path.moveTo(SkBits2Float(0x29272a1d), SkBits2Float(0xb03a2a55));  // 3.7118e-14f, -6.77266e-10f
10508 path.moveTo(SkBits2Float(0x20213b1e), SkBits2Float(0xc5272927));  // 1.36568e-19f, -2674.57f
10509 path.quadTo(SkBits2Float(0xc422373b), SkBits2Float(0xec2a201f), SkBits2Float(0x21c25d27), SkBits2Float(0x523a7059));  // -648.863f, -8.22676e+26f, 1.31706e-18f, 2.00187e+11f
10510 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
10511 path.moveTo(SkBits2Float(0x68556809), SkBits2Float(0x555b2d29));  // 4.03113e+24f, 1.50617e+13f
10512 path.moveTo(SkBits2Float(0x1f2a212a), SkBits2Float(0x2d032108));  // 3.60263e-20f, 7.45382e-12f
10513 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x2a552d29));  // 4.03114e+24f, 1.89339e-13f
10514 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
10516     SkPath path2(path);
10521     SkPath path;
10522     path.setFillType((SkPathFillType) 1);
10524     SkPath path1(path);
10525     path.reset();
10526     path.setFillType((SkPathFillType) 0);
10527 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a));  // 5.7784e-19f, 4.61198e-19f
10528 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0x3adf2128), SkBits2Float(0x4f1a3a8a));  // 6.14991e+25f, 75739, 9.4495e-15f, 0.00170234f, 2.58753e+09f
10529 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a));  // 5.7784e-19f, 4.61198e-19f
10530 path.close();
10531 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a));  // 5.7784e-19f, 4.61198e-19f
10532 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
10533 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a));  // 5.7784e-19f, 4.61198e-19f
10534 path.close();
10535 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a));  // 5.7784e-19f, 4.61198e-19f
10536 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
10537 path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x68295b2d));  // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.19905e+24f
10538 path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568));  // 4.86672e-14f, 5.15884e-14f
10539 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
10540 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
10541 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
10542 path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a));  // 5.7784e-19f, 4.61198e-19f
10543 path.close();
10544 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a));  // 5.7784e-19f, 4.61198e-19f
10545 path.lineTo(SkBits2Float(0x5b2d6829), SkBits2Float(0x212a8c55));  // 4.88097e+16f, 5.7784e-19f
10546 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
10547 path.lineTo(SkBits2Float(0x68295b68), SkBits2Float(0x2d296855));  // 3.19906e+24f, 9.6297e-12f
10548 path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a));  // 5.7784e-19f, 4.61198e-19f
10549 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
10550 path.quadTo(SkBits2Float(0x6028282a), SkBits2Float(0x68292ddf), SkBits2Float(0x5b2d555b), SkBits2Float(0x68556829));  // 4.84679e+19f, 3.1957e+24f, 4.8789e+16f, 4.03114e+24f
10552     SkPath path2(path);
10557     SkPath path;
10558     path.setFillType((SkPathFillType) 0);
10560     SkPath path1(path);
10561     path.reset();
10562     path.setFillType((SkPathFillType) 0);
10563 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0xf45b2d29));  // 4.03114e+24f, -6.94598e+31f
10564 path.moveTo(SkBits2Float(0x1f2a302a), SkBits2Float(0xc8032108));  // 3.60387e-20f, -134276
10565 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
10567     SkPath path2(path);
10572     SkPath path;
10573     path.setFillType((SkPathFillType) 1);
10575     SkPath path1(path);
10576     path.reset();
10577     path.setFillType((SkPathFillType) 0);
10578 path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55));  // 4.76191e+16f, 5.7784e-19f
10579 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4));  // 4.7323e-37f, 7.11705e+25f
10580 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
10581 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4));  // 4.7323e-37f, 7.11705e+25f
10582 path.close();
10583 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4));  // 4.7323e-37f, 7.11705e+25f
10584 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
10585 path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x283ac221), SkBits2Float(0xe6432a29), SkBits2Float(0x2a96812b));  // 0.00136978f, 1.03672e-14f, -2.3041e+23f, 2.6735e-13f
10586 path.lineTo(SkBits2Float(0x5529272a), SkBits2Float(0x1eb03a2a));  // 1.16241e+13f, 1.86588e-20f
10587 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
10588 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4));  // 4.7323e-37f, 7.11705e+25f
10589 path.close();
10590 path.moveTo(SkBits2Float(0x1051523a), SkBits2Float(0xd912102a));  // 4.12813e-29f, -2.56957e+15f
10591 path.close();
10592 path.moveTo(SkBits2Float(0x1051523a), SkBits2Float(0xd912102a));  // 4.12813e-29f, -2.56957e+15f
10593 path.quadTo(SkBits2Float(0xc82763e7), SkBits2Float(0x2927b029), SkBits2Float(0x295b2d27), SkBits2Float(0x2d685568));  // -171408, 3.72342e-14f, 4.86669e-14f, 1.32066e-11f
10594 path.moveTo(SkBits2Float(0x68556809), SkBits2Float(0x8c555b2d));  // 4.03113e+24f, -1.64364e-31f
10595 path.moveTo(SkBits2Float(0x081f2a21), SkBits2Float(0x252d0321));  // 4.78968e-34f, 1.50064e-16f
10596 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x5b2df068));  // 1.59583e+13f, 4.89595e+16f
10597 path.quadTo(SkBits2Float(0x2a1f2a8c), SkBits2Float(0x21482a21), SkBits2Float(0x4b7bc003), SkBits2Float(0x8ced3a6a));  // 1.41368e-13f, 6.78184e-19f, 1.64987e+07f, -3.65508e-31f
10598 path.moveTo(SkBits2Float(0x21481f21), SkBits2Float(0x4b7bc003));  // 6.78038e-19f, 1.64987e+07f
10599 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
10600 path.lineTo(SkBits2Float(0x21481f21), SkBits2Float(0x4b7bc003));  // 6.78038e-19f, 1.64987e+07f
10601 path.close();
10602 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03));  // -2.51765f, 6.14982e+25f
10603 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
10604 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03));  // -2.51765f, 6.14982e+25f
10605 path.close();
10606 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03));  // -2.51765f, 6.14982e+25f
10607 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
10608 path.quadTo(SkBits2Float(0x6829682d), SkBits2Float(0x292d555b), SkBits2Float(0x292a8c55), SkBits2Float(0x21081f2a));  // 3.20001e+24f, 3.84878e-14f, 3.78693e-14f, 4.61198e-19f
10609 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
10610 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03));  // -2.51765f, 6.14982e+25f
10611 path.close();
10612 path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03));  // -2.51765f, 6.14982e+25f
10613 path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3a21df), SkBits2Float(0x2728282a), SkBits2Float(0x8a3a21df));  // 9.4456e-15f, -8.96194e-33f, 2.33365e-15f, -8.96194e-33f
10614 path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3a3ac2b3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d));  // -8.10388e-33f, 0.000712435f, 1.50241e-13f, -1.38859e-25f
10615 path.lineTo(SkBits2Float(0x272a802a), SkBits2Float(0x2a8c2d29));  // 2.36617e-15f, 2.49003e-13f
10616 path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03));  // -2.51765f, 6.14982e+25f
10617 path.close();
10618 path.moveTo(SkBits2Float(0x4f9a3a29), SkBits2Float(0x3ab38a28));  // 5.17501e+09f, 0.00136978f
10619 path.quadTo(SkBits2Float(0xc368305b), SkBits2Float(0x5b296855), SkBits2Float(0x2d8c5568), SkBits2Float(0x1f2a2172));  // -232.189f, 4.7684e+16f, 1.59541e-11f, 3.60266e-20f
10620 path.lineTo(SkBits2Float(0x29c00321), SkBits2Float(0x5b4b7b13));  // 8.52706e-14f, 5.72747e+16f
10622     SkPath path2(path);
10627     SkPath path;
10628     path.setFillType((SkPathFillType) 0);
10630     SkPath path1(path);
10631     path.reset();
10632     path.setFillType((SkPathFillType) 0);
10633 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
10634 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
10635 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
10636 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
10637 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955));  // 3.35016e+24f, -2.87402e+29f
10638 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
10639 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955));  // 3.35016e+24f, -2.87402e+29f
10640 path.close();
10641 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955));  // 3.35016e+24f, -2.87402e+29f
10642 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55));  // 4.85282e+16f, 5.7784e-19f
10643 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10644 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
10645 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
10646 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10647 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
10648 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10649 path.close();
10650 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10651 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3));  // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f
10652 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10653 path.close();
10654 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10655 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29));  // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
10656 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10657 path.close();
10658 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10659 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
10660 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
10661 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10662 path.close();
10663 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d));  // 3.19839e+24f, 1.21279e-11f
10664 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
10665 path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0xc0032108));  // 3.60404e-20f, -2.04889f
10666 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
10667 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
10668 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955));  // 3.33127e+24f, -2.87402e+29f
10669 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
10670 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955));  // 3.33127e+24f, -2.87402e+29f
10671 path.close();
10672 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955));  // 3.33127e+24f, -2.87402e+29f
10673 path.lineTo(SkBits2Float(0x555b6829), SkBits2Float(0x6c212a8c));  // 1.50775e+13f, 7.79352e+26f
10674 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
10675 path.lineTo(SkBits2Float(0x8c558c55), SkBits2Float(0x212a1f2a));  // -1.64512e-31f, 5.76395e-19f
10677     SkPath path2(path);
10682     SkPath path;
10683     path.setFillType((SkPathFillType) 0);
10685     SkPath path1(path);
10686     path.reset();
10687     path.setFillType((SkPathFillType) 0);
10688 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
10689 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
10690 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
10691 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
10692 path.moveTo(SkBits2Float(0x6835282d), SkBits2Float(0xf0682955));  // 3.42196e+24f, -2.87402e+29f
10693 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
10694 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55));  // 4.85282e+16f, 5.7784e-19f
10695 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10696 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
10697 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
10698 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10699 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
10700 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3));  // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
10701 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29));  // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
10702 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10703 path.close();
10704 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10705 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
10706 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
10707 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10708 path.close();
10709 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d));  // 3.19839e+24f, 1.21279e-11f
10710 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
10711 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
10712 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
10713 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
10714 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10715 path.lineTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x2a212a1f));  // 2.49282e-13f, 1.43143e-13f
10716 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10717 path.close();
10718 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10719 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x2a1f08c0));  // -1.31678e-31f, 1.41251e-13f
10720 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10721 path.close();
10722 path.moveTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d));  // 2.50351e-13f, 3.19905e+24f
10723 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
10724 path.lineTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d));  // 2.50351e-13f, 3.19905e+24f
10725 path.close();
10726 path.moveTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d));  // 2.50351e-13f, 3.19905e+24f
10727 path.lineTo(SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a));  // 1.16348e+26f, 0.000209024f
10729     SkPath path2(path);
10734     SkPath path;
10735     path.setFillType((SkPathFillType) 0);
10737     SkPath path1(path);
10738     path.reset();
10739     path.setFillType((SkPathFillType) 0);
10740 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
10741 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
10742 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
10743 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
10744 path.moveTo(SkBits2Float(0x6835282d), SkBits2Float(0xf0682955));  // 3.42196e+24f, -2.87402e+29f
10745 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
10746 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55));  // 4.85282e+16f, 5.7784e-19f
10747 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10748 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
10749 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
10750 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10751 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
10752 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3));  // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
10753 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29));  // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
10754 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10755 path.close();
10756 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10757 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
10758 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
10759 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10760 path.close();
10761 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d));  // 3.19839e+24f, 1.21279e-11f
10762 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
10763 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
10764 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
10765 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
10766 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10767 path.lineTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x2a212a1f));  // 2.49282e-13f, 1.43143e-13f
10768 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10769 path.close();
10770 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10771 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x2a1f08c0));  // -1.31678e-31f, 1.41251e-13f
10773 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d));  // 3.19839e+24f, 1.21279e-11f
10774 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
10775 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
10776 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
10777 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
10778 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
10780     SkPath path2(path);
10785     SkPath path;
10786     path.setFillType((SkPathFillType) 1);
10788     SkPath path1(path);
10789     path.reset();
10790     path.setFillType((SkPathFillType) 0);
10791 path.moveTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003));  // 4.61198e-19f, 1.64987e+07f
10792 path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d));  // 9.43289e-15f, 1.61207e+25f
10793 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955));  // 3.33127e+24f, -2.87402e+29f
10794 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
10795 path.moveTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55));  // 4.85282e+16f, 5.7784e-19f
10796 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10797 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
10798 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
10799 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10800 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
10801 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3));  // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
10802 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29));  // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
10803 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10804 path.close();
10805 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10806 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
10807 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
10808 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10809 path.close();
10810 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d));  // 3.19839e+24f, 1.21279e-11f
10811 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
10812 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
10813 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
10814 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
10815 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10816 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
10817 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10818 path.close();
10819 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10820 path.lineTo(SkBits2Float(0x555b2c29), SkBits2Float(0x6c212a8c));  // 1.50614e+13f, 7.79352e+26f
10821 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
10822 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
10823 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10824 path.close();
10825 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10826 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x1f2128c0));  // -1.31678e-31f, 3.41268e-20f
10827 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10828 path.close();
10830     SkPath path2(path);
10835     SkPath path;
10836     path.setFillType((SkPathFillType) 0);
10838     SkPath path1(path);
10839     path.reset();
10840     path.setFillType((SkPathFillType) 0);
10841 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
10842 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
10843 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
10844 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
10845 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955));  // 3.33127e+24f, -2.87402e+29f
10846 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
10847 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55));  // 4.85282e+16f, 5.7784e-19f
10848 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10849 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
10850 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
10851 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10852 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
10853 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10854 path.close();
10855 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10856 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3));  // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f
10857 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10858 path.close();
10859 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10860 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29));  // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
10861 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10862 path.close();
10863 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10864 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
10865 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
10866 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
10867 path.close();
10868 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d));  // 3.19839e+24f, 1.21279e-11f
10869 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x8c555b2d));  // 4.03114e+24f, -1.64364e-31f
10870 path.moveTo(SkBits2Float(0x081f2a31), SkBits2Float(0xc0032921));  // 4.78969e-34f, -2.04939f
10871 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
10872 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
10873 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10874 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
10875 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10876 path.close();
10877 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10878 path.lineTo(SkBits2Float(0x555b6829), SkBits2Float(0x6c212a8c));  // 1.50775e+13f, 7.79352e+26f
10879 path.lineTo(SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556830));  // 4.88298e+16f, -2.64185e+29f
10880 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10881 path.close();
10882 path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10883 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
10884 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x212128c0));  // -1.31678e-31f, 5.46029e-19f
10885 path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955));  // 3.50128e+24f, -2.87402e+29f
10886 path.close();
10888     SkPath path2(path);
10893     SkPath path;
10894     path.setFillType((SkPathFillType) 1);
10895 path.moveTo(SkBits2Float(0x6828c6f9), SkBits2Float(0x6614dc9e));  // 3.18811e+24f, 1.75745e+23f
10896 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
10897 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
10898 path.lineTo(SkBits2Float(0x6828c6f9), SkBits2Float(0x6614dc9e));  // 3.18811e+24f, 1.75745e+23f
10899 path.close();
10900 path.moveTo(SkBits2Float(0x68226c73), SkBits2Float(0x660bd15e));  // 3.0681e+24f, 1.65068e+23f
10901 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
10902 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
10903 path.lineTo(SkBits2Float(0x6828d720), SkBits2Float(0x6604a1a2));  // 3.1893e+24f, 1.56583e+23f
10904 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
10905 path.conicTo(SkBits2Float(0x6822e012), SkBits2Float(0x6602acc5), SkBits2Float(0x68226c73), SkBits2Float(0x660bd15e), SkBits2Float(0x3f7ffa04));  // 3.07663e+24f, 1.54274e+23f, 3.0681e+24f, 1.65068e+23f, 0.999909f
10906 path.close();
10907 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f));  // 0, 5.14279e+25f
10908 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a));  // 0, 4.03018e+24f
10909 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
10910 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
10911 path.close();
10912 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f));  // 0, 5.14279e+25f
10913 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4));  // 0, 6.14991e+25f
10914 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
10915 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
10916 path.conicTo(SkBits2Float(0x68295b21), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x492bb324));  // 3.19904e+24f, 0, 0, 0, 703282
10917 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
10918 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68156829));  // 0, 2.82222e+24f
10919 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a));  // 0, 4.03018e+24f
10920 path.lineTo(SkBits2Float(0x673918f3), SkBits2Float(0x681b0f5f));  // 8.74098e+23f, 2.929e+24f
10921 path.lineTo(SkBits2Float(0x67391759), SkBits2Float(0x681b0fae));  // 8.74068e+23f, 2.92902e+24f
10922 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
10923 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
10924 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f));  // 0, 5.14279e+25f
10925 path.close();
10927     SkPath path1(path);
10928     path.reset();
10929     path.setFillType((SkPathFillType) 0);
10931     SkPath path2(path);
10936     SkPath path;
10937     path.setFillType((SkPathFillType) 1);
10938 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x68295b2d));  // 0, 3.19905e+24f
10939 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10940 path.lineTo(SkBits2Float(0x6a3a7bc0), SkBits2Float(0x00000000));  // 5.63611e+25f, 0
10941 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a034b21));  // 0, 3.9681e+25f
10942 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68295b2d));  // 0, 3.19905e+24f
10943 path.close();
10944 path.moveTo(SkBits2Float(0x6617da56), SkBits2Float(0x00000000));  // 1.79276e+23f, 0
10945 path.conicTo(SkBits2Float(0x5e704d09), SkBits2Float(0x5e3a4dfd), SkBits2Float(0x00000000), SkBits2Float(0x65eb62ef), SkBits2Float(0x430fa5e6));  // 4.32888e+18f, 3.35617e+18f, 0, 1.38948e+23f, 143.648f
10946 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
10947 path.conicTo(SkBits2Float(0x62743d2d), SkBits2Float(0x5e49b862), SkBits2Float(0x6617da56), SkBits2Float(0x00000000), SkBits2Float(0x410ef54c));  // 1.12635e+21f, 3.63387e+18f, 1.79276e+23f, 0, 8.93489f
10948 path.close();
10950     SkPath path1(path);
10951     path.reset();
10952     path.setFillType((SkPathFillType) 0);
10953 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
10954 path.quadTo(SkBits2Float(0x4f9a3a8a), SkBits2Float(0xc28a0d28), SkBits2Float(0x273a3ab3), SkBits2Float(0x8b2a2928));  // 5.17506e+09f, -69.0257f, 2.58445e-15f, -3.27718e-32f
10955 path.lineTo(SkBits2Float(0x63283ae6), SkBits2Float(0x27282a81));  // 3.1033e+21f, 2.33377e-15f
10957     SkPath path2(path);
10962     SkPath path;
10963     path.setFillType((SkPathFillType) 0);
10965     SkPath path1(path);
10966     path.reset();
10967     path.setFillType((SkPathFillType) 0);
10968 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
10969 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
10970 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
10971 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
10972 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955));  // 3.33127e+24f, -2.87402e+29f
10973 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
10974 path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955));  // 3.33127e+24f, -2.87402e+29f
10975 path.close();
10976 path.moveTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55));  // 4.85282e+16f, 5.7784e-19f
10977 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
10978 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
10979 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
10980 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10981 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
10982 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3));  // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
10983 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29));  // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
10984 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10985 path.close();
10986 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10987 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
10988 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
10989 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527));  // 3.35016e+24f, -2.87614e+29f
10990 path.close();
10991 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d));  // 3.19839e+24f, 1.21279e-11f
10992 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
10993 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
10994 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
10995 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
10996 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
10998     SkPath path2(path);
11003     SkPath path;
11004     path.setFillType((SkPathFillType) 1);
11006     SkPath path1(path);
11007     path.reset();
11008     path.setFillType((SkPathFillType) 0);
11009 path.moveTo(SkBits2Float(0xededed02), SkBits2Float(0xedededed));  // -9.20431e+27f, -9.20445e+27f
11010 path.close();
11011 path.moveTo(SkBits2Float(0xededed02), SkBits2Float(0xedededed));  // -9.20431e+27f, -9.20445e+27f
11012 path.quadTo(SkBits2Float(0x9fb9c16e), SkBits2Float(0x27737375), SkBits2Float(0xb7c5ff00), SkBits2Float(0x00ff9908));  // -7.86706e-20f, 3.37856e-15f, -2.3603e-05f, 2.34729e-38f
11013 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273));  // 1.9288e+31f, 1.9278e+31f
11014 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
11015 path.quadTo(SkBits2Float(0x04007f41), SkBits2Float(0xecececec), SkBits2Float(0xecececec), SkBits2Float(0xecec41ec));  // 1.51048e-36f, -2.2914e+27f, -2.2914e+27f, -2.28494e+27f
11016 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273));  // 1.9288e+31f, 1.9278e+31f
11017 path.close();
11018 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273));  // 1.9288e+31f, 1.9278e+31f
11019 path.quadTo(SkBits2Float(0x000000ec), SkBits2Float(0xececcc00), SkBits2Float(0x48ececec), SkBits2Float(0x0278806e));  // 3.30706e-43f, -2.29016e+27f, 485223, 1.8257e-37f
11020 path.lineTo(SkBits2Float(0x72ececec), SkBits2Float(0xecec02ec));  // 9.38559e+30f, -2.28256e+27f
11021 path.quadTo(SkBits2Float(0xec04007f), SkBits2Float(0xecececec), SkBits2Float(0xecececec), SkBits2Float(0xecec0400));  // -6.38322e+26f, -2.2914e+27f, -2.2914e+27f, -2.2826e+27f
11022 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273));  // 1.9288e+31f, 1.9278e+31f
11023 path.close();
11024 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273));  // 1.9288e+31f, 1.9278e+31f
11025 path.quadTo(SkBits2Float(0x000040ec), SkBits2Float(0x3a333300), SkBits2Float(0xecec3333), SkBits2Float(0xececdbec));  // 2.32896e-41f, 0.000683591f, -2.28439e+27f, -2.29076e+27f
11026 path.lineTo(SkBits2Float(0x3300007f), SkBits2Float(0x33d83333));  // 2.98028e-08f, 1.00676e-07f
11027 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273));  // 1.9288e+31f, 1.9278e+31f
11028 path.close();
11029 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273));  // 1.9288e+31f, 1.9278e+31f
11030 path.quadTo(SkBits2Float(0x9e9ea900), SkBits2Float(0x33ececec), SkBits2Float(0xececec33), SkBits2Float(0xec336e6e));  // -1.67988e-20f, 1.10327e-07f, -2.29138e+27f, -8.67677e+26f
11031 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273));  // 1.9288e+31f, 1.9278e+31f
11032 path.close();
11033 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273));  // 1.9288e+31f, 1.9278e+31f
11034 path.lineTo(SkBits2Float(0xedededed), SkBits2Float(0xedededed));  // -9.20445e+27f, -9.20445e+27f
11035 path.lineTo(SkBits2Float(0xecececec), SkBits2Float(0xecececec));  // -2.2914e+27f, -2.2914e+27f
11036 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273));  // 1.9288e+31f, 1.9278e+31f
11037 path.close();
11038 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273));  // 1.9288e+31f, 1.9278e+31f
11039 path.lineTo(SkBits2Float(0x01003300), SkBits2Float(0x33d83333));  // 2.35465e-38f, 1.00676e-07f
11040 path.quadTo(SkBits2Float(0xecec3333), SkBits2Float(0x04eeedec), SkBits2Float(0xe0e0e0e0), SkBits2Float(0x9ee0e0e0));  // -2.28439e+27f, 5.6172e-36f, -1.29634e+20f, -2.38099e-20f
11041 path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273));  // 1.9288e+31f, 1.9278e+31f
11042 path.close();
11043 path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273));  // 1.9288e+31f, 1.9278e+31f
11044 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
11045 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
11047     SkPath path2(path);
11052     SkPath path;
11053     path.setFillType((SkPathFillType) 1);
11054 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4));  // 0, 6.14991e+25f
11055 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
11056 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
11057 path.lineTo(SkBits2Float(0x68555b29), SkBits2Float(0x00000000));  // 4.03018e+24f, 0
11058 path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x682d2927), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6829686f));  // 0, 3.27091e+24f, 0, 0, 3.20003e+24f
11059 path.lineTo(SkBits2Float(0xdf218a28), SkBits2Float(0x00000000));  // -1.16402e+19f, 0
11060 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4));  // 0, 6.14991e+25f
11061 path.close();
11062 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11063 path.conicTo(SkBits2Float(0x6642c40c), SkBits2Float(0x00000000), SkBits2Float(0x65906630), SkBits2Float(0x6a25a070), SkBits2Float(0x3edcd74d));  // 2.29939e+23f, 0, 8.52382e+22f, 5.00576e+25f, 0.43133f
11064 path.conicTo(SkBits2Float(0x68295afa), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x4277a57b));  // 3.19903e+24f, 0, 0, 0, 61.9116f
11065 path.close();
11067     SkPath path1(path);
11068     path.reset();
11069     path.setFillType((SkPathFillType) 0);
11071     SkPath path2(path);
11077     SkPath path;
11078     path.setFillType((SkPathFillType) 0);
11080     SkPath path1(path);
11081     path.reset();
11082     path.setFillType((SkPathFillType) 0);
11083 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
11084 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc003210a));  // 3.60396e-20f, -2.04889f
11085 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
11086 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
11087 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955));  // 3.35016e+24f, -2.87402e+29f
11088 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
11089 path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955));  // 3.35016e+24f, -2.87402e+29f
11090 path.close();
11091 path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955));  // 3.35016e+24f, -2.87402e+29f
11092 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55));  // 4.85282e+16f, 5.7784e-19f
11093 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
11094 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
11095 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
11096 path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527));  // 3.42572e+24f, -2.87614e+29f
11097 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
11098 path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527));  // 3.42572e+24f, -2.87614e+29f
11099 path.close();
11100 path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527));  // 3.42572e+24f, -2.87614e+29f
11101 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3));  // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f
11102 path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527));  // 3.42572e+24f, -2.87614e+29f
11103 path.close();
11104 path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527));  // 3.42572e+24f, -2.87614e+29f
11105 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2127ed29));  // 2.25206e-21f, 300.343f, 0.000650423f, 5.68957e-19f
11106 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
11107 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
11108 path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527));  // 3.42572e+24f, -2.87614e+29f
11109 path.close();
11110 path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d));  // 3.19839e+24f, 1.21279e-11f
11111 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x5b2d5529));  // 4.03114e+24f, 4.87888e+16f
11112 path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0xc0032108));  // 3.60404e-20f, -2.04889f
11113 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
11114 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
11115 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955));  // 3.48239e+24f, -2.87402e+29f
11116 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
11117 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955));  // 3.48239e+24f, -2.87402e+29f
11118 path.close();
11119 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955));  // 3.48239e+24f, -2.87402e+29f
11120 path.lineTo(SkBits2Float(0x555b1b29), SkBits2Float(0x6c212a8c));  // 1.50569e+13f, 7.79352e+26f
11121 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
11122 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
11123 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955));  // 3.48239e+24f, -2.87402e+29f
11124 path.close();
11125 path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955));  // 3.48239e+24f, -2.87402e+29f
11126 path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x1f2128c0));  // -1.31678e-31f, 3.41268e-20f
11127 path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955));  // 3.48239e+24f, -2.87402e+29f
11128 path.close();
11130     SkPath path2(path);
11135     SkPath path;
11136     path.setFillType((SkPathFillType) 0);
11138     SkPath path1(path);
11139     path.reset();
11140     path.setFillType((SkPathFillType) 0);
11141 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
11142 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
11143 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
11144 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
11145 path.moveTo(SkBits2Float(0x6c395b2d), SkBits2Float(0xf0682955));  // 8.96327e+26f, -2.87402e+29f
11146 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
11147 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55));  // 4.85282e+16f, 5.7784e-19f
11148 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
11149 path.lineTo(SkBits2Float(0x8a283a28), SkBits2Float(0x284f1a3a));  // -8.09984e-33f, 1.14965e-14f
11150 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529));  // 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f
11151 path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720));  // 6.3398e-19f, 2.34747e-15f
11152 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
11153 path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x683a5b2d));  // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.52017e+24f
11154 path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568));  // 4.86672e-14f, 5.15884e-14f
11155 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
11156 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
11157 path.quadTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21));  // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f
11158 path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
11159 path.close();
11160 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
11161 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
11162 path.lineTo(SkBits2Float(0x5b2d212d), SkBits2Float(0x2d556829));  // 4.87316e+16f, 1.21308e-11f
11163 path.moveTo(SkBits2Float(0x68552968), SkBits2Float(0x5568295b));  // 4.02651e+24f, 1.5954e+13f
11164 path.moveTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55));  // 4.87407e+16f, 5.7784e-19f
11165 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0));  // 4.7323e-37f, 6.14991e+25f
11166 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
11168     SkPath path2(path);
11173     SkPath path;
11174     path.setFillType((SkPathFillType) 0);
11176     SkPath path1(path);
11177     path.reset();
11178     path.setFillType((SkPathFillType) 0);
11179 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11180 path.quadTo(SkBits2Float(0x30309ab8), SkBits2Float(0x305b3030), SkBits2Float(0x00f53030), SkBits2Float(0x3a3a0000));  // 6.42483e-10f, 7.97402e-10f, 2.2517e-38f, 0.000709534f
11181 path.quadTo(SkBits2Float(0xb8b8d5b8), SkBits2Float(0x0b0b0b03), SkBits2Float(0x0b0b0b0b), SkBits2Float(0x3a3a0b0b));  // -8.81361e-05f, 2.67787e-32f, 2.67787e-32f, 0.000709698f
11182 path.quadTo(SkBits2Float(0xb8b8b8b8), SkBits2Float(0x0b1203b8), SkBits2Float(0x0b0b0b0b), SkBits2Float(0x3a3a2110));  // -8.80821e-05f, 2.81214e-32f, 2.67787e-32f, 0.000710026f
11184     SkPath path2(path);
11189     SkPath path;
11190     path.setFillType((SkPathFillType) 1);
11191 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11192 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x743e0000));  // 0, 6.02134e+31f
11193 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
11194 path.quadTo(SkBits2Float(0x74360ca0), SkBits2Float(0x7401e10c), SkBits2Float(0x7436a382), SkBits2Float(0x7401cc18));  // 5.76937e+31f, 4.11603e+31f, 5.78805e+31f, 4.11344e+31f
11195 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
11196 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
11197 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
11198 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
11199 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
11200 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
11201 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
11202 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11203 path.close();
11205     SkPath path1(path);
11206     path.reset();
11207     path.setFillType((SkPathFillType) 0);
11208 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11209 path.lineTo(SkBits2Float(0xf0682955), SkBits2Float(0x211f5b2d));  // -2.87402e+29f, 5.3992e-19f
11210 path.moveTo(SkBits2Float(0x2d2aff2d), SkBits2Float(0x74747474));  // 9.72004e-12f, 7.74708e+31f
11211 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
11212 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
11213 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
11214 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
11216     SkPath path2(path);
11221     SkPath path;
11222     path.setFillType((SkPathFillType) 1);
11224     SkPath path1(path);
11225     path.reset();
11226     path.setFillType((SkPathFillType) 0);
11227 path.moveTo(SkBits2Float(0x1f2108c0), SkBits2Float(0x4b7b0321));  // 3.41003e-20f, 1.64503e+07f
11228 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d));  // 3.20982e+24f, 1.21279e-11f
11229 path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527));  // 3.33127e+24f, -2.87614e+29f
11230 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
11231 path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55));  // 4.87407e+16f, 5.7784e-19f
11232 path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x4b7b28c0));  // 4.7323e-37f, 1.646e+07f
11233 path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x2d081f21));  // 2.50338e-13f, 7.73762e-12f
11234 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
11235 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
11236 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
11237 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
11238 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
11239 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
11240 path.lineTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
11241 path.close();
11242 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
11243 path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x3ac22c21), SkBits2Float(0x6c401057), SkBits2Float(0x6d6d6b64));  // 0.00136978f, 0.00148142f, 9.28764e+26f, 4.59236e+27f
11244 path.cubicTo(SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x286d6d6d), SkBits2Float(0x081d2a29), SkBits2Float(0x6d690321), SkBits2Float(0x6b6b026d));  // 4.59251e+27f, 4.59251e+27f, 1.31799e-14f, 4.7295e-34f, 4.50711e+27f, 2.84109e+26f
11246     SkPath path2(path);
11251     SkPath path;
11252     path.setFillType((SkPathFillType) 1);
11254     SkPath path1(path);
11255     path.reset();
11256     path.setFillType((SkPathFillType) 0);
11257 path.moveTo(SkBits2Float(0xd72a8c55), SkBits2Float(0x61081f2a));  // -1.8752e+14f, 1.56938e+20f
11258 path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0xdf3a2128), SkBits2Float(0x471ac575));  // 6.14991e+25f, 75739, 9.4495e-15f, -1.3412e+19f, 39621.5f
11259 path.lineTo(SkBits2Float(0x28404040), SkBits2Float(0x552a298a));  // 1.06721e-14f, 1.16935e+13f
11260 path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a));  // 5.8414e-19f, 4.61198e-19f
11261 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
11262 path.lineTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a));  // 5.8414e-19f, 4.61198e-19f
11263 path.close();
11264 path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a));  // 5.8414e-19f, 4.61198e-19f
11265 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
11266 path.lineTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a));  // 5.8414e-19f, 4.61198e-19f
11267 path.close();
11268 path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a));  // 5.8414e-19f, 4.61198e-19f
11269 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
11271     SkPath path2(path);
11276     SkPath path;
11277     path.setFillType((SkPathFillType) 1);
11278 path.moveTo(SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8));  // 7.66623e+30f, 7.66608e+30f
11279 path.quadTo(SkBits2Float(0x724341bf), SkBits2Float(0x72433fc4), SkBits2Float(0x6d757575), SkBits2Float(0x6d6d6d6d));  // 3.86746e+30f, 3.86731e+30f, 4.74786e+27f, 4.59251e+27f
11280 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
11281 path.conicTo(SkBits2Float(0x6c6c8b72), SkBits2Float(0x00000000), SkBits2Float(0x6c6c6c6c), SkBits2Float(0x00000000), SkBits2Float(0x400812df));  // 1.14386e+27f, 0, 1.14327e+27f, 0, 2.12615f
11282 path.quadTo(SkBits2Float(0x72432acb), SkBits2Float(0x72432295), SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8));  // 3.86568e+30f, 3.86505e+30f, 7.66623e+30f, 7.66608e+30f
11283 path.close();
11284 path.moveTo(SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8));  // 7.66623e+30f, 7.66608e+30f
11285 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
11286 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
11287 path.close();
11288 path.moveTo(SkBits2Float(0x6c6c69d8), SkBits2Float(0x6d20df31));  // 1.14323e+27f, 3.11171e+27f
11289 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
11290 path.lineTo(SkBits2Float(0x6a674231), SkBits2Float(0x6c0c3394));  // 6.98936e+25f, 6.77973e+26f
11291 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
11292 path.close();
11294     SkPath path1(path);
11295     path.reset();
11296     path.setFillType((SkPathFillType) 0);
11297 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11298 path.lineTo(SkBits2Float(0x6c6b6ba7), SkBits2Float(0x886b6b6b));  // 1.13842e+27f, -7.0844e-34f
11299 path.quadTo(SkBits2Float(0x0000206b), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d));  // 1.16294e-41f, 4.59251e+27f, 4.59251e+27f, 4.59251e+27f
11300 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
11301 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x95066b78));  // 2.01583e+34f, -2.71459e-26f
11302 path.lineTo(SkBits2Float(0x6c6b6ba7), SkBits2Float(0x886b6b6b));  // 1.13842e+27f, -7.0844e-34f
11303 path.quadTo(SkBits2Float(0x0000206b), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d));  // 1.16294e-41f, 4.59251e+27f, 4.59251e+27f, 4.59251e+27f
11304 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
11305 path.lineTo(SkBits2Float(0x8787878f), SkBits2Float(0x87878787));  // -2.03922e-34f, -2.03922e-34f
11306 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878));  // 2.01583e+34f, 2.01583e+34f
11307 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878));  // 2.01583e+34f, 2.01583e+34f
11308 path.lineTo(SkBits2Float(0x6c105778), SkBits2Float(0x6d406b64));  // 6.97994e+26f, 3.72193e+27f
11309 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
11310 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
11311 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878));  // 2.01583e+34f, 2.01583e+34f
11312 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878));  // 2.01583e+34f, 2.01583e+34f
11313 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878));  // 2.01583e+34f, 2.01583e+34f
11314 path.lineTo(SkBits2Float(0xb4bcacbc), SkBits2Float(0xbcadbcbc));  // -3.51434e-07f, -0.0212082f
11315 path.moveTo(SkBits2Float(0xa03aacbc), SkBits2Float(0x757575a0));  // -1.5812e-19f, 3.11157e+32f
11316 path.close();
11318     SkPath path2(path);
11323     SkPath path;
11324     path.setFillType((SkPathFillType) 1);
11326     SkPath path1(path);
11327     path.reset();
11328     path.setFillType((SkPathFillType) 0);
11329 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11330 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
11331 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
11332 path.moveTo(SkBits2Float(0xe0f2f210), SkBits2Float(0xc3f2eef2));  // -1.40049e+20f, -485.867f
11333 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
11334 path.moveTo(SkBits2Float(0x556c0010), SkBits2Float(0x002a8768));  // 1.62178e+13f, 3.90567e-39f
11335 path.quadTo(SkBits2Float(0xf2f22021), SkBits2Float(0xf2f2f56e), SkBits2Float(0xf2f2f2f2), SkBits2Float(0xf22040d9));  // -9.59158e+30f, -9.62459e+30f, -9.6242e+30f, -3.17414e+30f
11336 path.lineTo(SkBits2Float(0xc013f2f2), SkBits2Float(0x0000294d));  // -2.3117f, 1.48159e-41f
11338     SkPath path2(path);
11343     SkPath path;
11344     path.setFillType((SkPathFillType) 1);
11345 path.moveTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2));  // 6.24803e+21f, 1.94304e+27f
11346 path.quadTo(SkBits2Float(0x63690f37), SkBits2Float(0x6d0a3d9b), SkBits2Float(0x00000000), SkBits2Float(0x6d3e3e3e));  // 4.29919e+21f, 2.67396e+27f, 0, 3.67984e+27f
11347 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
11348 path.lineTo(SkBits2Float(0x6c6c586c), SkBits2Float(0x00000000));  // 1.1429e+27f, 0
11349 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11350 path.conicTo(SkBits2Float(0x6c8c6c6c), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6cc8e82a), SkBits2Float(0x5b684b68));  // 1.35809e+27f, 0, 0, 1.94305e+27f, 6.53851e+16f
11351 path.lineTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2));  // 6.24803e+21f, 1.94304e+27f
11352 path.close();
11353 path.moveTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2));  // 6.24803e+21f, 1.94304e+27f
11354 path.quadTo(SkBits2Float(0x641ae35f), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 1.14287e+22f, 0, 0, 0
11355 path.lineTo(SkBits2Float(0x6c6c586c), SkBits2Float(0x00000000));  // 1.1429e+27f, 0
11356 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
11357 path.lineTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2));  // 6.24803e+21f, 1.94304e+27f
11358 path.close();
11360     SkPath path1(path);
11361     path.reset();
11362     path.setFillType((SkPathFillType) 0);
11363 path.moveTo(SkBits2Float(0x6c3e3e3e), SkBits2Float(0x586c79ff));  // 9.19959e+26f, 1.04003e+15f
11364 path.quadTo(SkBits2Float(0x6c6c4a6c), SkBits2Float(0x6c6c6c6c), SkBits2Float(0xc83e6c6c), SkBits2Float(0x3e313e3e));  // 1.14263e+27f, 1.14327e+27f, -194994, 0.173089f
11366     SkPath path2(path);
11371     SkPath path;
11372     path.setFillType((SkPathFillType) 0);
11374     SkPath path1(path);
11375     path.reset();
11376     path.setFillType((SkPathFillType) 0);
11377 path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29));  // 4.03114e+24f, 1.50617e+13f
11378 path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108));  // 3.60396e-20f, -2.04889f
11379 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
11380 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
11381 path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955));  // -3.42572e+24f, -2.87402e+29f
11382 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
11383 path.lineTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955));  // -3.42572e+24f, -2.87402e+29f
11384 path.close();
11385 path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955));  // -3.42572e+24f, -2.87402e+29f
11386 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55));  // 4.85282e+16f, 5.7784e-19f
11387 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
11388 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
11389 path.lineTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955));  // -3.42572e+24f, -2.87402e+29f
11390 path.close();
11391 path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955));  // -3.42572e+24f, -2.87402e+29f
11392 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d));  // 3.20982e+24f, 1.21279e-11f
11393 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11394 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
11395 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11396 path.close();
11397 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11398 path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3adf21), SkBits2Float(0x284f1a3a), SkBits2Float(0x213ab38a));  // 9.4456e-15f, -8.99754e-33f, 1.14965e-14f, 6.32569e-19f
11399 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11400 path.close();
11401 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11402 path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a20002a), SkBits2Float(0x2a8ced29));  // 2.25206e-21f, 300.343f, 0.000610354f, 2.50336e-13f
11403 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11404 path.close();
11405 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11406 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
11407 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4341f20), SkBits2Float(0xecc52a22));  // 2.22225e-15f, 0.000713932f, -720.486f, -1.90686e+27f
11408 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
11409 path.lineTo(SkBits2Float(0x1f2a2a8c), SkBits2Float(0x03210821));  // 3.60341e-20f, 4.7323e-37f
11410 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11411 path.close();
11412 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11413 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
11414 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11415 path.close();
11416 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11417 path.quadTo(SkBits2Float(0xe61d2a28), SkBits2Float(0x2a43962b), SkBits2Float(0x29272a81), SkBits2Float(0x2bb02a55));  // -1.85547e+23f, 1.73716e-13f, 3.71183e-14f, 1.25173e-12f
11418 path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3ac52729), SkBits2Float(0xc4223b32), SkBits2Float(0x6c2a201f));  // 2.22225e-15f, 0.00150416f, -648.925f, 8.22676e+26f
11420     SkPath path2(path);
11425     SkPath path;
11426     path.setFillType((SkPathFillType) 1);
11428     SkPath path1(path);
11429     path.reset();
11430     path.setFillType((SkPathFillType) 0);
11431 path.moveTo(SkBits2Float(0x2aed2a8c), SkBits2Float(0x03210a1f));  // 4.21292e-13f, 4.73253e-37f
11432 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
11433 path.quadTo(SkBits2Float(0x74747474), SkBits2Float(0x74747474), SkBits2Float(0x20437474), SkBits2Float(0x43a52b02));  // 7.74708e+31f, 7.74708e+31f, 1.65557e-19f, 330.336f
11434 path.moveTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a));  // 0.000615232f, 5.69738e-19f
11435 path.lineTo(SkBits2Float(0x4b7bd603), SkBits2Float(0x6cf33b6a));  // 1.65043e+07f, 2.3524e+27f
11436 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
11437 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
11438 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
11439 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
11440 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
11441 path.lineTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a));  // 0.000615232f, 5.69738e-19f
11442 path.close();
11443 path.moveTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a));  // 0.000615232f, 5.69738e-19f
11444 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
11445 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
11446 path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x742974e8));  // 7.74706e+31f, 5.3703e+31f
11447 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
11448 path.moveTo(SkBits2Float(0x31292768), SkBits2Float(0x212d2aff));  // 2.46151e-09f, 5.86716e-19f
11449 path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x323adf81), SkBits2Float(0x77291a3a), SkBits2Float(0x00002a49));  // 5.69738e-19f, 1.08774e-08f, 3.42981e+33f, 1.51691e-41f
11450 path.moveTo(SkBits2Float(0x7474743e), SkBits2Float(0x74747474));  // 7.74706e+31f, 7.74708e+31f
11451 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
11452 path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474));  // 7.74706e+31f, 7.74708e+31f
11453 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
11454 path.lineTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474));  // 7.74706e+31f, 7.74708e+31f
11455 path.close();
11456 path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474));  // 7.74706e+31f, 7.74708e+31f
11457 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
11459     SkPath path2(path);
11464     SkPath path;
11465     path.setFillType((SkPathFillType) 0);
11466 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x5b2d3368));  // 1.59583e+13f, 4.87517e+16f
11467 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
11468 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
11469 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b));  // 3.50084e+24f, -2.87489e+29f
11470 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
11471 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55));  // 4.85282e+16f, 5.7784e-19f
11472 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
11473 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
11474 path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b));  // 3.50084e+24f, -2.87489e+29f
11475 path.close();
11476 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b));  // 3.50084e+24f, -2.87489e+29f
11477 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d));  // 3.20982e+24f, 1.21279e-11f
11478 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11479 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
11480 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11481 path.close();
11482 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11483 path.quadTo(SkBits2Float(0x28282a2a), SkBits2Float(0x2c682921), SkBits2Float(0x8c555bf6), SkBits2Float(0x6d03de30));  // 9.33502e-15f, 3.2992e-12f, -1.64366e-31f, 2.5507e+27f
11484 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
11485 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11486 path.close();
11487 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11488 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
11489 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11490 path.close();
11491 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11492 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
11493 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11494 path.close();
11495 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
11496 path.lineTo(SkBits2Float(0x8ced293a), SkBits2Float(0x5c5c5c5c));  // -3.65404e-31f, 2.48104e+17f
11497 path.moveTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003));  // 4.61198e-19f, 1.64987e+07f
11498 path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55));  // 9.43289e-15f, 4.8745e+16f
11499 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a));  // 3.50084e+24f, -2.87489e+29f
11500 path.lineTo(SkBits2Float(0x682d2952), SkBits2Float(0xee682103));  // 3.27093e+24f, -1.79601e+28f
11501 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x2a3b0355));  // 4.85282e+16f, 1.66101e-13f
11502 path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a));  // 3.50084e+24f, -2.87489e+29f
11503 path.close();
11504 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a));  // 3.50084e+24f, -2.87489e+29f
11505 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
11507     SkPath path1(path);
11508     path.reset();
11509     path.setFillType((SkPathFillType) 0);
11510 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11511 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
11513     SkPath path2(path);
11518     SkPath path;
11519     path.setFillType((SkPathFillType) 0);
11520 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11521 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
11522 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11523 path.close();
11524 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad));  // -1.43243e-16f, 3.88004e+11f
11525 path.close();
11526 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad));  // -1.43243e-16f, 3.88004e+11f
11527 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x2ac05252), SkBits2Float(0x727fb721));  // 4.80216e+30f, 2.25832e+11f, 3.41632e-13f, 5.06496e+30f
11528 path.lineTo(SkBits2Float(0x73727322), SkBits2Float(0x555b2d29));  // 1.92088e+31f, 1.50617e+13f
11529 path.lineTo(SkBits2Float(0xab2a212e), SkBits2Float(0x7a27872a));  // -6.04422e-13f, 2.17464e+35f
11530 path.moveTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321));  // 4.44082e-16f, 1.99397e+36f
11531 path.quadTo(SkBits2Float(0x52524852), SkBits2Float(0x72525228), SkBits2Float(0x72727272), SkBits2Float(0x3a727272));  // 2.25789e+11f, 4.16584e+30f, 4.80216e+30f, 0.000924862f
11532 path.lineTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321));  // 4.44082e-16f, 1.99397e+36f
11533 path.close();
11534 path.moveTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321));  // 4.44082e-16f, 1.99397e+36f
11535 path.quadTo(SkBits2Float(0x2a292827), SkBits2Float(0x962b0080), SkBits2Float(0x5252752a), SkBits2Float(0x72725252));  // 1.50241e-13f, -1.38134e-25f, 2.25977e+11f, 4.79967e+30f
11536 path.quadTo(SkBits2Float(0x72725252), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272));  // 4.79967e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
11537 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda000072), SkBits2Float(0x52525ada), SkBits2Float(0x52525252));  // 4.80215e+30f, -9.00732e+15f, 2.25867e+11f, 2.25831e+11f
11538 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525272), SkBits2Float(0x72525248), SkBits2Float(0x72727272));  // 4.80216e+30f, 2.25832e+11f, 4.16584e+30f, 4.80216e+30f
11539 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x52525252));  // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 2.25831e+11f
11540 path.quadTo(SkBits2Float(0x86727272), SkBits2Float(0x5252528d), SkBits2Float(0x72525252), SkBits2Float(0x72727227));  // -4.55992e-35f, 2.25832e+11f, 4.16585e+30f, 4.80214e+30f
11541 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x29217272), SkBits2Float(0xc003211c), SkBits2Float(0x556a4b7b));  // 4.80216e+30f, 3.58484e-14f, -2.0489f, 1.61006e+13f
11542 path.moveTo(SkBits2Float(0x72557272), SkBits2Float(0x00727272));  // 4.22775e+30f, 1.05103e-38f
11543 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252));  // 1.58931e+16f, 2.25831e+11f
11544 path.close();
11545 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252));  // 1.58931e+16f, 2.25831e+11f
11546 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x3a727272), SkBits2Float(0x28273ac2), SkBits2Float(0x00802a29));  // 4.80216e+30f, 0.000924862f, 9.2831e-15f, 1.17701e-38f
11547 path.lineTo(SkBits2Float(0x52752a96), SkBits2Float(0x72525252));  // 2.63245e+11f, 4.16585e+30f
11548 path.quadTo(SkBits2Float(0x72525272), SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72727272));  // 4.16586e+30f, 2.25966e+11f, 2.25831e+11f, 4.80216e+30f
11549 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252));  // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f
11550 path.lineTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252));  // 1.58931e+16f, 2.25831e+11f
11551 path.close();
11552 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252));  // 1.58931e+16f, 2.25831e+11f
11553 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525272), SkBits2Float(0x72525248), SkBits2Float(0x72727272));  // 4.80216e+30f, 2.25832e+11f, 4.16584e+30f, 4.80216e+30f
11554 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x72525252));  // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 4.16585e+30f
11555 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x72727252), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada));  // 4.80216e+30f, 4.80215e+30f, -9.04113e+15f, 2.25867e+11f
11556 path.lineTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252));  // 1.58931e+16f, 2.25831e+11f
11557 path.close();
11558 path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252));  // 1.58931e+16f, 2.25831e+11f
11559 path.quadTo(SkBits2Float(0x86727272), SkBits2Float(0x5252528d), SkBits2Float(0x72525252), SkBits2Float(0x72727227));  // -4.55992e-35f, 2.25832e+11f, 4.16585e+30f, 4.80214e+30f
11560 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x29217272), SkBits2Float(0xc003211c), SkBits2Float(0x556a4b7b));  // 4.80216e+30f, 3.58484e-14f, -2.0489f, 1.61006e+13f
11561 path.moveTo(SkBits2Float(0x72557272), SkBits2Float(0x00727272));  // 4.22775e+30f, 1.05103e-38f
11562 path.moveTo(SkBits2Float(0x525adada), SkBits2Float(0x52525252));  // 2.34994e+11f, 2.25831e+11f
11563 path.close();
11564 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad));  // -1.43243e-16f, 3.88004e+11f
11565 path.close();
11566 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad));  // -1.43243e-16f, 3.88004e+11f
11567 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272));  // 4.80216e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
11568 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x52525252));  // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 2.25831e+11f
11569 path.quadTo(SkBits2Float(0x52525272), SkBits2Float(0x3b3b0052), SkBits2Float(0x5b2d553a), SkBits2Float(0x68556829));  // 2.25832e+11f, 0.00285341f, 4.87889e+16f, 4.03114e+24f
11571     SkPath path1(path);
11572     path.reset();
11573     path.setFillType((SkPathFillType) 0);
11574 path.moveTo(SkBits2Float(0x52528c55), SkBits2Float(0x29215252));  // 2.26074e+11f, 3.58206e-14f
11576     SkPath path2(path);
11581     SkPath path;
11582     path.setFillType((SkPathFillType) 0);
11584     SkPath path1(path);
11585     path.reset();
11586     path.setFillType((SkPathFillType) 0);
11587 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11588 path.quadTo(SkBits2Float(0x7a057c72), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x055f0089));  // 1.73275e+35f, 4.80216e+30f, 4.34505e+30f, 1.04855e-35f
11589 path.quadTo(SkBits2Float(0x00057272), SkBits2Float(0x72ff0000), SkBits2Float(0xba405e72), SkBits2Float(0x031b0074));  // 5.00233e-40f, 1.01016e+31f, -0.000733829f, 4.55509e-37f
11590 path.lineTo(SkBits2Float(0x664af700), SkBits2Float(0x56397d39));  // 2.39619e+23f, 5.09869e+13f
11591 path.quadTo(SkBits2Float(0x7a057273), SkBits2Float(0x057300e4), SkBits2Float(0x257c0c9f), SkBits2Float(0x72400006));  // 1.73224e+35f, 1.1426e-35f, 2.18618e-16f, 3.80295e+30f
11592 path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x030000ff), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8ec4000));  // -0.000836826f, 3.7617e-37f, 1.17894e+32f, -8.92527e+24f
11593 path.moveTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d));  // 0.000231069f, 2.53975e+30f
11594 path.quadTo(SkBits2Float(0x827a0572), SkBits2Float(0x08727272), SkBits2Float(0x08080808), SkBits2Float(0x08080808));  // -1.83687e-37f, 7.29588e-34f, 4.09355e-34f, 4.09355e-34f
11595 path.lineTo(SkBits2Float(0x08080808), SkBits2Float(0x08080808));  // 4.09355e-34f, 4.09355e-34f
11596 path.lineTo(SkBits2Float(0x08080808), SkBits2Float(0x08080808));  // 4.09355e-34f, 4.09355e-34f
11597 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
11598 path.quadTo(SkBits2Float(0x00800039), SkBits2Float(0x72100039), SkBits2Float(0x727a0572), SkBits2Float(0x7a727272));  // 1.1755e-38f, 2.85223e+30f, 4.95218e+30f, 3.14714e+35f
11599 path.lineTo(SkBits2Float(0x7272727a), SkBits2Float(0xdb5e6472));  // 4.80216e+30f, -6.25979e+16f
11600 path.moveTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647));  // 512.906f, 8.83477e-41f
11601 path.lineTo(SkBits2Float(0x666d0100), SkBits2Float(0x726efe62));  // 2.79805e+23f, 4.73376e+30f
11602 path.lineTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647));  // 512.906f, 8.83477e-41f
11603 path.close();
11604 path.moveTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647));  // 512.906f, 8.83477e-41f
11605 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
11606 path.quadTo(SkBits2Float(0x72057272), SkBits2Float(0x8c7a3472), SkBits2Float(0x72727272), SkBits2Float(0x00f6475e));  // 2.64319e+30f, -1.92751e-31f, 4.80216e+30f, 2.26171e-38f
11607 path.moveTo(SkBits2Float(0x6d106d43), SkBits2Float(0x6efe6266));  // 2.79362e+27f, 3.93641e+28f
11608 path.quadTo(SkBits2Float(0x72727a05), SkBits2Float(0xba5b7272), SkBits2Float(0x03000074), SkBits2Float(0x5aff00e8));  // 4.80274e+30f, -0.000837124f, 3.76163e-37f, 3.58886e+16f
11609 path.quadTo(SkBits2Float(0x00da0039), SkBits2Float(0x72100039), SkBits2Float(0x727a0572), SkBits2Float(0x7a727272));  // 2.00202e-38f, 2.85223e+30f, 4.95218e+30f, 3.14714e+35f
11610 path.lineTo(SkBits2Float(0x7272727a), SkBits2Float(0xdb5e6472));  // 4.80216e+30f, -6.25979e+16f
11611 path.lineTo(SkBits2Float(0xfc5b97fc), SkBits2Float(0x47440039));  // -4.56078e+36f, 50176.2f
11612 path.lineTo(SkBits2Float(0x00710000), SkBits2Float(0x62766d01));  // 1.03774e-38f, 1.13644e+21f
11613 path.quadTo(SkBits2Float(0x7a05726e), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16));  // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f
11615     SkPath path2(path);
11620     SkPath path;
11621     path.setFillType((SkPathFillType) 1);
11623     SkPath path1(path);
11624     path.reset();
11625     path.setFillType((SkPathFillType) 0);
11626 path.moveTo(SkBits2Float(0x10190004), SkBits2Float(0x7272727a));  // 3.01739e-29f, 4.80216e+30f
11627 path.quadTo(SkBits2Float(0xf3db5e64), SkBits2Float(0x5b97fc16), SkBits2Float(0x000039fc), SkBits2Float(0x01008000));  // -3.47604e+31f, 8.55598e+16f, 2.08009e-41f, 2.36017e-38f
11628 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x41720089));  // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 15.1251f
11629 path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363));  // 4.19457e+21f, 4.13923e+21f
11630 path.lineTo(SkBits2Float(0x01000000), SkBits2Float(0x10010004));  // 2.35099e-38f, 2.54408e-29f
11631 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
11632 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x63720089));  // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 4.46415e+21f
11633 path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363));  // 4.19457e+21f, 4.13923e+21f
11634 path.lineTo(SkBits2Float(0x72000000), SkBits2Float(0x5b5e72b4));  // 2.5353e+30f, 6.26136e+16f
11635 path.quadTo(SkBits2Float(0x05720089), SkBits2Float(0x05727272), SkBits2Float(0x7272727a), SkBits2Float(0x5b5e7272));  // 1.13789e-35f, 1.13998e-35f, 4.80216e+30f, 6.26133e+16f
11636 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
11637 path.moveTo(SkBits2Float(0x72008972), SkBits2Float(0x458fe705));  // 2.54594e+30f, 4604.88f
11638 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0xe8727272), SkBits2Float(0xba5b5e03), SkBits2Float(0x03000074));  // 1.73224e+35f, -4.5797e+24f, -0.00083682f, 3.76163e-37f
11639 path.lineTo(SkBits2Float(0xf3dbff00), SkBits2Float(0x00397d16));  // -3.48598e+31f, 5.2795e-39f
11640 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
11642     SkPath path2(path);
11647     SkPath path;
11648     path.setFillType((SkPathFillType) 0);
11650     SkPath path1(path);
11651     path.reset();
11652     path.setFillType((SkPathFillType) 0);
11653 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11654 path.quadTo(SkBits2Float(0x7a057c72), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x055f0089));  // 1.73275e+35f, 4.80216e+30f, 4.34505e+30f, 1.04855e-35f
11655 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xba405e72), SkBits2Float(0x03000074));  // 1.73224e+35f, 4.80216e+30f, -0.000733829f, 3.76163e-37f
11656 path.lineTo(SkBits2Float(0x664aff00), SkBits2Float(0x56397d39));  // 2.39655e+23f, 5.09869e+13f
11657 path.quadTo(SkBits2Float(0x7a057273), SkBits2Float(0x057300ff), SkBits2Float(0x257c0c9f), SkBits2Float(0x72787257));  // 1.73224e+35f, 1.1426e-35f, 2.18618e-16f, 4.92099e+30f
11658 path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x03000093), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8ecff00));  // -0.000836826f, 3.76165e-37f, 1.17894e+32f, -8.95346e+24f
11659 path.moveTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d));  // 0.000231069f, 2.53975e+30f
11660 path.quadTo(SkBits2Float(0x827a0572), SkBits2Float(0x72727272), SkBits2Float(0x724adf00), SkBits2Float(0x00397d39));  // -1.83687e-37f, 4.80216e+30f, 4.01828e+30f, 5.27954e-39f
11661 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x16f3abab), SkBits2Float(0xfc5b97fc), SkBits2Float(0x47440039));  // 1.73224e+35f, 3.93671e-25f, -4.56078e+36f, 50176.2f
11662 path.lineTo(SkBits2Float(0x00710000), SkBits2Float(0x62767201));  // 1.03774e-38f, 1.13653e+21f
11663 path.quadTo(SkBits2Float(0x7a05726e), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16));  // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f
11665     SkPath path2(path);
11671     SkPath path;
11672     path.setFillType((SkPathFillType) 0);
11674     SkPath path1(path);
11675     path.reset();
11676     path.setFillType((SkPathFillType) 0);
11677 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11678 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x05720089));  // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 1.13789e-35f
11679 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xba405e72), SkBits2Float(0x03000074));  // 1.73224e+35f, 4.80216e+30f, -0.000733829f, 3.76163e-37f
11680 path.lineTo(SkBits2Float(0x724aff00), SkBits2Float(0x56397d39));  // 4.02075e+30f, 5.09869e+13f
11681 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0xfa8d00ff), SkBits2Float(0x25727272), SkBits2Float(0x7272727a));  // 1.73224e+35f, -3.66067e+35f, 2.10289e-16f, 4.80216e+30f
11682 path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x03000093), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8e0ff00));  // -0.000836826f, 3.76165e-37f, 1.17894e+32f, -8.50011e+24f
11683 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
11684 path.quadTo(SkBits2Float(0x00397d39), SkBits2Float(0x05727272), SkBits2Float(0x7272727a), SkBits2Float(0x385e7272));  // 5.27954e-39f, 1.13998e-35f, 4.80216e+30f, 5.30355e-05f
11685 path.quadTo(SkBits2Float(0x057200ff), SkBits2Float(0x25727272), SkBits2Float(0x7272727a), SkBits2Float(0x5b5e7272));  // 1.1379e-35f, 2.10289e-16f, 4.80216e+30f, 6.26133e+16f
11686 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
11687 path.quadTo(SkBits2Float(0x2b2d16f3), SkBits2Float(0x0039fc4d), SkBits2Float(0x68800000), SkBits2Float(0x0100fafa));  // 6.14938e-13f, 5.32513e-39f, 4.8357e+24f, 2.369e-38f
11688 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x63720089));  // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 4.46415e+21f
11689 path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363));  // 4.19457e+21f, 4.13923e+21f
11690 path.lineTo(SkBits2Float(0x72720000), SkBits2Float(0xff725b5e));  // 4.7933e+30f, -3.22148e+38f
11691 path.moveTo(SkBits2Float(0x72720572), SkBits2Float(0x5b5e2572));  // 4.79373e+30f, 6.25286e+16f
11692 path.quadTo(SkBits2Float(0x05720089), SkBits2Float(0x25727272), SkBits2Float(0x72728c7a), SkBits2Float(0x5b5e7272));  // 1.13789e-35f, 2.10289e-16f, 4.80417e+30f, 6.26133e+16f
11693 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
11694 path.quadTo(SkBits2Float(0x97fc16f3), SkBits2Float(0x0039fc5b), SkBits2Float(0x00f6472e), SkBits2Float(0x01008000));  // -1.62909e-24f, 5.32515e-39f, 2.26171e-38f, 2.36017e-38f
11695 path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16));  // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f
11697     SkPath path2(path);
11702     SkPath path;
11703     path.setFillType((SkPathFillType) 1);
11705     SkPath path1(path);
11706     path.reset();
11707     path.setFillType((SkPathFillType) 0);
11708 path.moveTo(SkBits2Float(0x5c386c3a), SkBits2Float(0x4e691a3e));  // 2.07642e+17f, 9.77703e+08f
11709 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
11710 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
11711 path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb));  // -4.20789e+07f, 2.54923e-23f
11712 path.close();
11713 path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb));  // -4.20789e+07f, 2.54923e-23f
11714 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
11715 path.lineTo(SkBits2Float(0x438a0b9c), SkBits2Float(0x60a1d2c8));  // 276.091f, 9.32848e+19f
11716 path.quadTo(SkBits2Float(0xe13fb902), SkBits2Float(0x07ee536f), SkBits2Float(0x971d8ac1), SkBits2Float(0x2f9f174b));  // -2.21041e+20f, 3.58593e-34f, -5.09046e-25f, 2.89385e-10f
11717 path.lineTo(SkBits2Float(0x0f2cf5d8), SkBits2Float(0xe271654c));  // 8.5276e-30f, -1.11324e+21f
11718 path.lineTo(SkBits2Float(0xe6cf24d2), SkBits2Float(0xd9537742));  // -4.89105e+23f, -3.72015e+15f
11719 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
11720 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
11721 path.lineTo(SkBits2Float(0xda45ad4e), SkBits2Float(0xedce4a04));  // -1.39103e+16f, -7.98042e+27f
11722 path.lineTo(SkBits2Float(0xac0e45da), SkBits2Float(0x8f632841));  // -2.02182e-12f, -1.11997e-29f
11723 path.lineTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb));  // -4.20789e+07f, 2.54923e-23f
11724 path.close();
11725 path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb));  // -4.20789e+07f, 2.54923e-23f
11726 path.quadTo(SkBits2Float(0xf35c4ad5), SkBits2Float(0x0692f251), SkBits2Float(0x69632126), SkBits2Float(0xb927af67));  // -1.74534e+31f, 5.52751e-35f, 1.71614e+25f, -0.000159917f
11727 path.moveTo(SkBits2Float(0x6534bff9), SkBits2Float(0x434a9986));  // 5.3348e+22f, 202.6f
11728 path.quadTo(SkBits2Float(0x37c603e5), SkBits2Float(0xa0683953), SkBits2Float(0x751915e4), SkBits2Float(0x831c911a));  // 2.36053e-05f, -1.96701e-19f, 1.94059e+32f, -4.60108e-37f
11729 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
11730 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
11732     SkPath path2(path);
11737     SkPath path;
11738     path.setFillType((SkPathFillType) 1);
11739 path.moveTo(SkBits2Float(0x7c223bab), SkBits2Float(0x7cf35966));  // 3.36945e+36f, 1.01083e+37f
11740 path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0x7ccaca6d), SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 8.4236e+36f, 0, 0
11741 path.lineTo(SkBits2Float(0x7d7d7d7d), SkBits2Float(0x00000000));  // 2.10591e+37f, 0
11742 path.quadTo(SkBits2Float(0x7ccacab0), SkBits2Float(0x7d1817f4), SkBits2Float(0x7c223bab), SkBits2Float(0x7cf35966));  // 8.42364e+36f, 1.26354e+37f, 3.36945e+36f, 1.01083e+37f
11743 path.close();
11745     SkPath path1(path);
11746     path.reset();
11747     path.setFillType((SkPathFillType) 0);
11748 path.moveTo(SkBits2Float(0x109d0000), SkBits2Float(0xff7bc000));  // 6.19256e-29f, -3.34633e+38f
11749 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
11750 path.quadTo(SkBits2Float(0x72728302), SkBits2Float(0x8b727272), SkBits2Float(0x72727272), SkBits2Float(0xc00308f6));  // 4.80344e+30f, -4.66936e-32f, 4.80216e+30f, -2.04742f
11751 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
11753     SkPath path2(path);
11758     SkPath path;
11759     path.setFillType((SkPathFillType) 0);
11761     SkPath path1(path);
11762     path.reset();
11763     path.setFillType((SkPathFillType) 0);
11764 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11765 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
11766 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
11767 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
11768 path.moveTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f
11769 path.moveTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030));  // 5.01357e+33f, 6.40969e-10f
11770 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
11771 path.lineTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030));  // 5.01357e+33f, 6.40969e-10f
11772 path.close();
11773 path.moveTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030));  // 5.01357e+33f, 6.40969e-10f
11774 path.lineTo(SkBits2Float(0x7f303030), SkBits2Float(0x7a303030));  // 2.34194e+38f, 2.28705e+35f
11775 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
11776 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
11777 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
11778 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
11779 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
11780 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
11781 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
11782 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
11783 path.moveTo(SkBits2Float(0x77303030), SkBits2Float(0xff303030));  // 3.57352e+33f, -2.34194e+38f
11784 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
11785 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x77303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f, 3.57352e+33f, 6.40969e-10f
11786 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
11787 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a7a3030));  // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 3.24763e+35f
11788     SkPath path2(path);
11793     SkPath path;
11794     path.setFillType((SkPathFillType) 0);
11796     SkPath path1(path);
11797     path.reset();
11798     path.setFillType((SkPathFillType) 0);
11799 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11800     path.conicTo(SkBits2Float(0x44444444), SkBits2Float(0x44444444), SkBits2Float(0x44263030), SkBits2Float(0x44304430), SkBits2Float(0x4c444430));  // 785.067f, 785.067f, 664.753f, 705.065f, 5.145e+07f
11801 path.moveTo(SkBits2Float(0x44444444), SkBits2Float(0x44444444));  // 785.067f, 785.067f
11802 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
11803     SkPath path2(path);
11808     SkPath path;
11809     path.setFillType((SkPathFillType) 1);
11811     SkPath path1(path);
11812     path.reset();
11813     path.setFillType((SkPathFillType) 0);
11814 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11815 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
11816 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
11817 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11818 path.close();
11819 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11820 path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x7272081f));  // 1.43144e-13f, 4.79393e+30f
11821 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x5974fa80), SkBits2Float(0x00747474), SkBits2Float(0x59585264));  // 4.80216e+30f, 4.30971e+15f, 1.06947e-38f, 3.80557e+15f
11822 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
11823 path.quadTo(SkBits2Float(0x80807d80), SkBits2Float(0x80808080), SkBits2Float(0xff7f0000), SkBits2Float(0x80808080));  // -1.18e-38f, -1.1801e-38f, -3.38953e+38f, -1.1801e-38f
11824 path.quadTo(SkBits2Float(0x80808080), SkBits2Float(0x80808080), SkBits2Float(0xed842b00), SkBits2Float(0x7252ff6d));  // -1.1801e-38f, -1.1801e-38f, -5.113e+27f, 4.17924e+30f
11825 path.quadTo(SkBits2Float(0x72577200), SkBits2Float(0x55525352), SkBits2Float(0x2a212a8c), SkBits2Float(0x7272081f));  // 4.26733e+30f, 1.44535e+13f, 1.43144e-13f, 4.79393e+30f
11826 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x6f740080), SkBits2Float(0x8c556874), SkBits2Float(0x2982ffff));  // 4.80216e+30f, 7.55149e+28f, -1.64404e-31f, 5.81757e-14f
11828     SkPath path2(path);
11833     SkPath path;
11834     path.setFillType((SkPathFillType) 1);
11836     SkPath path1(path);
11837     path.reset();
11838     path.setFillType((SkPathFillType) 0);
11839 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11840 path.lineTo(SkBits2Float(0xed0081bc), SkBits2Float(0x1b2d8040));  // -2.48568e+27f, 1.43517e-22f
11841 path.moveTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474));  // 7.74703e+31f, 5.42799e-14f
11842 path.close();
11843 path.moveTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474));  // 7.74703e+31f, 5.42799e-14f
11844 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
11845 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
11846 path.lineTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474));  // 7.74703e+31f, 5.42799e-14f
11847 path.close();
11848 path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad));  // -1.43244e-16f, 3.88004e+11f
11849 path.close();
11850 path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad));  // -1.43244e-16f, 3.88004e+11f
11851 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52524872), SkBits2Float(0x72525252), SkBits2Float(0x72727272));  // 4.80216e+30f, 2.2579e+11f, 4.16585e+30f, 4.80216e+30f
11852 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0x80406666), SkBits2Float(0x68291b2d), SkBits2Float(0x0315ff80));  // 4.80215e+30f, -5.91421e-39f, 3.19432e+24f, 4.40805e-37f
11853 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
11854 path.lineTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad));  // -1.43244e-16f, 3.88004e+11f
11855 path.close();
11856 path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad));  // -1.43244e-16f, 3.88004e+11f
11857 path.quadTo(SkBits2Float(0x72727227), SkBits2Float(0x72727272), SkBits2Float(0x74727272), SkBits2Float(0x55747421));  // 4.80214e+30f, 4.80216e+30f, 7.68345e+31f, 1.67987e+13f
11858 path.lineTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad));  // -1.43244e-16f, 3.88004e+11f
11859 path.close();
11860 path.moveTo(SkBits2Float(0x724b0000), SkBits2Float(0x00725f72));  // 4.02083e+30f, 1.05035e-38f
11861 path.lineTo(SkBits2Float(0x52525252), SkBits2Float(0x72725252));  // 2.25831e+11f, 4.79967e+30f
11862 path.quadTo(SkBits2Float(0x26727272), SkBits2Float(0x0303a525), SkBits2Float(0x52005c03), SkBits2Float(0x72525252));  // 8.41157e-16f, 3.8687e-37f, 1.37825e+11f, 4.16585e+30f
11863 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x1ff07255), SkBits2Float(0x2a8c5572), SkBits2Float(0x21082a21));  // 4.80216e+30f, 1.01833e-19f, 2.49283e-13f, 4.61343e-19f
11864 path.lineTo(SkBits2Float(0x2a2a3a21), SkBits2Float(0x29212828));  // 1.51192e-13f, 3.5784e-14f
11866     SkPath path2(path);
11871     SkPath path;
11872     path.setFillType((SkPathFillType) 0);
11874     SkPath path1(path);
11875     path.reset();
11876     path.setFillType((SkPathFillType) 0);
11877 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11878 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
11879 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878));  // 2.01583e+34f, 2.01583e+34f
11880 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878));  // 2.01583e+34f, 2.01583e+34f
11881 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878));  // 2.01583e+34f, 2.01583e+34f
11882 path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x78787878), SkBits2Float(0x78787878), SkBits2Float(0x78787878));  // 6.40969e-10f, 2.01583e+34f, 2.01583e+34f, 2.01583e+34f
11883 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f
11884 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f
11885 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f
11886 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f
11887 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f
11888 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f
11889 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f
11890 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f
11891 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f
11892 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f
11893 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f
11894 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f
11895 path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030));  // 6.40969e-10f, 6.40969e-10f
11896 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x7878788d));  // 2.01583e+34f, 2.01584e+34f
11897 path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x30303030));  // 2.01583e+34f, 6.40969e-10f
11899     SkPath path2(path);
11904     SkPath path;
11905     path.setFillType((SkPathFillType) 1);
11906 path.moveTo(SkBits2Float(0x70621ede), SkBits2Float(0x00000000));  // 2.79924e+29f, 0
11907 path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x74fc5b97), SkBits2Float(0x7d458fe4));  // 0, 0, 0, 1.59951e+32f, 1.64128e+37f
11908 path.lineTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000));  // -1.44916e+29f, 0
11909 path.lineTo(SkBits2Float(0x70621ede), SkBits2Float(0x00000000));  // 2.79924e+29f, 0
11910 path.close();
11911 path.moveTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000));  // -1.44916e+29f, 0
11912 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11913 path.lineTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000));  // -1.44916e+29f, 0
11914 path.close();
11916     SkPath path1(path);
11917     path.reset();
11918     path.setFillType((SkPathFillType) 0);
11920     SkPath path2(path);
11925     SkPath path;
11926     path.setFillType((SkPathFillType) 1);
11928     SkPath path1(path);
11929     path.reset();
11930     path.setFillType((SkPathFillType) 0);
11931 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11932 path.quadTo(SkBits2Float(0x868b5aae), SkBits2Float(0x626c45ab), SkBits2Float(0xefea1ffe), SkBits2Float(0x0029fc76));  // -5.24192e-35f, 1.08961e+21f, -1.44916e+29f, 3.85582e-39f
11933 path.moveTo(SkBits2Float(0xfacbff01), SkBits2Float(0x56fc5b97));  // -5.29604e+35f, 1.38735e+14f
11934 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
11936     SkPath path2(path);
11941     SkPath path;
11942     path.setFillType((SkPathFillType) 1);
11944     SkPath path1(path);
11945     path.reset();
11946     path.setFillType((SkPathFillType) 0);
11947 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11948 path.quadTo(SkBits2Float(0x29ff4bae), SkBits2Float(0xa1d75590), SkBits2Float(0x9fd6f6c3), SkBits2Float(0x70621ede));  // 1.13374e-13f, -1.45916e-18f, -9.10408e-20f, 2.79924e+29f
11949 path.quadTo(SkBits2Float(0x57a839d3), SkBits2Float(0x1a80d34b), SkBits2Float(0x0147a31b), SkBits2Float(0xff7fffff));  // 3.69933e+14f, 5.32809e-23f, 3.66675e-38f, -3.40282e+38f
11950 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11951 path.close();
11952 path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef));  // 7.64778e-23f, -2.54344e-26f
11953 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
11954 path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef));  // 7.64778e-23f, -2.54344e-26f
11955 path.close();
11956 path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef));  // 7.64778e-23f, -2.54344e-26f
11957 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
11958 path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef));  // 7.64778e-23f, -2.54344e-26f
11959 path.close();
11960 path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef));  // 7.64778e-23f, -2.54344e-26f
11961 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
11962 path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef));  // 7.64778e-23f, -2.54344e-26f
11963 path.close();
11965     SkPath path2(path);
11970     SkPath path;
11971     path.setFillType((SkPathFillType) 1);
11972 path.moveTo(SkBits2Float(0x7644b829), SkBits2Float(0x00000000));  // 9.97486e+32f, 0
11973 path.lineTo(SkBits2Float(0x74fc5b97), SkBits2Float(0x77df944a));  // 1.59951e+32f, 9.06945e+33f
11974 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf8fbe3ff));  // 0, -4.08716e+34f
11975 path.lineTo(SkBits2Float(0x7644b829), SkBits2Float(0x00000000));  // 9.97486e+32f, 0
11976 path.close();
11978     SkPath path1(path);
11979     path.reset();
11980     path.setFillType((SkPathFillType) 0);
11981 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
11982 path.quadTo(SkBits2Float(0x45ab86ae), SkBits2Float(0xd6d6626c), SkBits2Float(0xd6d6d6d6), SkBits2Float(0x7644d6d6));  // 5488.83f, -1.17859e+14f, -1.18109e+14f, 9.98093e+32f
11983 path.moveTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0xd6d6d6d6));  // -1.18109e+14f, -1.18109e+14f
11984 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
11985 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
11986 path.lineTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0xd6d6d6d6));  // -1.18109e+14f, -1.18109e+14f
11987 path.close();
11988 path.moveTo(SkBits2Float(0xef08a412), SkBits2Float(0x5aaeff7f));  // -4.22883e+28f, 2.46288e+16f
11989 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
11990 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
11991 path.lineTo(SkBits2Float(0xef08a412), SkBits2Float(0x5aaeff7f));  // -4.22883e+28f, 2.46288e+16f
11992 path.close();
11994     SkPath path2(path);
12000     SkPath path;
12001     path.setFillType((SkPathFillType) 0);
12002 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12003 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
12004 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
12005 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12006 path.close();
12007 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12008 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
12009 path.quadTo(SkBits2Float(0xd7da0000), SkBits2Float(0x5252525a), SkBits2Float(0x72525252), SkBits2Float(0x72727272));  // -4.79387e+14f, 2.25831e+11f, 4.16585e+30f, 4.80216e+30f
12010 path.quadTo(SkBits2Float(0x48525252), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255));  // 215369, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f
12011 path.quadTo(SkBits2Float(0xdada007b), SkBits2Float(0x5252525a), SkBits2Float(0x72675252), SkBits2Float(0x72727272));  // -3.0681e+16f, 2.25831e+11f, 4.5818e+30f, 4.80216e+30f
12012 path.quadTo(SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272), SkBits2Float(0x72727272));  // 2.25831e+11f, 3.36289e-15f, 4.80216e+30f, 4.80216e+30f
12013 path.quadTo(SkBits2Float(0x1c292172), SkBits2Float(0x7bc00321), SkBits2Float(0x9aaaaaaa), SkBits2Float(0x8c556a4b));  // 5.59606e-22f, 1.99397e+36f, -7.05861e-23f, -1.64409e-31f
12014 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252));  // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f
12015 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12016 path.close();
12017 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad));  // -1.43243e-16f, 3.88004e+11f
12018 path.close();
12019 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad));  // -1.43243e-16f, 3.88004e+11f
12020 path.quadTo(SkBits2Float(0x72725570), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272));  // 4.79991e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
12021 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0x555bb672), SkBits2Float(0x29686968), SkBits2Float(0x252a081f));  // 4.80215e+30f, 1.50985e+13f, 5.16058e-14f, 1.47479e-16f
12022 path.moveTo(SkBits2Float(0x5d68392a), SkBits2Float(0x01002780));  // 1.04584e+18f, 2.35382e-38f
12023 path.moveTo(SkBits2Float(0x72727200), SkBits2Float(0x72725252));  // 4.80212e+30f, 4.79967e+30f
12024 path.quadTo(SkBits2Float(0x5adada00), SkBits2Float(0xa5252652), SkBits2Float(0x727272ad), SkBits2Float(0xda007b72));  // 3.08006e+16f, -1.43245e-16f, 4.80218e+30f, -9.04113e+15f
12025 path.lineTo(SkBits2Float(0x5252525a), SkBits2Float(0x72525252));  // 2.25831e+11f, 4.16585e+30f
12026 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272));  // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
12027 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x74217472), SkBits2Float(0x005b5574), SkBits2Float(0x72680000));  // 4.80216e+30f, 5.11671e+31f, 8.38768e-39f, 4.59523e+30f
12028 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x007b7272), SkBits2Float(0x525adada));  // 4.80216e+30f, 2.25831e+11f, 1.13368e-38f, 2.34994e+11f
12029 path.lineTo(SkBits2Float(0x72727200), SkBits2Float(0x72725252));  // 4.80212e+30f, 4.79967e+30f
12030 path.close();
12032     SkPath path1(path);
12033     path.reset();
12034     path.setFillType((SkPathFillType) 0);
12036     SkPath path2(path);
12043     SkPath path;
12044     path.setFillType((SkPathFillType) 0);
12045 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500));  // 0, 1.32857e+13f
12046 path.lineTo(SkBits2Float(0x55555568), SkBits2Float(0x55555555));  // 1.46602e+13f, 1.46602e+13f
12047 path.lineTo(SkBits2Float(0x98989898), SkBits2Float(0x55989898));  // -3.94452e-24f, 2.09726e+13f
12048 path.lineTo(SkBits2Float(0xf6f65555), SkBits2Float(0x101006f6));  // -2.49812e+33f, 2.84044e-29f
12049 path.quadTo(SkBits2Float(0xdca33f10), SkBits2Float(0xf6f6f6f6), SkBits2Float(0xf621f6f6), SkBits2Float(0xf70ff6f6));  // -3.67598e+17f, -2.50452e+33f, -8.21259e+32f, -2.91995e+33f
12050 path.lineTo(SkBits2Float(0x9400f6f6), SkBits2Float(0x10530000));  // -6.51105e-27f, 4.16124e-29f
12051 path.quadTo(SkBits2Float(0x0f101010), SkBits2Float(0x00101010), SkBits2Float(0xf610f720), SkBits2Float(0xf6f6f6f6));  // 7.10284e-30f, 1.47513e-39f, -7.35062e+32f, -2.50452e+33f
12052 path.lineTo(SkBits2Float(0x105352f6), SkBits2Float(0x1cf6ff10));  // 4.16763e-29f, 1.63448e-21f
12053 path.lineTo(SkBits2Float(0xf6f6220a), SkBits2Float(0x003700f6));  // -2.49608e+33f, 5.0513e-39f
12054 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
12055 path.quadTo(SkBits2Float(0x10101007), SkBits2Float(0x10f7fd10), SkBits2Float(0xf6f6f6f6), SkBits2Float(0xf6f645e0));  // 2.84113e-29f, 9.78142e-29f, -2.50452e+33f, -2.4975e+33f
12056 path.lineTo(SkBits2Float(0xed9ef6f6), SkBits2Float(0x53535353));  // -6.14965e+27f, 9.07636e+11f
12057 path.lineTo(SkBits2Float(0x53006cf6), SkBits2Float(0x53295353));  // 5.51584e+11f, 7.27247e+11f
12058 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500));  // 0, 1.32857e+13f
12059 path.close();
12060 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500));  // 0, 1.32857e+13f
12061 path.lineTo(SkBits2Float(0xf6f6f6f6), SkBits2Float(0x5353d9f6));  // -2.50452e+33f, 9.09895e+11f
12063     SkPath path1(path);
12064     path.reset();
12065     path.setFillType((SkPathFillType) 0);
12067     SkPath path2(path);
12073     SkPath path;
12074     path.setFillType((SkPathFillType) 0);
12075 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12076 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
12077 path.quadTo(SkBits2Float(0x525252c7), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255));  // 2.25833e+11f, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f
12078 path.quadTo(SkBits2Float(0xd7da0000), SkBits2Float(0x5adada00), SkBits2Float(0x52525252), SkBits2Float(0x00005252));  // -4.79387e+14f, 3.08006e+16f, 2.25831e+11f, 2.9531e-41f
12079 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
12080 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12081 path.close();
12082 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12083 path.quadTo(SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255), SkBits2Float(0xda007b72));  // 4.79967e+30f, 4.80216e+30f, 4.80215e+30f, -9.04113e+15f
12084 path.lineTo(SkBits2Float(0x5252525a), SkBits2Float(0x72525252));  // 2.25831e+11f, 4.16585e+30f
12085 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272));  // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
12086 path.lineTo(SkBits2Float(0x7bc00321), SkBits2Float(0x9aaaaaaa));  // 1.99397e+36f, -7.05861e-23f
12087 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252));  // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f
12088 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12089 path.close();
12090 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad));  // -1.43243e-16f, 3.88004e+11f
12091 path.close();
12092 path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad));  // -1.43243e-16f, 3.88004e+11f
12093 path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272));  // 4.80216e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
12094 path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x26525ada), SkBits2Float(0x72ada525));  // 4.80215e+30f, -9.04113e+15f, 7.29815e-16f, 6.87879e+30f
12095 path.quadTo(SkBits2Float(0x007b7272), SkBits2Float(0x525adada), SkBits2Float(0x52525252), SkBits2Float(0x72727252));  // 1.13368e-38f, 2.34994e+11f, 2.25831e+11f, 4.80215e+30f
12096 path.quadTo(SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72722772), SkBits2Float(0x72727272));  // 2.25966e+11f, 2.25831e+11f, 4.79636e+30f, 4.80216e+30f
12097 path.quadTo(SkBits2Float(0x74727272), SkBits2Float(0x55747421), SkBits2Float(0x0000005b), SkBits2Float(0x72727268));  // 7.68345e+31f, 1.67987e+13f, 1.27518e-43f, 4.80216e+30f
12098 path.quadTo(SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72727272), SkBits2Float(0x72557272));  // 2.25966e+11f, 2.25831e+11f, 4.80216e+30f, 4.22775e+30f
12099 path.quadTo(SkBits2Float(0x5adada72), SkBits2Float(0x52525252), SkBits2Float(0x72725252), SkBits2Float(0x72727272));  // 3.08009e+16f, 2.25831e+11f, 4.79967e+30f, 4.80216e+30f
12101     SkPath path1(path);
12102     path.reset();
12103     path.setFillType((SkPathFillType) 0);
12105     SkPath path2(path);
12110     SkPath path;
12111     path.setFillType((SkPathFillType) 0);
12113     SkPath path1(path);
12114     path.reset();
12115     path.setFillType((SkPathFillType) 0);
12116 path.moveTo(SkBits2Float(0x68546829), SkBits2Float(0x555b2d29));  // 4.01225e+24f, 1.50617e+13f
12117 path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0x4b7b2108));  // 3.60404e-20f, 1.6458e+07f
12118 path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55));  // 9.43289e-15f, 4.8745e+16f
12119 path.moveTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b));  // 3.48195e+24f, -2.87586e+29f
12120 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
12121 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x3b2a8c55));  // 4.85282e+16f, 0.00260236f
12122 path.lineTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b));  // 3.48195e+24f, -2.87586e+29f
12123 path.close();
12124 path.moveTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b));  // 3.48195e+24f, -2.87586e+29f
12125 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
12126 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
12127 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
12128 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b));  // 3.50084e+24f, -2.87489e+29f
12129 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
12130 path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55));  // 4.85282e+16f, 5.7784e-19f
12131 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
12132 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
12133 path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b));  // 3.50084e+24f, -2.87489e+29f
12134 path.close();
12135 path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b));  // 3.50084e+24f, -2.87489e+29f
12136 path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d));  // 3.20982e+24f, 1.21279e-11f
12137 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
12138 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
12139 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
12140 path.close();
12141 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
12142 path.quadTo(SkBits2Float(0x2828102a), SkBits2Float(0x2c682921), SkBits2Float(0x8c555bf6), SkBits2Float(0x6d03de30));  // 9.32938e-15f, 3.2992e-12f, -1.64366e-31f, 2.5507e+27f
12143 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
12144 path.lineTo(SkBits2Float(0x3a803adf), SkBits2Float(0x8a294f1a));  // 0.000978317f, -8.15193e-33f
12145 path.quadTo(SkBits2Float(0x291d9628), SkBits2Float(0x2a43e62b), SkBits2Float(0x093a2a81), SkBits2Float(0x5c5c8ced));  // 3.49912e-14f, 1.73993e-13f, 2.24089e-33f, 2.48318e+17f
12146 path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
12147 path.close();
12148 path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527));  // 3.16127e+24f, -2.87614e+29f
12149 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
12150 path.lineTo(SkBits2Float(0x1f212a8c), SkBits2Float(0xc0032108));  // 3.41283e-20f, -2.04889f
12151 path.lineTo(SkBits2Float(0xed847b4b), SkBits2Float(0x2d552829));  // -5.12513e+27f, 1.21166e-11f
12152 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
12154     SkPath path2(path);
12159     SkPath path;
12160     path.setFillType((SkPathFillType) 1);
12161 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12162 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
12163 path.conicTo(SkBits2Float(0x66f837a9), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x3f823406));  // 5.86087e+23f, 0, 0, 0, 1.01721f
12164 path.close();
12165 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12166 path.quadTo(SkBits2Float(0x675b1bfe), SkBits2Float(0x00000000), SkBits2Float(0x67d76c42), SkBits2Float(0x6292c469));  // 1.03471e+24f, 0, 2.03461e+24f, 1.35369e+21f
12167 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
12168 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
12169 path.quadTo(SkBits2Float(0x679e1b26), SkBits2Float(0x687703c4), SkBits2Float(0x00000000), SkBits2Float(0x687d2968));  // 1.49327e+24f, 4.66598e+24f, 0, 4.78209e+24f
12170 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12171 path.close();
12173     SkPath path1(path);
12174     path.reset();
12175     path.setFillType((SkPathFillType) 0);
12176 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12177 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
12178 path.quadTo(SkBits2Float(0xf8f8c0ed), SkBits2Float(0xf8f8f8f8), SkBits2Float(0x9f9f9f9f), SkBits2Float(0x3014149f));  // -4.03626e+34f, -4.03981e+34f, -6.76032e-20f, 5.38714e-10f
12180     SkPath path2(path);
12185     SkPath path;
12186     path.setFillType((SkPathFillType) 1);
12187 path.setFillType(SkPathFillType::kEvenOdd);
12188 path.moveTo(SkBits2Float(0xd4438848), SkBits2Float(0xd488cf64));  // -3.35922e+12f, -4.70076e+12f
12189 path.lineTo(SkBits2Float(0xd43a056e), SkBits2Float(0xd4851696));  // -3.19582e+12f, -4.57288e+12f
12190 path.quadTo(SkBits2Float(0xd3d48e79), SkBits2Float(0xd49fb136), SkBits2Float(0x00000000), SkBits2Float(0xd4d4d4d4));  // -1.82585e+12f, -5.48698e+12f, 0, -7.31283e+12f
12191 path.quadTo(SkBits2Float(0xd3d06670), SkBits2Float(0xd4a0bb38), SkBits2Float(0xd41d628f), SkBits2Float(0xd472c531));  // -1.79014e+12f, -5.52269e+12f, -2.70385e+12f, -4.17076e+12f
12192 path.lineTo(SkBits2Float(0xd43a0559), SkBits2Float(0xd485168e));  // -3.19581e+12f, -4.57287e+12f
12193 path.lineTo(SkBits2Float(0xd446958b), SkBits2Float(0xd4810278));  // -3.41165e+12f, -4.43274e+12f
12194 path.lineTo(SkBits2Float(0xd443884a), SkBits2Float(0xd488cf65));  // -3.35922e+12f, -4.70076e+12f
12195 path.quadTo(SkBits2Float(0xd47efa09), SkBits2Float(0xd49fd72a), SkBits2Float(0xd4a63f0f), SkBits2Float(0xd4b83ab3));  // -4.38047e+12f, -5.49208e+12f, -5.71218e+12f, -6.33007e+12f
12196 path.lineTo(SkBits2Float(0xd497ca70), SkBits2Float(0xd4c4d4ae));  // -5.21549e+12f, -6.76305e+12f
12197 path.lineTo(SkBits2Float(0xd459d4d4), SkBits2Float(0xd4c4d4d4));  // -3.74231e+12f, -6.76307e+12f
12198 path.lineTo(SkBits2Float(0xd440daf9), SkBits2Float(0xd4c632d3));  // -3.31323e+12f, -6.81005e+12f
12199 path.lineTo(SkBits2Float(0xd4438848), SkBits2Float(0xd488cf64));  // -3.35922e+12f, -4.70076e+12f
12200 path.close();
12201 path.moveTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84));  // -4.23412e+12f, -7.20837e+12f
12202 path.lineTo(SkBits2Float(0xd4422174), SkBits2Float(0xd4d02069));  // -3.33514e+12f, -7.15118e+12f
12203 path.lineTo(SkBits2Float(0xd440daa3), SkBits2Float(0xd4c632d9));  // -3.31321e+12f, -6.81005e+12f
12204 path.lineTo(SkBits2Float(0xd41017bc), SkBits2Float(0xd4cb99b6));  // -2.47549e+12f, -6.99566e+12f
12205 path.lineTo(SkBits2Float(0xd442213b), SkBits2Float(0xd4d02067));  // -3.33512e+12f, -7.15117e+12f
12206 path.lineTo(SkBits2Float(0xd442d4d4), SkBits2Float(0xd4d4d4d4));  // -3.34718e+12f, -7.31283e+12f
12207 path.lineTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84));  // -4.23412e+12f, -7.20837e+12f
12208 path.close();
12209 path.moveTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e));  // -4.06264e+12f, -4.06265e+12f
12210 path.lineTo(SkBits2Float(0xd484e02c), SkBits2Float(0xd45fafcd));  // -4.56557e+12f, -3.84291e+12f
12211 path.lineTo(SkBits2Float(0xd462c867), SkBits2Float(0xd45655f7));  // -3.8961e+12f, -3.68226e+12f
12212 path.lineTo(SkBits2Float(0xd45ac463), SkBits2Float(0xd45ac505));  // -3.75839e+12f, -3.75843e+12f
12213 path.lineTo(SkBits2Float(0xd43d2fa9), SkBits2Float(0xd43d2fb5));  // -3.25019e+12f, -3.2502e+12f
12214 path.lineTo(SkBits2Float(0xd41d6287), SkBits2Float(0xd472c52a));  // -2.70385e+12f, -4.17076e+12f
12215 path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0xd3db1b95), SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, -1.88212e+12f, 0, 0
12216 path.quadTo(SkBits2Float(0xd4b7efac), SkBits2Float(0x00000000), SkBits2Float(0xd4d0e88f), SkBits2Float(0xd40b8b46));  // -6.32e+12f, 0, -7.17804e+12f, -2.39735e+12f
12217 path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0x00000000));  // -7.31283e+12f, 0
12218 path.lineTo(SkBits2Float(0xdcdc154b), SkBits2Float(0x00000000));  // -4.95583e+17f, 0
12219 path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4c4d477));  // -7.31283e+12f, -6.76303e+12f
12220 path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d442));  // -7.31283e+12f, -7.31275e+12f
12221 path.lineTo(SkBits2Float(0xd4d4a691), SkBits2Float(0xd4d4d442));  // -7.30662e+12f, -7.31275e+12f
12222 path.lineTo(SkBits2Float(0xd454d4d4), SkBits2Float(0xd4d4aa30));  // -3.65641e+12f, -7.30711e+12f
12223 path.lineTo(SkBits2Float(0xd4bd9def), SkBits2Float(0xd4d43df0));  // -6.51519e+12f, -7.29258e+12f
12224 path.lineTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84));  // -4.23412e+12f, -7.20837e+12f
12225 path.lineTo(SkBits2Float(0xd497ca70), SkBits2Float(0xd4c4d4ae));  // -5.21549e+12f, -6.76305e+12f
12226 path.lineTo(SkBits2Float(0xd4bab953), SkBits2Float(0xd4c4d48e));  // -6.41579e+12f, -6.76304e+12f
12227 path.lineTo(SkBits2Float(0xd4a63f0f), SkBits2Float(0xd4b83ab3));  // -5.71218e+12f, -6.33007e+12f
12228 path.lineTo(SkBits2Float(0xd4ae61eb), SkBits2Float(0xd4ae61f4));  // -5.99174e+12f, -5.99174e+12f
12229 path.lineTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e));  // -4.06264e+12f, -4.06265e+12f
12230 path.close();
12231 path.moveTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e));  // -4.06264e+12f, -4.06265e+12f
12232 path.lineTo(SkBits2Float(0xd446965c), SkBits2Float(0xd4810237));  // -3.4117e+12f, -4.4327e+12f
12233 path.lineTo(SkBits2Float(0xd45ac549), SkBits2Float(0xd45ac55f));  // -3.75845e+12f, -3.75846e+12f
12234 path.lineTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e));  // -4.06264e+12f, -4.06265e+12f
12235 path.close();
12236 path.moveTo(SkBits2Float(0xd4b46028), SkBits2Float(0xd41e572a));  // -6.19766e+12f, -2.72027e+12f
12237 path.lineTo(SkBits2Float(0xd4cde20a), SkBits2Float(0xd434bb57));  // -7.07408e+12f, -3.10495e+12f
12238 path.lineTo(SkBits2Float(0xd4c75ffe), SkBits2Float(0xd46f215d));  // -6.85047e+12f, -4.10823e+12f
12239 path.lineTo(SkBits2Float(0xd4b46028), SkBits2Float(0xd41e572a));  // -6.19766e+12f, -2.72027e+12f
12240 path.close();
12242     SkPath path1(path);
12243     path.reset();
12244     path.setFillType((SkPathFillType) 0);
12245 path.setFillType(SkPathFillType::kWinding);
12246 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12247 path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0xa5a50000), SkBits2Float(0xd4d4a5a5), SkBits2Float(0xd4d4d4d4));  // 0, -2.86229e-16f, -7.3065e+12f, -7.31283e+12f
12248 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4cfd4d4), SkBits2Float(0xd4d41dd4));  // -7.31283e+12f, -7.31283e+12f, -7.14103e+12f, -7.28827e+12f
12249 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d432d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4a5a5d4));  // -7.31283e+12f, -7.29109e+12f, -7.31283e+12f, -5.69161e+12f
12250 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0x00000000));  // -7.31283e+12f, -7.31283e+12f, -7.31283e+12f, 0
12251 path.moveTo(SkBits2Float(0xa5a5a500), SkBits2Float(0xd4d4d4a5));  // -2.87347e-16f, -7.31281e+12f
12252 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0x2ad4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4cfd4d4));  // -7.31283e+12f, 3.78064e-13f, -7.31283e+12f, -7.14103e+12f
12253 path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4));  // -7.31283e+12f, -7.31283e+12f, -7.31283e+12f, -7.31283e+12f
12254 path.quadTo(SkBits2Float(0xd4d40000), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4));  // -7.28426e+12f, -7.31283e+12f, -7.31283e+12f, -7.31283e+12f
12256     SkPath path2(path);
12261     SkPath path;
12262     path.setFillType((SkPathFillType) 0);
12263 path.setFillType(SkPathFillType::kWinding);
12264 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268));  // 1.59583e+13f, 5.20715e+30f
12265 path.quadTo(SkBits2Float(0xe0e02972), SkBits2Float(0xe0e060e0), SkBits2Float(0x728e4603), SkBits2Float(0x72727272));  // -1.29221e+20f, -1.29345e+20f, 5.63603e+30f, 4.80216e+30f
12266 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268));  // 1.59583e+13f, 5.20715e+30f
12267 path.close();
12268 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268));  // 1.59583e+13f, 5.20715e+30f
12269 path.quadTo(SkBits2Float(0x68720052), SkBits2Float(0x52527372), SkBits2Float(0x00527252), SkBits2Float(0x728e4601));  // 4.57127e+24f, 2.2597e+11f, 7.57152e-39f, 5.63603e+30f
12270 path.quadTo(SkBits2Float(0x52ec7272), SkBits2Float(0x6265527f), SkBits2Float(0x8e460152), SkBits2Float(0x72ff8072));  // 5.07766e+11f, 1.05756e+21f, -2.4406e-30f, 1.01215e+31f
12271 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268));  // 1.59583e+13f, 5.20715e+30f
12272 path.close();
12273 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268));  // 1.59583e+13f, 5.20715e+30f
12274 path.lineTo(SkBits2Float(0x52626552), SkBits2Float(0x72727272));  // 2.43091e+11f, 4.80216e+30f
12275 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x62727272), SkBits2Float(0x39393939), SkBits2Float(0x728bc739));  // 4.80216e+30f, 1.11809e+21f, 0.000176643f, 5.53719e+30f
12276 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
12277 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x56727272), SkBits2Float(0x72720152), SkBits2Float(0x72727270));  // 4.80216e+30f, 6.66433e+13f, 4.79341e+30f, 4.80216e+30f
12278 path.quadTo(SkBits2Float(0x52526172), SkBits2Float(0x8e460300), SkBits2Float(0x72727272), SkBits2Float(0x52525272));  // 2.25894e+11f, -2.44068e-30f, 4.80216e+30f, 2.25832e+11f
12279 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
12280 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268));  // 1.59583e+13f, 5.20715e+30f
12281 path.close();
12282 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268));  // 1.59583e+13f, 5.20715e+30f
12283 path.lineTo(SkBits2Float(0x72727272), SkBits2Float(0x52525f72));  // 4.80216e+30f, 2.25886e+11f
12284 path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268));  // 1.59583e+13f, 5.20715e+30f
12285 path.close();
12286 path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268));  // 1.59583e+13f, 5.20715e+30f
12287 path.quadTo(SkBits2Float(0x52727272), SkBits2Float(0x64655252), SkBits2Float(0x72c1c152), SkBits2Float(0x72727272));  // 2.60326e+11f, 1.69209e+22f, 7.67543e+30f, 4.80216e+30f
12289     SkPath path1(path);
12290     path.reset();
12291     path.setFillType((SkPathFillType) 0);
12292 path.setFillType(SkPathFillType::kWinding);
12294     SkPath path2(path);
12299     SkPath path;
12300     path.setFillType((SkPathFillType) 0);
12301 path.setFillType(SkPathFillType::kWinding);
12303     SkPath path1(path);
12304     path.reset();
12305     path.setFillType((SkPathFillType) 0);
12306 path.setFillType(SkPathFillType::kWinding);
12307 path.moveTo(SkBits2Float(0x46090052), SkBits2Float(0x7270726c));  // 8768.08f, 4.76254e+30f
12308 path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060));  // -5.63338e+19f, 1.32171e-36f
12309 path.close();
12310 path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060));  // -5.63338e+19f, 1.32171e-36f
12311 path.lineTo(SkBits2Float(0x77727272), SkBits2Float(0x52520072));  // 4.91741e+33f, 2.25488e+11f
12312 path.lineTo(SkBits2Float(0x46090052), SkBits2Float(0x727272ce));  // 8768.08f, 4.80219e+30f
12313 path.quadTo(SkBits2Float(0x725252ec), SkBits2Float(0x72727272), SkBits2Float(0x72727272), SkBits2Float(0x39393962));  // 4.16589e+30f, 4.80216e+30f, 4.80216e+30f, 0.000176644f
12314 path.lineTo(SkBits2Float(0x6c460900), SkBits2Float(0x72727072));  // 9.57639e+26f, 4.802e+30f
12315 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
12316 path.quadTo(SkBits2Float(0x725252ec), SkBits2Float(0x72727272), SkBits2Float(0x72727272), SkBits2Float(0x39393962));  // 4.16589e+30f, 4.80216e+30f, 4.80216e+30f, 0.000176644f
12317 path.lineTo(SkBits2Float(0x0052ca00), SkBits2Float(0x728e4603));  // 7.60297e-39f, 5.63603e+30f
12318 path.quadTo(SkBits2Float(0xff727272), SkBits2Float(0x52527272), SkBits2Float(0x39392072), SkBits2Float(0xe0393939));  // -3.22267e+38f, 2.25966e+11f, 0.000176551f, -5.3387e+19f
12319 path.lineTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060));  // -5.63338e+19f, 1.32171e-36f
12320 path.close();
12321 path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060));  // -5.63338e+19f, 1.32171e-36f
12322 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
12323 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
12324 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0xdada0072), SkBits2Float(0x52524b5a), SkBits2Float(0x72528000));  // 4.79991e+30f, -3.0681e+16f, 2.25802e+11f, 4.16938e+30f
12325 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0xca005252), SkBits2Float(0x46030052), SkBits2Float(0x7272728e));  // 4.80216e+30f, -2.10242e+06f, 8384.08f, 4.80217e+30f
12326 path.quadTo(SkBits2Float(0x7272ff72), SkBits2Float(0x20725252), SkBits2Float(0x39393939), SkBits2Float(0xd76ee039));  // 4.81307e+30f, 2.05254e-19f, 0.000176643f, -2.62647e+14f
12327 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
12328 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
12329 path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0xdada0072), SkBits2Float(0x52524b5a), SkBits2Float(0x72528000));  // 4.79991e+30f, -3.0681e+16f, 2.25802e+11f, 4.16938e+30f
12330 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272));  // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
12331 path.quadTo(SkBits2Float(0x72667254), SkBits2Float(0x00000040), SkBits2Float(0x00a70155), SkBits2Float(0x726800ff));  // 4.56447e+30f, 8.96831e-44f, 1.5337e-38f, 4.59531e+30f
12332 path.quadTo(SkBits2Float(0x7b727272), SkBits2Float(0xad000c52), SkBits2Float(0x1c10adad), SkBits2Float(0x72728d8a));  // 1.25886e+36f, -7.27869e-12f, 4.78701e-22f, 4.80425e+30f
12333 path.quadTo(SkBits2Float(0xff056546), SkBits2Float(0x727205ff), SkBits2Float(0x524b5aff), SkBits2Float(0x64005252));  // -1.77313e+38f, 4.79377e+30f, 2.18351e+11f, 9.46846e+21f
12334 path.quadTo(SkBits2Float(0x72524872), SkBits2Float(0xdada7272), SkBits2Float(0x5252525a), SkBits2Float(0x72727252));  // 4.16508e+30f, -3.07437e+16f, 2.25831e+11f, 4.80215e+30f
12335 path.quadTo(SkBits2Float(0x72724172), SkBits2Float(0xdad10072), SkBits2Float(0x52524b5a), SkBits2Float(0x725b8000));  // 4.79837e+30f, -2.94144e+16f, 2.25802e+11f, 4.34765e+30f
12336 path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272));  // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
12337 path.quadTo(SkBits2Float(0x72728372), SkBits2Float(0x00000040), SkBits2Float(0xf6a70147), SkBits2Float(0xc2c2c256));  // 4.80347e+30f, 8.96831e-44f, -1.69363e+33f, -97.3796f
12338 path.lineTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060));  // -5.63338e+19f, 1.32171e-36f
12339 path.close();
12340 path.moveTo(SkBits2Float(0x7a787a7a), SkBits2Float(0x7a3a7a7a));  // 3.22543e+35f, 2.42063e+35f
12341 path.lineTo(SkBits2Float(0x8f4603e0), SkBits2Float(0x72727272));  // -9.7629e-30f, 4.80216e+30f
12342 path.quadTo(SkBits2Float(0x00807272), SkBits2Float(0x46090052), SkBits2Float(0x7270726c), SkBits2Float(0x60e04372));  // 1.1796e-38f, 8768.08f, 4.76254e+30f, 1.29279e+20f
12343 path.moveTo(SkBits2Float(0x943603e0), SkBits2Float(0x77727272));  // -9.18942e-27f, 4.91741e+33f
12344 path.quadTo(SkBits2Float(0x5c525200), SkBits2Float(0x46090052), SkBits2Float(0x727272ce), SkBits2Float(0x5252ec72));  // 2.368e+17f, 8768.08f, 4.80219e+30f, 2.26478e+11f
12346     SkPath path2(path);
12351     SkPath path;
12352     path.setFillType((SkPathFillType) 0);
12353 path.setFillType(SkPathFillType::kWinding);
12355     SkPath path1(path);
12356     path.reset();
12357     path.setFillType((SkPathFillType) 0);
12358 path.setFillType(SkPathFillType::kWinding);
12359 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12360 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
12361 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
12362 path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00faf6f6));  // -1.71467e+38f, 2.30475e-38f
12363 path.moveTo(SkBits2Float(0x60576bfa), SkBits2Float(0x006df653));  // 6.20911e+19f, 1.00984e-38f
12364 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
12366     SkPath path2(path);
12371     SkPath path;
12372     path.setFillType((SkPathFillType) 1);
12373 path.setFillType(SkPathFillType::kEvenOdd);
12374 path.moveTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000));  // -1.71467e+38f, 0
12375 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf66e5600));  // 0, -1.20851e+33f
12376 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf629168b));  // 0, -8.57378e+32f
12377 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12378 path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000));  // -1.71467e+38f, 0
12379 path.close();
12381     SkPath path1(path);
12382     path.reset();
12383     path.setFillType((SkPathFillType) 0);
12384 path.setFillType(SkPathFillType::kWinding);
12385 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12386 path.lineTo(SkBits2Float(0x03e8f6f6), SkBits2Float(0xf7060000));  // 1.36924e-36f, -2.71784e+33f
12387 path.lineTo(SkBits2Float(0x4ff6f6f6), SkBits2Float(0x3e3e3e2a));  // 8.28676e+09f, 0.185784f
12388 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
12390     SkPath path2(path);
12395     SkPath path;
12396     path.setFillType((SkPathFillType) 0);
12397 path.setFillType(SkPathFillType::kWinding);
12399     SkPath path1(path);
12400     path.reset();
12401     path.setFillType((SkPathFillType) 0);
12402 path.setFillType(SkPathFillType::kWinding);
12403 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12404 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
12405 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
12406 path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00faf6f6));  // -1.71467e+38f, 2.30475e-38f
12407 path.moveTo(SkBits2Float(0x60576bfa), SkBits2Float(0x006df653));  // 6.20911e+19f, 1.00984e-38f
12408 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
12410     SkPath path2(path);
12415     SkPath path;
12416     path.setFillType((SkPathFillType) 1);
12417 path.setFillType(SkPathFillType::kEvenOdd);
12418 path.moveTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000));  // -1.71467e+38f, 0
12419 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf66e5600));  // 0, -1.20851e+33f
12420 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf629168b));  // 0, -8.57378e+32f
12421 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12422 path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000));  // -1.71467e+38f, 0
12423 path.close();
12425     SkPath path1(path);
12426     path.reset();
12427     path.setFillType((SkPathFillType) 0);
12428 path.setFillType(SkPathFillType::kWinding);
12429 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
12430 path.lineTo(SkBits2Float(0x03e8f6f6), SkBits2Float(0xf7060000));  // 1.36924e-36f, -2.71784e+33f
12431 path.lineTo(SkBits2Float(0x4ff6f6f6), SkBits2Float(0x3e3e3e2a));  // 8.28676e+09f, 0.185784f
12432 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
12434     SkPath path2(path);