Lines Matching refs:path
12 SkPath path;
13 path.setFillType(SkPath::kEvenOdd_FillType);
14 path.moveTo(555, 468);
15 path.lineTo(555, 362);
16 path.lineTo(872, 362);
17 path.lineTo(872, 468);
18 path.lineTo(555, 468);
19 path.close();
369 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
373 SkPath path;
374 path.setFillType(SkPath::kEvenOdd_FillType);
375 path.moveTo(1074.29285f, 627.292786f);
376 path.quadTo(1074.58582f, 627, 1075, 627);
377 path.lineTo(1117, 627);
378 path.quadTo(1124.04163f, 627, 1129.02246f, 631.9776f);
379 path.quadTo(1134, 636.958374f, 1134, 644);
380 path.lineTo(1134, 645);
381 path.quadTo(1134, 652.041626f, 1129.02246f, 657.0224f);
382 path.quadTo(1124.04163f, 662, 1117, 662);
383 path.lineTo(1075, 662);
384 path.quadTo(1074.58582f, 662, 1074.29285f, 661.707214f);
385 path.quadTo(1074, 661.414185f, 1074, 661);
386 path.lineTo(1074, 628);
387 path.quadTo(1074, 627.585815f, 1074.29285f, 627.292786f);
388 path.close();
389 path.moveTo(1076, 629);
390 path.lineTo(1117, 629);
391 path.cubicTo(1125.2843f, 629, 1132, 635.715698f, 1132, 644);
392 path.lineTo(1132, 645);
393 path.cubicTo(1132, 653.284302f, 1125.2843f, 660, 1117, 660);
394 path.lineTo(1076, 660);
395 path.lineTo(1076, 629);
396 path.close();
403 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
407 SkPath path;
408 path.setFillType(SkPath::kEvenOdd_FillType);
409 path.moveTo(301.464081f, 424);
410 path.lineTo(296, 433.46405f);
411 path.lineTo(296, 433.810822f);
412 path.lineTo(303.25589f, 438);
413 path.lineTo(304.729736f, 438);
414 path.lineTo(311, 427.139557f);
415 path.lineTo(311, 426.305237f);
416 path.lineTo(307.007202f, 424);
417 path.lineTo(301.464081f, 424);
418 path.close();
426 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
430 SkPath path;
431 path.setFillType(SkPath::kEvenOdd_FillType);
432 path.moveTo(818, 157);
433 path.cubicTo(818, 148.715729f, 824.715698f, 142, 833, 142);
434 path.lineTo(909, 142);
435 path.lineTo(909, 143);
436 path.lineTo(833, 143);
437 path.cubicTo(825.268005f, 143, 819, 149.268005f, 819, 157);
438 path.lineTo(819, 926);
439 path.lineTo(818, 926);
440 path.lineTo(818, 157);
441 path.close();
442 path.moveTo(1184, 926);
443 path.lineTo(1185, 926);
444 path.lineTo(1185, 157);
445 path.cubicTo(1185, 148.715729f, 1178.2843f, 142, 1170, 142);
446 path.lineTo(1093, 142);
447 path.lineTo(1093, 143);
448 path.lineTo(1170, 143);
449 path.cubicTo(1177.73193f, 143, 1184, 149.268005f, 1184, 157);
450 path.lineTo(1184, 926);
451 path.close();
458 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
462 SkPath path;
463 path.setFillType(SkPath::kEvenOdd_FillType);
464 path.moveTo(540.74231f, 215.922546f);
465 path.cubicTo(540.893127f, 215.391159f, 541.443909f, 215.090134f, 541.972473f, 215.250168f);
466 path.lineTo(581.213318f, 227.131104f);
467 path.cubicTo(581.741882f, 227.291153f, 582.048157f, 227.851654f, 581.897339f, 228.383041f);
468 path.lineTo(576.708923f, 246.663925f);
469 path.cubicTo(576.558167f, 247.195297f, 576.007324f, 247.496338f, 575.47876f, 247.336288f);
470 path.lineTo(536.237915f, 235.455353f);
471 path.cubicTo(535.709351f, 235.295319f, 535.403137f, 234.734802f, 535.553894f, 234.20343f);
472 path.lineTo(540.74231f, 215.922546f);
473 path.close();
481 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
485 SkPath path;
486 path.setFillType(SkPath::kEvenOdd_FillType);
487 path.moveTo(33, 787);
488 path.lineTo(33, 412);
489 path.lineTo(1233, 412);
490 path.lineTo(1233, 787);
491 path.quadTo(1233, 793.213196f, 1228.60803f, 797.607971f);
492 path.quadTo(1224.21326f, 802, 1218, 802);
493 path.lineTo(48, 802);
494 path.quadTo(41.7867966f, 802, 37.3919983f, 797.607971f);
495 path.quadTo(33, 793.213196f, 33, 787);
496 path.close();
508 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
512 SkPath path;
513 path.setFillType(SkPath::kEvenOdd_FillType);
514 path.moveTo(808, 886);
515 path.cubicTo(805.581055f, 886, 803.563293f, 887.717773f, 803.100037f, 890);
516 path.lineTo(1122.90002f, 890);
517 path.cubicTo(1122.43677f, 887.717773f, 1120.41895f, 886, 1118, 886);
518 path.lineTo(808, 886);
519 path.close();
532 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
536 SkPath path;
537 path.setFillType(SkPath::kEvenOdd_FillType);
538 path.moveTo(184, 734);
539 path.quadTo(133.051727f, 734, 97.0258636f, 770.025879f);
540 path.quadTo(61, 806.051758f, 61, 857);
541 path.quadTo(61, 895.835083f, 81.9317017f, 926);
542 path.lineTo(286.068298f, 926);
543 path.quadTo(307, 895.835083f, 307, 857);
544 path.quadTo(307, 806.051758f, 270.974121f, 770.025879f);
545 path.quadTo(234.948273f, 734, 184, 734);
546 path.close();
557 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
561 SkPath path;
562 path.setFillType(SkPath::kEvenOdd_FillType);
563 path.moveTo(363, 493);
564 path.cubicTo(360.790863f, 493, 359, 494.790863f, 359, 497);
565 path.lineTo(359, 656);
566 path.cubicTo(359, 658.209106f, 360.790863f, 660, 363, 660);
567 path.lineTo(623.001709f, 660);
568 path.cubicTo(624.657776f, 659.999023f, 626, 658.65625f, 626, 657);
569 path.lineTo(626, 496);
570 path.cubicTo(626, 494.343872f, 624.657959f, 493.00116f, 623.002075f, 493);
571 path.lineTo(363, 493);
572 path.close();
585 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
589 SkPath path;
590 path.setFillType(SkPath::kEvenOdd_FillType);
591 path.moveTo(656, 728);
592 path.cubicTo(653.790833f, 728, 652, 729.790833f, 652, 732);
593 path.lineTo(652, 789);
594 path.cubicTo(652, 791.209106f, 653.790833f, 793, 656, 793);
595 path.lineTo(769.001282f, 793);
596 path.cubicTo(770.657532f, 792.999268f, 772, 791.656433f, 772, 790);
597 path.lineTo(772, 731);
598 path.cubicTo(772, 729.34314f, 770.65686f, 728, 769, 728);
599 path.lineTo(656, 728);
600 path.close();
613 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
617 SkPath path;
618 path.setFillType(SkPath::kEvenOdd_FillType);
619 path.moveTo(0, 495);
620 path.lineTo(1.23685242e-14f, 293);
621 path.lineTo(44, 293);
622 path.quadTo(45.6568527f, 293, 46.8288002f, 294.171204f);
623 path.quadTo(48, 295.34314f, 48, 297);
624 path.lineTo(48, 491);
625 path.quadTo(48, 492.65686f, 46.8288002f, 493.828796f);
626 path.quadTo(45.6568527f, 495, 44, 495);
627 path.lineTo(0, 495);
628 path.close();
629 path.moveTo(1, 294);
630 path.lineTo(44, 294);
631 path.cubicTo(45.6568565f, 294, 47, 295.34314f, 47, 297);
632 path.lineTo(47, 491);
633 path.cubicTo(47, 492.65686f, 45.6568565f, 494, 44, 494);
634 path.lineTo(1, 494);
635 path.lineTo(1, 294);
636 path.close();
643 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
647 SkPath path;
648 path.setFillType(SkPath::kEvenOdd_FillType);
649 path.moveTo(863.439026f, 692);
650 path.lineTo(863.283264f, 692);
651 path.lineTo(802, 708.420837f);
652 path.lineTo(802, 718.773621f);
653 path.lineTo(866, 701.624817f);
654 path.lineTo(866, 701.557922f);
655 path.lineTo(863.439026f, 692);
656 path.close();
664 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
668 SkPath path;
669 path.setFillType(SkPath::kEvenOdd_FillType);
670 path.moveTo(6.66133815e-16f, 648);
671 path.lineTo(25.8522835f, 648);
672 path.quadTo(27.5087376f, 647.999634f, 28.6807098f, 646.82843f);
673 path.quadTo(29.8518829f, 645.656433f, 29.8522835f, 644);
674 path.lineTo(29.8522835f, 467);
675 path.quadTo(29.8518829f, 465.343536f, 28.6807098f, 464.17157f);
676 path.quadTo(27.5087376f, 463.000397f, 25.8522835f, 463);
677 path.lineTo(2.22044605e-16f, 463);
678 path.lineTo(6.66133815e-16f, 648);
679 path.close();
687 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
691 SkPath path;
692 path.setFillType(SkPath::kEvenOdd_FillType);
693 path.moveTo(0, 926);
694 path.lineTo(0, 0);
695 path.lineTo(1265, 0);
696 path.lineTo(1265, 926);
697 path.lineTo(0, 926);
698 path.close();
709 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
713 SkPath path;
714 path.setFillType(SkPath::kEvenOdd_FillType);
715 path.moveTo(16, 56);
716 path.lineTo(32, 56);
717 path.lineTo(32, 72);
718 path.lineTo(16, 72);
719 path.lineTo(16, 56);
720 path.close();
743 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
747 SkPath path;
748 path.setFillType(SkPath::kEvenOdd_FillType);
749 path.moveTo(0, 926);
750 path.lineTo(0, 0);
751 path.lineTo(1265, 0);
752 path.lineTo(1265, 926);
753 path.lineTo(0, 926);
754 path.close();
762 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
766 SkPath path;
767 path.setFillType(SkPath::kEvenOdd_FillType);
768 path.moveTo(179, 407);
769 path.cubicTo(177.34314f, 407, 176, 408.34314f, 176, 410);
770 path.lineTo(176, 436);
771 path.cubicTo(176, 437.65686f, 177.34314f, 439, 179, 439);
772 path.lineTo(337.002289f, 439);
773 path.cubicTo(338.105835f, 438.998779f, 339, 438.103821f, 339, 437);
774 path.lineTo(339, 409);
775 path.cubicTo(339, 407.896362f, 338.10611f, 407.001526f, 337.002838f, 407);
776 path.lineTo(179, 407);
777 path.close();
790 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
794 SkPath path;
795 path.setFillType(SkPath::kEvenOdd_FillType);
796 path.moveTo(807, 817);
797 path.quadTo(806.585876f, 817.000122f, 806.292908f, 817.292908f);
798 path.quadTo(806.000122f, 817.585876f, 806, 818);
799 path.lineTo(806, 881);
800 path.lineTo(1111, 881);
801 path.lineTo(1111, 818);
802 path.quadTo(1110.99988f, 817.585876f, 1110.70715f, 817.292908f);
803 path.quadTo(1110.41406f, 817.000122f, 1110, 817);
804 path.lineTo(807, 817);
805 path.close();
816 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
820 SkPath path;
821 path.setFillType(SkPath::kEvenOdd_FillType);
822 path.moveTo(967, 263);
823 path.quadTo(966.585876f, 263.000092f, 966.292908f, 263.292908f);
824 path.quadTo(966.000122f, 263.585876f, 966, 264);
825 path.lineTo(966, 301);
826 path.lineTo(1214, 301);
827 path.lineTo(1214, 264);
828 path.quadTo(1213.99988f, 263.585876f, 1213.70715f, 263.292908f);
829 path.quadTo(1213.41406f, 263.000092f, 1213, 263);
830 path.lineTo(967, 263);
831 path.close();
842 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
846 path;
847 path.setFillType(SkPath::kEvenOdd_FillType);
848 path.moveTo(271.032867f, -5.32907052e-15f);
849 path.lineTo(56.9671326f, -5.16253706e-15f);
850 path.quadTo(52.7835083f, 3.69968891f, 48.7416f, 7.74160004f);
851 path.quadTo(1, 55.4831848f, 1, 123);
852 path.quadTo(1, 190.516815f, 48.7416f, 238.258392f);
853 path.quadTo(96.4831848f, 286, 164, 286);
854 path.quadTo(231.516815f, 286, 279.258392f, 238.258392f);
855 path.quadTo(327, 190.516815f, 327, 123);
856 path.quadTo(327, 55.4831848f, 279.258392f, 7.74160004f);
857 path.quadTo(275.216431f, 3.69964004f, 271.032867f, -5.32907052e-15f);
858 path.close();
871 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
875 SkPath path;
876 path.setFillType(SkPath::kEvenOdd_FillType);
877 path.moveTo(475.421448f, 836.985962f);
878 path.lineTo(461.280975f, 841.990662f);
879 path.cubicTo(466.80899f, 857.609802f, 458.62854f, 874.752991f, 443.009399f, 880.281006f);
880 path.cubicTo(435.199829f, 883.044983f, 427.009247f, 882.381897f, 420.080048f, 879.075378f);
881 path.lineTo(413.620056f, 892.613037f);
882 path.quadTo(430.419983f, 900.629761f, 447.96701f, 894.43811f);
883 path.quadTo(448.00708f, 894.42395f, 448.014038f, 894.421509f);
884 path.quadTo(448.043976f, 894.410889f, 448.061066f, 894.404846f);
885 path.quadTo(465.596313f, 888.179932f, 473.613037f, 871.379944f);
886 path.quadTo(477.351227f, 863.546143f, 478, 855.549866f);
887 path.lineTo(478, 848.804321f);
888 path.quadTo(477.528076f, 842.93811f, 475.421448f, 836.985962f);
889 path.close();
896 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
900 SkPath path;
901 path.setFillType(SkPath::kEvenOdd_FillType);
902 path.moveTo(458.703552f, 275.050262f);
903 path.quadTo(487.41687f, 273.000702f, 528, 273);
904 path.lineTo(529, 273);
905 path.quadTo(530.242371f, 273.000305f, 531.121338f, 273.878693f);
906 path.quadTo(531.999695f, 274.75766f, 532, 276);
907 path.lineTo(532, 378);
908 path.quadTo(531.990173f, 380.898804f, 503.296448f, 382.949738f);
909 path.quadTo(474.58313f, 384.999298f, 434, 385);
910 path.lineTo(433, 385);
911 path.quadTo(431.75766f, 384.999695f, 430.878693f, 384.121307f);
912 path.quadTo(430.000305f, 383.24234f, 430, 382);
913 path.lineTo(430, 280);
914 path.quadTo(430.009796f, 277.101196f, 458.703552f, 275.050262f);
915 path.close();
928 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
932 SkPath path;
933 path.setFillType(SkPath::kEvenOdd_FillType);
934 path.moveTo(465.503998f, 546);
935 path.lineTo(347, 546);
936 path.lineTo(347, 632);
937 path.lineTo(469.104248f, 632);
938 path.quadTo(470.79007f, 627.638672f, 471.833496f, 621.036255f);
939 path.quadTo(474.902588f, 601.562866f, 470.591064f, 574.024353f);
940 path.lineTo(468.507751f, 560.724426f);
941 path.quadTo(467.275146f, 552.856262f, 465.84668f, 547.288391f);
942 path.quadTo(465.670349f, 546.601501f, 465.503998f, 546);
943 path.close();
956 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
960 SkPath path;
961 path.setFillType(SkPath::kEvenOdd_FillType);
962 path.moveTo(936.765625f, 458.965302f);
963 path.cubicTo(937.028442f, 453.863251f, 933.145813f, 449.864502f, 928.093445f, 450.033905f);
964 path.lineTo(661.882263f, 458.958862f);
965 path.lineTo(661.875366f, 458.959106f);
966 path.cubicTo(656.828369f, 459.13205f, 652.525085f, 463.399719f, 652.258545f, 468.496124f);
967 path.lineTo(652.258179f, 468.503662f);
968 path.lineTo(649.021729f, 531.322754f);
969 path.cubicTo(648.75885f, 536.424805f, 652.641479f, 540.423523f, 657.693848f, 540.25415f);
970 path.lineTo(923.905029f, 531.329163f);
971 path.cubicTo(928.955017f, 531.159851f, 933.262268f, 526.890442f, 933.528809f, 521.791565f);
972 path.lineTo(933.529175f, 521.784363f);
973 path.lineTo(936.765625f, 458.965302f);
974 path.close();
987 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
991 SkPath path;
992 path.setFillType(SkPath::kEvenOdd_FillType);
993 path.moveTo(156, 126);
994 path.quadTo(154.343552f, 126.000397f, 153.17157f, 127.17157f);
995 path.quadTo(152.000397f, 128.343552f, 152, 130);
996 path.lineTo(152, 174);
997 path.lineTo(1114, 174);
998 path.lineTo(1114, 130);
999 path.quadTo(1113.99963f, 128.343552f, 1112.82837f, 127.17157f);
1000 path.quadTo(1111.65649f, 126.000397f, 1110, 126);
1001 path.lineTo(156, 126);
1002 path.close();
1013 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1017 SkPath path;
1018 path.setFillType(SkPath::kEvenOdd_FillType);
1019 path.moveTo(182.000015f, 645);
1020 path.lineTo(182, 640);
1021 path.cubicTo(174.322327f, 640, 166.644669f, 637.071045f, 160.786804f, 631.213196f);
1022 path.cubicTo(149.071075f, 619.497437f, 149.071075f, 600.502563f, 160.786804f, 588.786804f);
1023 path.lineTo(157.251266f, 585.251221f);
1024 path.quadTo(147, 595.502502f, 147.000015f, 610);
1025 path.quadTo(147, 624.482605f, 157.230255f, 634.727722f);
1026 path.quadTo(157.251251f, 634.748779f, 157.251282f, 634.748779f);
1027 path.quadTo(157.282852f, 634.780334f, 157.272263f, 634.769775f);
1028 path.quadTo(167.517334f, 645, 182.000015f, 645);
1029 path.close();
1036 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1040 SkPath path;
1041 path.setFillType(SkPath::kEvenOdd_FillType);
1042 path.moveTo(154, 670);
1043 path.cubicTo(151.238571f, 670, 149, 672.238586f, 149, 675);
1044 path.lineTo(149, 710.001465f);
1045 path.cubicTo(149.000809f, 712.209961f, 150.791367f, 714, 153, 714);
1046 path.lineTo(189, 714);
1047 path.cubicTo(191.209137f, 714, 193, 712.209167f, 193, 710);
1048 path.lineTo(193, 675);
1049 path.cubicTo(193, 672.238586f, 190.761429f, 670, 188, 670);
1050 path.lineTo(154, 670);
1051 path.close();
1064 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1068 SkPath path;
1069 path.setFillType(SkPath::kEvenOdd_FillType);
1070 path.moveTo(50, 182);
1071 path.lineTo(1215, 182);
1072 path.lineTo(1215, 202);
1073 path.quadTo(1214.99951f, 204.070572f, 1213.53552f, 205.535538f);
1074 path.quadTo(1212.07056f, 206.999496f, 1210, 207);
1075 path.lineTo(55, 207);
1076 path.quadTo(52.9294319f, 206.999496f, 51.4644661f, 205.535538f);
1077 path.quadTo(50.0004997f, 204.070572f, 50, 202);
1078 path.lineTo(50, 182);
1079 path.close();
1090 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1094 SkPath path;
1095 path.setFillType(SkPath::kEvenOdd_FillType);
1096 path.moveTo(172, 201);
1097 path.lineTo(172, 202);
1098 path.lineTo(220, 202);
1099 path.cubicTo(221.65686f, 202, 223, 200.65686f, 223, 199);
1100 path.cubicTo(223, 200.104568f, 221.65686f, 201, 220, 201);
1101 path.lineTo(172, 201);
1102 path.close();
1109 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1113 SkPath path;
1114 path.setFillType(SkPath::kEvenOdd_FillType);
1115 path.moveTo(806, 57);
1116 path.cubicTo(806, 55.3431473f, 807.34314f, 54, 809, 54);
1117 path.lineTo(930, 54);
1118 path.cubicTo(931.65686f, 54, 933, 55.3431473f, 933, 57);
1119 path.lineTo(933, 91);
1120 path.cubicTo(933, 92.6568527f, 931.65686f, 94, 930, 94);
1121 path.lineTo(809, 94);
1122 path.cubicTo(807.34314f, 94, 806, 92.6568527f, 806, 91);
1123 path.lineTo(806, 57);
1124 path.close();
1125 path.moveTo(808, 58);
1126 path.cubicTo(808, 56.8954315f, 808.895447f, 56, 810, 56);
1127 path.lineTo(929, 56);
1128 path.cubicTo(930.104553f, 56, 931, 56.8954315f, 931, 58);
1129 path.lineTo(931, 90);
1130 path.cubicTo(931, 91.1045685f, 930.104553f, 92, 929, 92);
1131 path.lineTo(810, 92);
1132 path.cubicTo(808.895447f, 92, 808, 91.1045685f, 808, 90);
1133 path.lineTo(808, 58);
1134 path.close();
1141 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1145 SkPath path;
1146 path.setFillType(SkPath::kEvenOdd_FillType);
1147 path.moveTo(173, 5342);
1148 path.quadTo(171.343536f, 5342.00049f, 170.17157f, 5343.17139f);
1149 path.quadTo(169.000397f, 5344.34375f, 169, 5346);
1150 path.lineTo(169, 5372);
1151 path.lineTo(234, 5372);
1152 path.lineTo(234, 5346);
1153 path.quadTo(233.999603f, 5344.34375f, 232.82843f, 5343.17139f);
1154 path.quadTo(231.656464f, 5342.00049f, 230, 5342);
1155 path.lineTo(173, 5342);
1156 path.close();
1167 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1171 SkPath path;
1172 path.setFillType(SkPath::kEvenOdd_FillType);
1173 path.moveTo(90, 187);
1174 path.cubicTo(90, 185.34314f, 91.3431473f, 184, 93, 184);
1175 path.lineTo(588, 184);
1176 path.cubicTo(589.65686f, 184, 591, 185.34314f, 591, 187);
1177 path.lineTo(591, 218);
1178 path.cubicTo(591, 219.65686f, 589.65686f, 221, 588, 221);
1179 path.lineTo(93, 221);
1180 path.cubicTo(91.3431473f, 221, 90, 219.65686f, 90, 218);
1181 path.lineTo(90, 187);
1182 path.close();
1183 path.moveTo(92, 188);
1184 path.cubicTo(92, 186.895432f, 92.8954315f, 186, 94, 186);
1185 path.lineTo(587, 186);
1186 path.cubicTo(588.104553f, 186, 589, 186.895432f, 589, 188);
1187 path.lineTo(589, 217);
1188 path.cubicTo(589, 218.104568f, 588.104553f, 219, 587, 219);
1189 path.lineTo(94, 219);
1190 path.cubicTo(92.8954315f, 219, 92, 218.104568f, 92, 217);
1191 path.lineTo(92, 188);
1192 path.close();
1199 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1203 SkPath path;
1204 path.setFillType(SkPath::kEvenOdd_FillType);
1205 path.moveTo(635, 1788);
1206 path.cubicTo(635, 1786.34314f, 636.34314f, 1785, 638, 1785);
1207 path.lineTo(832, 1785);
1208 path.cubicTo(833.65686f, 1785, 835, 1786.34314f, 835, 1788);
1209 path.lineTo(835, 1812);
1210 path.cubicTo(835, 1813.65686f, 833.65686f, 1815, 832, 1815);
1211 path.lineTo(638, 1815);
1212 path.cubicTo(636.34314f, 1815, 635, 1813.65686f, 635, 1812);
1213 path.lineTo(635, 1788);
1214 path.close();
1215 path.moveTo(637, 1789);
1216 path.cubicTo(637, 1787.89539f, 637.895447f, 1787, 639, 1787);
1217 path.lineTo(831, 1787);
1218 path.cubicTo(832.104553f, 1787, 833, 1787.89539f, 833, 1789);
1219 path.lineTo(833, 1811);
1220 path.cubicTo(833, 1812.10461f, 832.104553f, 1813, 831, 1813);
1221 path.lineTo(639, 1813);
1222 path.cubicTo(637.895447f, 1813, 637, 1812.10461f, 637, 1811);
1223 path.lineTo(637, 1789);
1224 path.close();
1231 testPathOp(reporter, path
1235 SkPath path;
1236 path.setFillType(SkPath::kEvenOdd_FillType);
1237 path.moveTo(320, 347);
1238 path.cubicTo(320, 344.238586f, 322.238586f, 342, 325, 342);
1239 path.lineTo(416, 342);
1240 path.cubicTo(418.761414f, 342, 421, 344.238586f, 421, 347);
1241 path.cubicTo(421, 344.790863f, 418.761414f, 343, 416, 343);
1242 path.lineTo(325, 343);
1243 path.cubicTo(322.238586f, 343, 320, 344.790863f, 320, 347);
1244 path.close();
1245 path.moveTo(320, 378);
1246 path.cubicTo(320, 380.761414f, 322.238586f, 383, 325, 383);
1247 path.lineTo(416, 383);
1248 path.cubicTo(418.761414f, 383, 421, 380.761414f, 421, 378);
1249 path.cubicTo(421, 380.209137f, 418.761414f, 382, 416, 382);
1250 path.lineTo(325, 382);
1251 path.cubicTo(322.238586f, 382, 320, 380.209137f, 320, 378);
1252 path.close();
1259 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1263 SkPath path;
1264 path.setFillType(SkPath::kEvenOdd_FillType);
1265 path.moveTo(136, 14089);
1266 path.lineTo(136, 14056);
1267 path.lineTo(778, 14056);
1268 path.lineTo(778, 14089);
1269 path.quadTo(777.999573f, 14090.6562f, 776.82843f, 14091.8281f);
1270 path.quadTo(775.656433f, 14093, 774, 14093);
1271 path.lineTo(140, 14093);
1272 path.quadTo(138.343552f, 14093, 137.17157f, 14091.8281f);
1273 path.quadTo(136.000397f, 14090.6562f, 136, 14089);
1274 path.close();
1285 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1289 SkPath path;
1290 path.setFillType(SkPath::kEvenOdd_FillType);
1291 path.moveTo(377.1716f, 5910.17139f);
1292 path.cubicTo(376.447723f, 5910.89551f, 376, 5911.89551f, 376, 5913);
1293 path.lineTo(376, 5972);
1294 path.cubicTo(376, 5974.20898f, 377.790863f, 5976, 380, 5976);
1295 path.cubicTo(378.34314f, 5976, 377, 5974.20898f, 377, 5972);
1296 path.lineTo(377, 5913);
1297 path.cubicTo(377, 5912.17139f, 377.335785f, 5911.42188f, 377.878693f, 5910.87891f);
1298 path.lineTo(377.1716f, 5910.17139f);
1299 path.close();
1306 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1310 SkPath path;
1311 path.setFillType(SkPath::kEvenOdd_FillType);
1312 path.moveTo(843, 216);
1313 path.cubicTo(843, 213.238571f, 845.238586f, 211, 848, 211);
1314 path.lineTo(1191, 211);
1315 path.cubicTo(1193.76147f, 211, 1196, 213.238571f, 1196, 216);
1316 path.lineTo(1196, 779);
1317 path.cubicTo(1196, 781.761414f, 1193.76147f, 784, 1191, 784);
1318 path.lineTo(848, 784);
1319 path.cubicTo(845.238586f, 784, 843, 781.761414f, 843, 779);
1320 path.lineTo(843, 216);
1321 path.close();
1322 path.moveTo(844, 217);
1323 path.cubicTo(844, 214.238571f, 846.238586f, 212, 849, 212);
1324 path.lineTo(1190, 212);
1325 path.cubicTo(1192.76147f, 212, 1195, 214.238571f, 1195, 217);
1326 path.lineTo(1195, 778);
1327 path.cubicTo(1195, 779.65686f, 1192.76147f, 781, 1190, 781);
1328 path.lineTo(849, 781);
1329 path.cubicTo(846.238586f, 781, 844, 779.65686f, 844, 778);
1330 path.lineTo(844, 217);
1331 path.close();
1338 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1342 SkPath path;
1343 path.setFillType(SkPath::kEvenOdd_FillType);
1344 path.moveTo(162, 468);
1345 path.cubicTo(159.790863f, 468, 158, 469.790863f, 158, 472);
1346 path.lineTo(158, 528);
1347 path.cubicTo(158, 530.209106f, 159.790863f, 532, 162, 532);
1348 path.lineTo(275, 532);
1349 path.cubicTo(277.209137f, 532, 279, 530.209106f, 279, 528);
1350 path.lineTo(279, 472);
1351 path.cubicTo(279, 469.790863f, 277.209137f, 468, 275, 468);
1352 path.lineTo(162, 468);
1353 path.close();
1366 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1370 SkPath path;
1371 path.setFillType(SkPath::kEvenOdd_FillType);
1372 path.moveTo(162, 468);
1373 path.cubicTo(159.790863f, 468, 158, 469.790863f, 158, 472);
1374 path.lineTo(158, 528);
1375 path.cubicTo(158, 530.209106f, 159.790863f, 532, 162, 532);
1376 path.lineTo(275.009186f, 532);
1377 path.cubicTo(276.661774f, 531.994995f, 278, 530.653748f, 278, 529);
1378 path.lineTo(278, 471);
1379 path.cubicTo(278, 469.346375f, 276.662079f, 468.005249f, 275.009705f, 468);
1380 path.lineTo(162, 468);
1381 path.close();
1394 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1398 SkPath path;
1399 path.setFillType(SkPath::kEvenOdd_FillType);
1400 path.moveTo(137.34314f, 145.34314f);
1401 path.quadTo(139.687088f, 143.000793f, 143, 143);
1402 path.lineTo(242, 143);
1403 path.quadTo(245.312912f, 143.000793f, 247.65686f, 145.34314f);
1404 path.quadTo(249.999207f, 147.687088f, 250, 151);
1405 path.lineTo(250, 177);
1406 path.lineTo(135, 177);
1407 path.lineTo(135, 151);
1408 path.quadTo(135.000793f, 147.687088f, 137.34314f, 145.34314f);
1409 path.close();
1417 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1421 SkPath path;
1422 path.setFillType(SkPath::kEvenOdd_FillType);
1423 path.moveTo(143, 143);
1424 path.quadTo(139.687088f, 143.000793f, 137.34314f, 145.34314f);
1425 path.quadTo(135.000793f, 147.687088f, 135, 151);
1426 path.lineTo(135, 177);
1427 path.lineTo(250, 177);
1428 path.lineTo(250, 151);
1429 path.quadTo(249.999207f, 147.687088f, 247.65686f, 145.34314f);
1430 path.quadTo(245.312912f, 143.000793f, 242, 143);
1431 path.lineTo(143, 143);
1432 path.close();
1443 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1447 SkPath path;
1448 path.setFillType(SkPath::kEvenOdd_FillType);
1449 path.moveTo(1001.87866f, 14.8786793f);
1450 path.quadTo(1002.75745f, 14.0001001f, 1004, 14);
1451 path.lineTo(1105, 14);
1452 path.quadTo(1106.24255f, 14.0001001f, 1107.12134f, 14.8786793f);
1453 path.quadTo(1107.99988f, 15.7574596f, 1108, 17);
1454 path.lineTo(1108, 41);
1455 path.quadTo(1107.99988f, 42.2425423f, 1107.12134f, 43.1213188f);
1456 path.quadTo(1106.24255f, 43.9999008f, 1105, 44);
1457 path.lineTo(1004, 44);
1458 path.quadTo(1002.75745f, 43.9999008f, 1001.87866f, 43.1213188f);
1459 path.quadTo(1001.00012f, 42.2425423f, 1001, 41);
1460 path.lineTo(1001, 17);
1461 path.quadTo(1001.00012f, 15.7574596f, 1001.87866f, 14.8786793f);
1462 path.close();
1475 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1479 SkPath path;
1480 path.setFillType(SkPath::kEvenOdd_FillType);
1481 path.moveTo(1001.87866f, 14.8786793f);
1482 path.quadTo(1002.75745f, 14.0001001f, 1004, 14);
1483 path.lineTo(1105, 14);
1484 path.quadTo(1106.24255f, 14.0001001f, 1107.12134f, 14.8786793f);
1485 path.quadTo(1107.99988f, 15.7574596f, 1108, 17);
1486 path.lineTo(1108, 41);
1487 path.quadTo(1107.99988f, 42.2425423f, 1107.12134f, 43.1213188f);
1488 path.quadTo(1106.24255f, 43.9999008f, 1105, 44);
1489 path.lineTo(1004, 44);
1490 path.quadTo(1002.75745f, 43.9999008f, 1001.87866f, 43.1213188f);
1491 path.quadTo(1001.00012f, 42.2425423f, 1001, 41);
1492 path.lineTo(1001, 17);
1493 path.quadTo(1001.00012f, 15.7574596f, 1001.87866f, 14.8786793f);
1494 path.close();
1495 path.moveTo(1003, 18);
1496 path.cubicTo(1003, 16.8954296f, 1003.89545f, 16, 1005, 16);
1497 path.lineTo(1104, 16);
1498 path.cubicTo(1105.10461f, 16, 1106, 16.8954296f, 1106, 18);
1499 path.lineTo(1106, 40);
1500 path.cubicTo(1106, 41.1045685f, 1105.10461f, 42, 1104, 42);
1501 path.lineTo(1005, 42);
1502 path.cubicTo(1003.89545f, 42, 1003, 41.1045685f, 1003, 40);
1503 path.lineTo(1003, 18);
1504 path.close();
1511 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1515 SkPath path;
1516 path.setFillType(SkPath::kEvenOdd_FillType);
1517 path.moveTo(0, 994);
1518 path.lineTo(0, 0);
1519 path.lineTo(512, 0);
1520 path.lineTo(512, 994);
1521 path.lineTo(0, 994);
1522 path.close();
1534 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1538 SkPath path;
1539 path.setFillType(SkPath::kEvenOdd_FillType);
1540 path.moveTo(0, 193);
1541 path.lineTo(323, 193);
1542 path.lineTo(323, 168);
1543 path.quadTo(323, 166.757385f, 322.121338f, 165.878662f);
1544 path.quadTo(321.242615f, 165, 320, 165);
1545 path.lineTo(0, 165);
1546 path.lineTo(0, 193);
1547 path.close();
1558 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1562 SkPath path;
1563 path.setFillType(SkPath::kEvenOdd_FillType);
1564 path.moveTo(183, 8507);
1565 path.lineTo(552, 8506.99023f);
1566 path.lineTo(552, 8508);
1567 path.lineTo(183, 8508);
1568 path.lineTo(183, 8507);
1569 path.close();
1576 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1580 SkPath path;
1581 path.setFillType(SkPath::kEvenOdd_FillType);
1582 path.moveTo(140, 1000);
1583 path.lineTo(140, 842);
1584 path.lineTo(141, 842);
1585 path.lineTo(141.14502f, 1000);
1586 path.lineTo(140, 1000);
1587 path.close();
1594 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1598 SkPath path;
1599 path.setFillType(SkPath::kEvenOdd_FillType);
1600 path.moveTo(134.34314f, 9802.34277f);
1601 path.quadTo(132, 9804.68652f, 132, 9808);
1602 path.lineTo(132, 9822);
1603 path.quadTo(132, 9825.31348f, 134.34314f, 9827.65723f);
1604 path.quadTo(136.686295f, 9830, 140, 9830);
1605 path.lineTo(140.028473f, 9830);
1606 path.lineTo(139.877213f, 9828.90723f);
1607 path.quadTo(137.692032f, 9828.5332f, 136.050247f, 9826.65723f);
1608 path.quadTo(134, 9824.31348f, 134, 9821);
1609 path.lineTo(134, 9809);
1610 path.quadTo(134, 9806.10059f, 136.050247f, 9804.0498f);
1611 path.lineTo(134.34314f, 9802.34277f);
1612 path.close();
1619 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1623 SkPath path;
1624 path.setFillType(SkPath::kEvenOdd_FillType);
1625 path.moveTo(817.464478f, 11.4644661f);
1626 path.quadTo(818.928955f, 10, 821, 10);
1627 path.lineTo(998, 10);
1628 path.quadTo(999.082947f, 10, 1000, 10.4003992f);
1629 path.lineTo(1000, 13.3527431f);
1630 path.quadTo(999.917603f, 13.2607508f, 999.82843f, 13.1715727f);
1631 path.quadTo(998.65686f, 12, 997, 12);
1632 path.lineTo(822, 12);
1633 path.quadTo(820.34314f, 12, 819.17157f, 13.1715727f);
1634 path.quadTo(818, 14.3431454f, 818, 16);
1635 path.lineTo(818, 28);
1636 path.quadTo(818, 29.6568546f, 819.17157f, 30.8284264f);
1637 path.quadTo(820.34314f, 32, 822, 32);
1638 path.lineTo(997, 32);
1639 path.quadTo(998.65686f, 32, 999.82843f, 30.8284264f);
1640 path.quadTo(999.917603f, 30.7392426f, 1000, 30.6472569f);
1641 path.lineTo(1000, 33.5996017f);
1642 path.quadTo(999.082947f, 34, 998, 34);
1643 path.lineTo(821, 34);
1644 path.quadTo(818.928955f, 34, 817.464478f, 32.5355339f);
1645 path.quadTo(816, 31.0710678f, 816, 29);
1646 path.lineTo(816, 15);
1647 path.quadTo(816, 12.9289322f, 817.464478f, 11.4644661f);
1648 path.close();
1655 path, pathB, kIntersect_SkPathOp, filename);
1659 SkPath path;
1660 path.setFillType(SkPath::kEvenOdd_FillType);
1661 path.moveTo(966.464478f, 4261.46436f);
1662 path.quadTo(965, 4262.92871f, 965, 4265);
1663 path.lineTo(965, 4276);
1664 path.quadTo(965, 4278.07129f, 966.464478f, 4279.53564f);
1665 path.quadTo(967.928955f, 4281, 970, 4281);
1666 path.lineTo(970.020325f, 4281);
1667 path.lineTo(969.887512f, 4279.81641f);
1668 path.quadTo(968.928284f, 4279.48145f, 968.17157f, 4278.53564f);
1669 path.quadTo(967, 4277.07129f, 967, 4275);
1670 path.lineTo(967, 4266);
1671 path.quadTo(967, 4264.44287f, 968.035217f, 4263.31396f);
1672 path.lineTo(968, 4263);
1673 path.lineTo(966.464478f, 4261.46436f);
1674 path.close();
1681 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1685 SkPath path;
1686 path.setFillType(SkPath::kEvenOdd_FillType);
1687 path.moveTo(991.633911f, 1839);
1688 path.lineTo(964.265015f, 1839);
1689 path.lineTo(963.734985f, 1893.73242f);
1690 path.lineTo(991.3703f, 1894);
1691 path.lineTo(1018.23492f, 1894);
1692 path.lineTo(1018.76501f, 1839.2627f);
1693 path.lineTo(991.638184f, 1839);
1694 path.lineTo(991.633911f, 1839);
1695 path.close();
1703 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1707 SkPath path;
1708 path.setFillType(SkPath::kEvenOdd_FillType);
1709 path.moveTo(1129.53552f, 1164.46448f);
1710 path.lineTo(1128, 1166);
1711 path.lineTo(1128.12231f, 1166.49548f);
1712 path.quadTo(1129, 1167.56592f, 1129, 1169);
1713 path.lineTo(1129, 1170.05054f);
1714 path.lineTo(1130.34509f, 1175.49878f);
1715 path.quadTo(1131, 1174.38513f, 1131, 1173);
1716 path.lineTo(1131, 1168);
1717 path.quadTo(1131, 1165.92896f, 1129.53552f, 1164.46448f);
1718 path.close();
1725 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1729 SkPath path;
1730 path.setFillType(SkPath::kEvenOdd_FillType);
1731 path.moveTo(143.292892f, 0.707106769f);
1732 path.quadTo(143, 0.414213538f, 143, 0);
1733 path.lineTo(1123, 0);
1734 path.quadTo(1123, 0.414213538f, 1122.70715f, 0.707106769f);
1735 path.quadTo(1122.41418f, 1, 1122, 1);
1736 path.lineTo(144, 1);
1737 path.quadTo(143.585785f, 1, 143.292892f, 0.707106769f);
1738 path.close();
1745 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1749 SkPath path;
1750 path.setFillType(SkPath::kEvenOdd_FillType);
1751 path.moveTo(741, 9432);
1752 path.lineTo(761, 9431.99023f);
1753 path.lineTo(761, 9433);
1754 path.lineTo(741, 9433);
1755 path.lineTo(741, 9432);
1756 path.close();
1763 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1767 SkPath path;
1768 path.setFillType(SkPath::kEvenOdd_FillType);
1769 path.moveTo(1000, 343);
1770 path.lineTo(165, 343);
1771 path.lineTo(165, 364.869873f);
1772 path.lineTo(1000, 364.869873f);
1773 path.lineTo(1000, 343);
1774 path.close();
1782 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1786 SkPath path;
1787 path.setFillType(SkPath::kEvenOdd_FillType);
1788 path.moveTo(838, 9125);
1789 path.lineTo(862, 9124.99023f);
1790 path.lineTo(862, 9126);
1791 path.lineTo(838, 9126);
1792 path.lineTo(838, 9125);
1793 path.close();
1800 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1804 SkPath path;
1805 path.setFillType(SkPath::kEvenOdd_FillType);
1806 path.moveTo(143, 9075);
1807 path.lineTo(316, 9075);
1808 path.lineTo(316, 9073.99023f);
1809 path.lineTo(143, 9074);
1810 path.lineTo(143, 9075);
1811 path.close();
1818 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1822 SkPath path;
1823 path.setFillType(SkPath::kEvenOdd_FillType);
1824 path.moveTo(541.5f, 4835.99512f);
1825 path.lineTo(91.5f, 4836);
1826 path.lineTo(91.5f, 4836.5f);
1827 path.lineTo(541.5f, 4836.5f);
1828 path.lineTo(541.5f, 4835.99512f);
1829 path.close();
1836 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1840 SkPath path;
1841 path.setFillType(SkPath::kEvenOdd_FillType);
1842 path.moveTo(284.878693f, 10134.8789f);
1843 path.quadTo(284, 10135.7578f, 284, 10137);
1844 path.lineTo(284, 10216);
1845 path.quadTo(284, 10217.2422f, 284.878693f, 10218.1211f);
1846 path.quadTo(285.125122f, 10218.3672f, 285.40213f, 10218.5459f);
1847 path.lineTo(286, 10138);
1848 path.lineTo(286, 10136);
1849 path.lineTo(284.878693f, 10134.8789f);
1850 path.close();
1857 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1861 SkPath path;
1862 path.setFillType(SkPath::kEvenOdd_FillType);
1863 path.moveTo(3.17157292f, 11831.1719f);
1864 path.quadTo(4.34314585f, 11830, 6, 11830);
1865 path.lineTo(1259, 11830);
1866 path.quadTo(1260.65686f, 11830, 1261.82837f, 11831.1719f);
1867 path.quadTo(1263, 11832.3428f, 1263, 11834);
1868 path.lineTo(1263, 11848);
1869 path.quadTo(1263, 11849.6572f, 1261.82837f, 11850.8281f);
1870 path.quadTo(1260.65686f, 11852, 1259, 11852);
1871 path.lineTo(6, 11852);
1872 path.quadTo(4.34314585f, 11852, 3.17157292f, 11850.8281f);
1873 path.quadTo(2, 11849.6572f, 2, 11848);
1874 path.lineTo(2, 11834);
1875 path.quadTo(2, 11832.3428f, 3.17157292f, 11831.1719f);
1876 path.close();
1877 path.moveTo(3.87867975f, 11831.8789f);
1878 path.quadTo(4.7573595f, 11831, 6, 11831);
1879 path.lineTo(1259, 11831);
1880 path.quadTo(1260.24268f, 11831, 1261.12134f, 11831.8789f);
1881 path.quadTo(1262, 11832.7578f, 1262, 11834);
1882 path.lineTo(1262, 11848);
1883 path.quadTo(1262, 11849.2422f, 1261.12134f, 11850.1211f);
1884 path.quadTo(1260.24268f, 11851, 1259, 11851);
1885 path.lineTo(6, 11851);
1886 path.quadTo(4.7573595f, 11851, 3.87867975f, 11850.1211f);
1887 path.quadTo(3, 11849.2422f, 3, 11848);
1888 path.lineTo(3, 11834);
1889 path.quadTo(3, 11832.7578f, 3.87867975f, 11831.8789f);
1890 path.close();
1897 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1901 SkPath path;
1902 path.setFillType(SkPath::kEvenOdd_FillType);
1903 path.moveTo(1000, 902.329346f);
1904 path.quadTo(998, 905.250427f, 998, 909);
1905 path.lineTo(998, 910);
1906 path.quadTo(998, 913.749573f, 1000, 916.670654f);
1907 path.lineTo(1000, 902.329346f);
1908 path.close();
1925 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1929 SkPath path;
1930 path.setFillType(SkPath::kEvenOdd_FillType);
1931 path.moveTo(610.5f, 5.78626502e-14f);
1932 path.lineTo(1083.5f, -6.12303177e-17f);
1933 path.lineTo(1083.5f, 469);
1934 path.lineTo(610.5f, 469);
1935 path.lineTo(610.5f, 5.78626502e-14f);
1936 path.close();
1944 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1948 SkPath path;
1949 path.setFillType(SkPath::kEvenOdd_FillType);
1950 path.moveTo(85.6091843f, 5.92893219f);
1951 path.quadTo(89.6041641f, 3, 93.7462997f, 3);
1952 path.lineTo(1212.74634f, 3);
1953 path.quadTo(1216.88843f, 3, 1218.75134f, 5.92893219f);
1954 path.quadTo(1220.61414f, 8.85775471f, 1219.10669f, 12.9996767f);
1955 path.quadTo(1220.46338f, 9.27196693f, 1218.4939f, 6.63603878f);
1956 path.quadTo(1216.52441f, 4, 1212.38232f, 4);
1957 path.lineTo(93.3823318f, 4);
1958 path.quadTo(89.2401962f, 4, 85.3518219f, 6.63603878f);
1959 path.quadTo(81.4634476f, 9.27207756f, 80.1065979f, 13);
1960 path.quadTo(81.614212f, 8.85786438f, 85.6091843f, 5.92893219f);
1961 path.close();
1969 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1973 SkPath path;
1974 path.setFillType(SkPath::kEvenOdd_FillType);
1975 path.moveTo(85.6091843f, 5.92893219f);
1976 path.quadTo(89.6041641f, 3, 93.7462997f, 3);
1977 path.lineTo(112.74634f, 3);
1978 path.quadTo(116.88843f, 3, 118.75134f, 5.92893219f);
1979 path.quadTo(120.61414f, 8.85775471f, 119.10669f, 12.9996767f);
1980 path.quadTo(120.46338f, 9.27196693f, 118.4939f, 6.63603878f);
1981 path.quadTo(116.52441f, 4, 112.38232f, 4);
1982 path.lineTo(93.3823318f, 4);
1983 path.quadTo(89.2401962f, 4, 85.3518219f, 6.63603878f);
1984 path.quadTo(81.4634476f, 9.27207756f, 80.1065979f, 13);
1985 path.quadTo(81.614212f, 8.85786438f, 85.6091843f, 5.92893219f);
1986 path.close();
1994 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1998 SkPath path;
1999 path.setFillType(SkPath::kEvenOdd_FillType);
2000 path.moveTo(117.686981f, 3339.08423f);
2001 path.lineTo(109.533035f, 3350.72925f);
2002 path.quadTo(107.120552f, 3354.17456f, 103.879379f, 3354.41821f);
2003 path.quadTo(100.638504f, 3354.66187f, 98.4674301f, 3351.56177f);
2004 path.quadTo(100.87973f, 3355.00635f, 104.291222f, 3355.00635f);
2005 path.quadTo(107.70298f, 3355.00635f, 110.115463f, 3351.56104f);
2006 path.lineTo(118, 3340.30078f);
2007 path.lineTo(118, 3339.53125f);
2008 path.lineTo(117.686981f, 3339.08423f);
2009 path.close();
2016 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2020 SkPath path;
2021 path.setFillType(SkPath::kEvenOdd_FillType);
2022 path.moveTo(509.34021f, 176);
2023 path.lineTo(505, 176);
2024 path.quadTo(500.964233f, 176, 497.299988f, 176.896912f);
2025 path.quadTo(493.678162f, 177.952286f, 490.183014f, 179.9702f);
2026 path.lineTo(489.316986f, 180.4702f);
2027 path.quadTo(485.175385f, 182.861359f, 482.115265f, 186.082397f);
2028 path.quadTo(479.69455f, 188.700821f, 477.995941f, 191.618286f);
2029 path.quadTo(476.316772f, 194.550476f, 475.258759f, 197.959335f);
2030 path.quadTo(474, 202.218979f, 474, 207);
2031 path.lineTo(474, 208);
2032 path.quadTo(474, 212.03569f, 474.896851f, 215.699799f);
2033 path.quadTo(475.950256f, 219.315002f, 477.962708f, 222.803986f);
2034 path.lineTo(477.970215f, 222.816986f);
2035 path.lineTo(478.470215f, 223.683014f);
2036 path.quadTo(478.474915f, 223.691162f, 478.479645f, 223.69931f);
2037 path.quadTo(480.867981f, 227.831055f, 484.082947f, 230.885254f);
2038 path.quadTo(486.701447f, 233.305939f, 489.61908f, 235.004517f);
2039 path.quadTo(492.550232f, 236.682983f, 495.957611f, 237.740738f);
2040 path.quadTo(500.217987f, 239, 505, 239);
2041 path.lineTo(509.482178f, 239);
2042 path.quadTo(515.299133f, 238.212051f, 520.801941f, 235.038513f);
2043 path.quadTo(520.809509f, 235.034164f, 520.817017f, 235.0298f);
2044 path.lineTo(521.683044f, 234.5298f);
2045 path.quadTo(521.692078f, 234.524582f, 521.701111f, 234.519348f);
2046 path.quadTo(532.80603f, 228.09938f, 536.126709f, 215.70639f);
2047 path.quadTo(539.450134f, 203.303314f, 533.029785f, 192.183014f);
2048 path.lineTo(532.529785f, 191.316986f);
2049 path.quadTo(526.109497f, 180.196686f, 513.706421f, 176.873276f);
2050 path.quadTo(511.503082f, 176.282898f, 509.34021f, 176);
2051 path.close();
2068 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2072 SkPath path;
2073 path.setFillType(SkPath::kEvenOdd_FillType);
2074 path.moveTo(497.299988f, 176.896912f);
2075 path.quadTo(493.678162f, 177.952286f, 490.183014f, 179.9702f);
2076 path.lineTo(489.316986f, 180.4702f);
2077 path.quadTo(485.175385f, 182.861359f, 482.115265f, 186.082397f);
2084 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2088 SkPath path;
2089 path.setFillType(SkPath::kEvenOdd_FillType);
2090 path.moveTo(460.257355f, 1202.27808f);
2091 path.lineTo(460.257355f, 1204.27808f);
2092 path.quadTo(461.081207f, 1204.27808f, 461.665161f, 1203.69873f);
2093 path.lineTo(461.67157f, 1203.69238f);
2094 path.lineTo(466.621307f, 1198.74268f);
2095 path.quadTo(466.623993f, 1198.73999f, 466.626648f, 1198.7373f);
2096 path.quadTo(466.914185f, 1198.44604f, 466.914185f, 1198.03552f);
2097 path.quadTo(466.914215f, 1197.62122f, 466.621307f, 1197.32837f);
2098 path.lineTo(465.914215f, 1196.62122f);
2099 path.lineTo(460.257355f, 1202.27808f);
2100 path.close();
2107 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2111 SkPath path;
2112 path.setFillType(SkPath::kEvenOdd_FillType);
2113 path.moveTo(899.17157f, 548.17157f);
2114 path.quadTo(898, 549.34314f, 898, 551);
2115 path.lineTo(898, 556);
2116 path.lineTo(899.027283f, 556);
2117 path.lineTo(900.02356f, 551.602844f);
2118 path.quadTo(900.06073f, 551.297058f, 900.156555f, 551.015747f);
2119 path.lineTo(900.5f, 549.5f);
2120 path.lineTo(899.17157f, 548.17157f);
2121 path.close();
2128 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2132 SkPath path;
2133 path.setFillType(SkPath::kEvenOdd_FillType);
2134 path.moveTo(0, 1431);
2135 path.lineTo(0, 775);
2136 path.lineTo(1265, 775);
2137 path.lineTo(1265, 1431);
2138 path.lineTo(0, 1431);
2139 path.close();
2147 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2151 SkPath path;
2152 path.setFillType(SkPath::kEvenOdd_FillType);
2153 path.moveTo(1020.79303f, 2252);
2154 path.quadTo(1018.72198f, 2252, 1016.86798f, 2253.46436f);
2155 path.quadTo(1015.02032f, 2254.92383f, 1014.4668f, 2256.98584f);
2156 path.lineTo(1014.46301f, 2257);
2157 path.lineTo(1011.53705f, 2268);
2158 path.quadTo(1010.98615f, 2270.07104f, 1012.06104f, 2271.53564f);
2159 path.quadTo(1013.13599f, 2273, 1015.20703f, 2273);
2160 path.lineTo(1083.20703f, 2273);
2161 path.quadTo(1085.27808f, 2273, 1087.13208f, 2271.53564f);
2162 path.quadTo(1088.97144f, 2270.08252f, 1089.52832f, 2268.03271f);
2163 path.lineTo(1089.53711f, 2268);
2164 path.lineTo(1092.46301f, 2257);
2165 path.lineTo(1092.4679f, 2256.98145f);
2166 path.quadTo(1093.00916f, 2254.92236f, 1091.93909f, 2253.46436f);
2167 path.quadTo(1090.86414f, 2252, 1088.79297f, 2252);
2168 path.lineTo(1020.79303f, 2252);
2169 path.close();
2186 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2190 SkPath path;
2191 path.setFillType(SkPath::kEvenOdd_FillType);
2192 path.moveTo(22.5f, 24174.5f);
2193 path.lineTo(185.5f, 24174.498f);
2194 path.lineTo(185.5f, 24174.75f);
2195 path.lineTo(22.5f, 24174.75f);
2196 path.lineTo(22.5f, 24174.5f);
2197 path.close();
2204 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2208 SkPath path;
2209 path.setFillType(SkPath::kEvenOdd_FillType);
2210 path.moveTo(1000, 866.329346f);
2211 path.quadTo(998, 869.250427f, 998, 873);
2212 path.lineTo(998, 874);
2213 path.quadTo(998, 877.749573f, 1000, 880.670654f);
2214 path.lineTo(1000, 866.329346f);
2215 path.close();
2232 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2236 SkPath path;
2237 path.setFillType(SkPath::kEvenOdd_FillType);
2238 path.moveTo(22.5f, 24527.25f);
2239 path.lineTo(45, 24527.248f);
2240 path.lineTo(45, 24527.5f);
2241 path.lineTo(22.5f, 24527.5f);
2242 path.lineTo(22.5f, 24527.25f);
2243 path.close();
2250 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2254 SkPath path;
2255 path.setFillType(SkPath::kEvenOdd_FillType);
2256 path.moveTo(1000, 844.329346f);
2257 path.quadTo(998, 847.250427f, 998, 851);
2258 path.lineTo(998, 852);
2259 path.quadTo(998, 855.749573f, 1000, 858.670654f);
2260 path.lineTo(1000, 844.329346f);
2261 path.close();
2278 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2282 SkPath path;
2283 path.setFillType(SkPath::kEvenOdd_FillType);
2284 path.moveTo(1000, 866.329346f);
2285 path.quadTo(998, 869.250427f, 998, 873);
2286 path.lineTo(998, 874);
2287 path.quadTo(998, 877.749573f, 1000, 880.670654f);
2288 path.lineTo(1000, 866.329346f);
2289 path.close();
2306 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2310 SkPath path;
2311 path.setFillType(SkPath::kEvenOdd_FillType);
2312 path.moveTo(407, 119);
2313 path.lineTo(407, 28);
2314 path.lineTo(647, 28);
2315 path.lineTo(647, 119);
2316 path.lineTo(407, 119);
2317 path.close();
2604 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2608 SkPath path;
2609 path.setFillType(SkPath::kEvenOdd_FillType);
2610 path.moveTo(999.892212f, 246);
2611 path.lineTo(927.340759f, 245.505722f);
2612 path.quadTo(928.068054f, 246, 929, 246);
2613 path.lineTo(999.892212f, 246);
2614 path.close();
2615 path.moveTo(927.340759f, 245.505722f);
2616 path.lineTo(926.5f, 245.5f);
2617 path.lineTo(925.17157f, 246.82843f);
2618 path.quadTo(926.34314f, 248, 928, 248);
2619 path.lineTo(1000, 248);
2620 path.lineTo(1000, 246);
2627 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2631 SkPath path;
2632 path.setFillType(SkPath::kEvenOdd_FillType);
2633 path.moveTo(1000, 896.991394f);
2634 path.quadTo(999.789917f, 896.718872f, 999.535522f, 896.464478f);
2635 path.quadTo(998.071045f, 895, 996, 895);
2636 path.lineTo(956, 895);
2637 path.quadTo(951.857849f, 895, 948.928955f, 897.928955f);
2638 path.quadTo(946, 900.857849f, 946, 905);
2639 path.lineTo(946, 906);
2640 path.quadTo(946, 910.142151f, 948.928955f, 913.071045f);
2641 path.quadTo(951.857849f, 916, 956, 916);
2642 path.lineTo(996, 916);
2643 path.quadTo(998.071045f, 916, 999.535522f, 914.535522f);
2644 path.quadTo(999.789917f, 914.281128f, 1000, 914.008606f);
2645 path.lineTo(1000, 896.991394f);
2646 path.close();
2663 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2667 SkPath path;
2668 path.setFillType(SkPath::kEvenOdd_FillType);
2669 path.moveTo(90.9763107f, 153.309662f);
2670 path.quadTo(91.9526215f, 152.333344f, 93.3333359f, 152.333344f);
2671 path.lineTo(124.666664f, 152.333344f);
2672 path.quadTo(126.047379f, 152.333344f, 127.023689f, 153.309662f);
2673 path.quadTo(128, 154.285965f, 128, 155.666672f);
2674 path.lineTo(128, 163.666672f);
2675 path.lineTo(90, 163.666672f);
2676 path.lineTo(90, 155.666672f);
2677 path.quadTo(90, 154.285965f, 90.9763107f, 153.309662f);
2678 path.close();
2695 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2699 SkPath path;
2700 path.setFillType(SkPath::kEvenOdd_FillType);
2701 path.moveTo(90.9763107f, 153.309662f);
2702 path.quadTo(91.9526215f, 152.333344f, 93.3333359f, 152.333344f);
2703 path.lineTo(124.666672f, 152.333344f);
2704 path.quadTo(126.047379f, 152.333344f, 127.023689f, 153.309662f);
2705 path.quadTo(128, 154.285965f, 128, 155.666672f);
2706 path.lineTo(128, 163.666672f);
2707 path.lineTo(90, 163.666672f);
2708 path.lineTo(90, 155.666672f);
2709 path.quadTo(90, 154.285965f, 90.9763107f, 153.309662f);
2710 path.close();
2727 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2731 SkPath path;
2732 path.setFillType(SkPath::kEvenOdd_FillType);
2733 path.moveTo(360.740479f, 741.040771f);
2734 path.quadTo(360.378967f, 741, 360, 741);
2735 path.quadTo(359.159821f, 741, 358.403076f, 741.200745f);
2736 path.quadTo(357.649658f, 741.415833f, 356.92746f, 741.846436f);
2737 path.quadTo(356.600769f, 742.041199f, 356.310211f, 742.262268f);
2738 path.quadTo(356.025513f, 742.489197f, 355.757355f, 742.757385f);
2739 path.quadTo(355.16394f, 743.350769f, 354.770874f, 744.027283f);
2740 path.quadTo(354.389618f, 744.71283f, 354.183258f, 745.528564f);
2741 path.quadTo(354.090027f, 745.897095f, 354.040833f, 746.259277f);
2742 path.quadTo(354, 746.621216f, 354, 747);
2743 path.quadTo(354, 747.839844f, 354.200653f, 748.596497f);
2744 path.quadTo(354.415771f, 749.35022f, 354.846466f, 750.072632f);
2745 path.quadTo(355.040741f, 750.398438f, 355.261444f, 750.688721f);
2746 path.quadTo(355.488861f, 750.974121f, 355.757355f, 751.242615f);
2747 path.quadTo(356.352142f, 751.837402f, 357.030304f, 752.230896f);
2748 path.quadTo(357.714539f, 752.610901f, 358.528564f, 752.816833f);
2749 path.quadTo(358.895294f, 752.909607f, 359.25528f, 752.95874f);
2750 path.quadTo(359.618896f, 753, 360, 753);
2751 path.quadTo(360.842285f, 753, 361.600952f, 752.798157f);
2752 path.quadTo(362.352386f, 752.583008f, 363.072601f, 752.153625f);
2753 path.quadTo(363.397339f, 751.960022f, 363.686829f, 751.740051f);
2754 path.quadTo(363.973297f, 751.511963f, 364.242645f, 751.242615f);
2755 path.quadTo(364.837799f, 750.647461f, 365.231354f, 749.968933f);
2756 path.quadTo(365.610992f, 749.285034f, 365.816803f, 748.471497f);
2757 path.quadTo(365.909668f, 748.104431f, 365.958832f, 747.743713f);
2758 path.quadTo(366, 747.380371f, 366, 747);
2759 path.quadTo(366, 746.158997f, 365.798767f, 745.401367f);
2760 path.quadTo(365.583618f, 744.648682f, 365.153595f, 743.927429f);
2761 path.quadTo(364.959442f, 743.601807f, 364.738678f, 743.311462f);
2762 path.quadTo(364.511108f, 743.025818f, 364.242645f, 742.757385f);
2763 path.quadTo(363.649017f, 742.163757f, 362.972168f, 741.770569f);
2764 path.quadTo(362.286835f, 741.389526f, 361.471497f, 741.183289f);
2765 path.quadTo(361.102509f, 741.089966f, 360.740479f, 741.040771f);
2766 path.close();
2774 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2778 SkPath path;
2779 path.setFillType(SkPath::kEvenOdd_FillType);
2780 path.moveTo(172, 972);
2781 path.quadTo(170.757355f, 972, 169.878677f, 972.878662f);
2782 path.quadTo(169, 973.757385f, 169, 975);
2783 path.lineTo(169, 1171);
2784 path.quadTo(169, 1172.24268f, 169.878677f, 1173.12134f);
2785 path.quadTo(170.757355f, 1174, 172, 1174);
2786 path.lineTo(308, 1174);
2787 path.quadTo(309.242645f, 1174, 310.121307f, 1173.12134f);
2788 path.quadTo(310.337311f, 1172.9054f, 310.5f, 1172.66772f);
2789 path.lineTo(310.5f, 973.332336f);
2790 path.quadTo(310.337219f, 973.094604f, 310.121307f, 972.878662f);
2791 path.quadTo(309.242645f, 972, 308, 972);
2792 path.lineTo(172, 972);
2793 path.close();
2810 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2814 SkPath path;
2815 path.setFillType(SkPath::kEvenOdd_FillType);
2816 path.moveTo(443, 8292);
2817 path.lineTo(443, 8140);
2818 path.lineTo(444, 8140);
2819 path.lineTo(444.01001f, 8292);
2820 path.lineTo(443, 8292);
2821 path.close();
2828 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2832 SkPath path;
2833 path.setFillType(SkPath::kEvenOdd_FillType);
2834 path.moveTo(10105, 2510);
2835 path.lineTo(10123, 2509.98999f);
2836 path.lineTo(10123, 2511);
2837 path.lineTo(10105, 2511);
2838 path.lineTo(10105, 2510);
2839 path.close();
2846 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2850 SkPath path;
2851 path.setFillType(SkPath::kEvenOdd_FillType);
2852 path.moveTo(429.994995f, 6268);
2853 path.lineTo(430, 2187);
2854 path.lineTo(430.5f, 2187);
2855 path.lineTo(430.5f, 6268);
2856 path.lineTo(429.994995f, 6268);
2857 path.close();
2864 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2868 SkPath path;
2869 path.setFillType(SkPath::kEvenOdd_FillType);
2870 path.moveTo(25.9107456f, 272.577423f);
2871 path.quadTo(26.1548233f, 272.333344f, 26.5000019f, 272.333344f);
2872 path.lineTo(131.166672f, 272.333344f);
2873 path.quadTo(131.511841f, 272.333344f, 131.75592f, 272.577423f);
2874 path.quadTo(132, 272.821503f, 132, 273.166687f);
2875 path.lineTo(132, 417.166656f);
2876 path.quadTo(132, 417.511841f, 131.75592f, 417.75592f);
2877 path.quadTo(131.511841f, 418, 131.166672f, 418);
2878 path.lineTo(26.5000019f, 418);
2879 path.quadTo(26.1548233f, 418, 25.9107456f, 417.75592f);
2880 path.quadTo(25.6666679f, 417.511841f, 25.6666679f, 417.166656f);
2881 path.lineTo(25.6666679f, 273.166687f);
2882 path.quadTo(25.6666679f, 272.821503f, 25.9107456f, 272.577423f);
2883 path.close();
2900 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2904 SkPath path;
2905 path.setFillType(SkPath::kEvenOdd_FillType);
2906 path.moveTo(276, 9506);
2907 path.lineTo(276, 7531);
2908 path.lineTo(277, 7531);
2909 path.lineTo(277.01001f, 9506);
2910 path.lineTo(276, 9506);
2911 path.close();
2918 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2922 SkPath path;
2923 path.setFillType(SkPath::kEvenOdd_FillType);
2924 path.moveTo(276, 9600);
2925 path.lineTo(276, 7703);
2926 path.lineTo(277, 7703);
2927 path.lineTo(277.01001f, 9600);
2928 path.lineTo(276, 9600);
2929 path.close();
2936 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2940 SkPath path;
2941 path.setFillType(SkPath::kEvenOdd_FillType);
2942 path.moveTo(960, 306);
2943 path.lineTo(960, 305);
2944 path.lineTo(1000, 305);
2945 path.lineTo(1000, 306.708527f);
2946 path.lineTo(960, 306);
2947 path.close();
2954 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2958 SkPath path;
2959 path.setFillType(SkPath::kEvenOdd_FillType);
2960 path.moveTo(47.1666679f, 19651.334f);
2961 path.lineTo(65.8333359f, 19651.332f);
2962 path.lineTo(65.8333359f, 19651.5f);
2963 path.lineTo(47.1666679f, 19651.5f);
2964 path.lineTo(47.1666679f, 19651.334f);
2965 path.close();
2972 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2976 SkPath path;
2977 path.setFillType(SkPath::kEvenOdd_FillType);
2978 path.moveTo(941, 1494);
2979 path.lineTo(941, 1464);
2980 path.lineTo(985, 1464);
2981 path.lineTo(985, 1494);
2982 path.lineTo(941, 1494);
2983 path.close();
3150 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3154 SkPath path;
3155 path.setFillType(SkPath::kEvenOdd_FillType);
3156 path.moveTo(1083.34314f, 445.65686f);
3157 path.quadTo(1081, 443.313721f, 1081, 440);
3158 path.lineTo(1257, 440);
3159 path.quadTo(1257, 443.313721f, 1254.65686f, 445.65686f);
3160 path.quadTo(1252.31372f, 448, 1249, 448);
3161 path.lineTo(1089, 448);
3162 path.quadTo(1085.68628f, 448, 1083.34314f, 445.65686f);
3163 path.close();
3164 path.moveTo(1083, 441);
3165 path.lineTo(1255, 441);
3166 path.quadTo(1255, 443.071075f, 1253.53552f, 444.535522f);
3167 path.quadTo(1252.07104f, 446, 1250, 446);
3168 path.lineTo(1088, 446);
3169 path.quadTo(1085.92896f, 446, 1084.46448f, 444.535522f);
3170 path.quadTo(1083, 443.071075f, 1083, 441);
3171 path.close();
3178 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3182 SkPath path;
3183 path.setFillType(SkPath::kEvenOdd_FillType);
3184 path.moveTo(170.340179f, 176);
3185 path.lineTo(166, 176);
3186 path.quadTo(161.964188f, 176, 158.299957f, 176.896912f);
3187 path.quadTo(154.678162f, 177.952271f, 151.183014f, 179.9702f);
3188 path.lineTo(150.316986f, 180.4702f);
3189 path.quadTo(146.175812f, 182.861099f, 143.115921f, 186.081696f);
3190 path.quadTo(140.693939f, 188.70134f, 138.99472f, 191.620407f);
3191 path.quadTo(137.316833f, 194.550888f, 136.259338f, 197.957367f);
3192 path.quadTo(135, 202.217865f, 135, 207);
3193 path.lineTo(135, 208);
3194 path.quadTo(135, 212.035751f, 135.896912f, 215.699997f);
3195 path.quadTo(136.952286f, 219.321869f, 138.9702f, 222.816986f);
3196 path.lineTo(139.4702f, 223.683014f);
3197 path.quadTo(141.861099f, 227.824188f, 145.081696f, 230.884079f);
3198 path.quadTo(147.70134f, 233.306061f, 150.620407f, 235.00528f);
3199 path.quadTo(153.550888f, 236.683167f, 156.957367f, 237.740662f);
3200 path.quadTo(161.217865f, 239, 166, 239);
3201 path.lineTo(170.482162f, 239);
3202 path.quadTo(176.307037f, 238.210968f, 181.816986f, 235.0298f);
3203 path.lineTo(182.683014f, 234.5298f);
3204 path.quadTo(182.686462f, 234.527817f, 182.689896f, 234.525818f);
3205 path.quadTo(193.804352f, 228.105652f, 197.126709f, 215.70639f);
3206 path.quadTo(200.450104f, 203.303314f, 194.0298f, 192.183014f);
3207 path.lineTo(193.5298f, 191.316986f);
3208 path.quadTo(187.109497f, 180.196686f, 174.706406f, 176.873276f);
3209 path.quadTo(172.503067f, 176.282898f, 170.340179f, 176);
3210 path.close();
3227 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3231 SkPath path;
3232 path.setFillType(SkPath::kEvenOdd_FillType);
3233 path.moveTo(819.050781f, 5539.72412f);
3234 path.quadTo(819.651672f, 5539.1543f, 820.479858f, 5539.17578f);
3235 path.lineTo(1191.35278f, 5548.8877f);
3236 path.quadTo(1192.18091f, 5548.90918f, 1192.7511f, 5549.50977f);
3237 path.quadTo(1193.32141f, 5550.11133f, 1193.29968f, 5550.93945f);
3238 path.lineTo(1186.57214f, 5807.85107f);
3239 path.quadTo(1186.55054f, 5808.6792f, 1185.94958f, 5809.24951f);
3240 path.quadTo(1185.34863f, 5809.81982f, 1184.52051f, 5809.79834f);
3241 path.lineTo(813.647705f, 5800.08643f);
3242 path.quadTo(812.819519f, 5800.06494f, 812.249268f, 5799.46387f);
3243 path.quadTo(811.679016f, 5798.86279f, 811.700684f, 5798.03467f);
3244 path.lineTo(818.428162f, 5541.12305f);
3245 path.quadTo(818.44989f, 5540.29492f, 819.050781f, 5539.72412f);
3246 path.close();
3254 path, pathB, kIntersect_SkPathOp, filename);
3258 SkPath path;
3259 path.setFillType(SkPath::kEvenOdd_FillType);
3260 path.moveTo(47.1666679f, 27820.668f);
3261 path.lineTo(60.8333359f, 27820.668f);
3262 path.lineTo(60.8333359f, 27820.498f);
3263 path.lineTo(47.1666679f, 27820.5f);
3264 path.lineTo(47.1666679f, 27820.668f);
3265 path.close();
3272 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3276 SkPath path;
3277 path.setFillType(SkPath::kEvenOdd_FillType);
3278 path.moveTo(630.378662f, 1293.42896f);
3279 path.quadTo(631.257385f, 1292.55029f, 632.5f, 1292.55029f);
3280 path.quadTo(633.742615f, 1292.55029f, 634.621338f, 1293.42896f);
3281 path.lineTo(639.571045f, 1298.37866f);
3282 path.quadTo(640.449768f, 1299.25732f, 640.449707f, 1300.5f);
3283 path.quadTo(640.449768f, 1301.74268f, 639.571045f, 1302.62134f);
3284 path.lineTo(634.621338f, 1307.57104f);
3285 path.quadTo(633.742615f, 1308.44971f, 632.5f, 1308.44971f);
3286 path.quadTo(631.257385f, 1308.44971f, 630.378662f, 1307.57104f);
3287 path.lineTo(625.428955f, 1302.62134f);
3288 path.quadTo(624.550232f, 1301.74268f, 624.550293f, 1300.5f);
3289 path.quadTo(624.550232f, 1299.25732f, 625.428955f, 1298.37866f);
3290 path.lineTo(630.378662f, 1293.42896f);
3291 path.close();
3299 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3303 SkPath path;
3304 path.setFillType(SkPath::kEvenOdd_FillType);
3305 path.moveTo(1083.34314f, 513.65686f);
3306 path.quadTo(1081, 511.313721f, 1081, 508);
3307 path.lineTo(1257, 508);
3308 path.quadTo(1257, 511.313721f, 1254.65686f, 513.65686f);
3309 path.quadTo(1252.31372f, 516, 1249, 516);
3310 path.lineTo(1089, 516);
3311 path.quadTo(1085.68628f, 516, 1083.34314f, 513.65686f);
3312 path.close();
3313 path.moveTo(1083, 509);
3314 path.lineTo(1255, 509);
3315 path.quadTo(1255, 511.071075f, 1253.53552f, 512.535522f);
3316 path.quadTo(1252.07104f, 514, 1250, 514);
3317 path.lineTo(1088, 514);
3318 path.quadTo(1085.92896f, 514, 1084.46448f, 512.535522f);
3319 path.quadTo(1083, 511.071075f, 1083, 509);
3320 path.close();
3327 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3331 SkPath path;
3332 path.setFillType(SkPath::kEvenOdd_FillType);
3333 path.moveTo(999.454102f, 689.17157f);
3334 path.quadTo(1001.172f, 688, 1002.82886f, 688);
3335 path.lineTo(1013.82886f, 688);
3336 path.lineTo(1002.17114f, 713);
3337 path.lineTo(991.171143f, 713);
3338 path.quadTo(989.514282f, 713, 988.889038f, 711.82843f);
3339 path.quadTo(988.263794f, 710.65686f, 989.036377f, 709);
3340 path.lineTo(996.963623f, 692);
3341 path.quadTo(997.736206f, 690.34314f, 999.454102f, 689.17157f);
3342 path.close();
3350 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3354 SkPath path;
3355 path.setFillType(SkPath::kEvenOdd_FillType);
3356 path.moveTo(794.514709f, 759.485291f);
3357 path.quadTo(791, 755.970581f, 791, 751);
3358 path.lineTo(1133, 751);
3359 path.quadTo(1133, 755.970581f, 1129.48523f, 759.485291f);
3360 path.quadTo(1125.97058f, 763, 1121, 763);
3361 path.lineTo(803, 763);
3362 path.quadTo(798.029419f, 763, 794.514709f, 759.485291f);
3363 path.close();
3364 path.moveTo(793, 752);
3365 path.lineTo(1131, 752);
3366 path.quadTo(1131, 755.727905f, 1128.36401f, 758.363953f);
3367 path.quadTo(1125.72791f, 761, 1122, 761);
3368 path.lineTo(802, 761);
3369 path.quadTo(798.272095f, 761, 795.636047f, 758.363953f);
3370 path.quadTo(793, 755.727905f, 793, 752);
3371 path.close();
3378 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3382 SkPath path;
3383 path.setFillType(SkPath::kEvenOdd_FillType);
3384 path.moveTo(166.878677f, 7638.87891f);
3385 path.quadTo(166, 7639.75732f, 166, 7641);
3386 path.lineTo(166, 11577);
3387 path.quadTo(166, 11578.2422f, 166.878677f, 11579.1211f);
3388 path.quadTo(167.388f, 11579.6309f, 168.019989f, 11579.8447f);
3389 path.lineTo(168.019974f, 11576.2979f);
3390 path.quadTo(168, 11576.1533f, 168, 11576);
3391 path.lineTo(168, 7642);
3392 path.lineTo(168.000015f, 7641.99316f);
3393 path.lineTo(168, 7640);
3394 path.lineTo(166.878677f, 7638.87891f);
3395 path.close();
3402 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3406 SkPath path;
3407 path.setFillType(SkPath::kEvenOdd_FillType);
3408 path.moveTo(465.951904f, 547.960144f);
3409 path.quadTo(465.66571f, 546.867371f, 465.404938f, 546);
3410 path.lineTo(465.504089f, 546);
3411 path.quadTo(465.670349f, 546.601257f, 465.84668f, 547.288391f);
3412 path.quadTo(467.274506f, 552.852356f, 468.506836f, 560.718567f);
3413 path.quadTo(467.336121f, 553.24585f, 465.951904f, 547.960144f);
3414 path.close();
3415 path.moveTo(470.591064f, 574.024353f);
3416 path.quadTo(474.844055f, 601.176025f, 471.728271f, 620.364502f);
3417 path.quadTo(470.567017f, 627.515991f, 468.635742f, 632);
3418 path.lineTo(469.106812f, 632);
3419 path.quadTo(470.791504f, 627.638672f, 471.833496f, 621.036255f);
3420 path.quadTo(474.905701f, 601.569519f, 470.591064f, 574.024353f);
3421 path.close();
3429 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3433 SkPath path;
3434 path.setFillType(SkPath::kEvenOdd_FillType);
3435 path.moveTo(633.147217f, 1247);
3436 path.lineTo(718, 1162.14722f);
3437 path.lineTo(802.852783f, 1247);
3438 path.lineTo(718, 1331.85278f);
3439 path.lineTo(633.147217f, 1247);
3440 path.close();
3457 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3461 SkPath path;
3462 path.setFillType(SkPath::kEvenOdd_FillType);
3463 path.moveTo(816.514709f, 781.485291f);
3464 path.quadTo(813, 777.970581f, 813, 773);
3465 path.lineTo(1133, 773);
3466 path.quadTo(1133, 777.970581f, 1129.48523f, 781.485291f);
3467 path.quadTo(1125.97058f, 785, 1121, 785);
3468 path.lineTo(825, 785);
3469 path.quadTo(820.029419f, 785, 816.514709f, 781.485291f);
3470 path.close();
3471 path.moveTo(815, 774);
3472 path.lineTo(1131, 774);
3473 path.quadTo(1131, 777.727905f, 1128.36401f, 780.363953f);
3474 path.quadTo(1125.72791f, 783, 1122, 783);
3475 path.lineTo(824, 783);
3476 path.quadTo(820.272095f, 783, 817.636047f, 780.363953f);
3477 path.quadTo(815, 777.727905f, 815, 774);
3478 path.close();
3485 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3489 SkPath path;
3490 path.setFillType(SkPath::kEvenOdd_FillType);
3491 path.moveTo(365, 5101);
3492 path.lineTo(365, 5082);
3493 path.lineTo(366, 5083);
3494 path.lineTo(367, 5092.96631f);
3495 path.lineTo(367, 5100);
3496 path.quadTo(367, 5101.50537f, 367.967712f, 5102.61084f);
3497 path.lineTo(368.278717f, 5105.71045f);
3498 path.quadTo(367.277618f, 5105.34863f, 366.464478f, 5104.53564f);
3499 path.quadTo(365, 5103.07129f, 365, 5101);
3500 path.close();
3507 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3511 SkPath path;
3512 path.setFillType(SkPath::kEvenOdd_FillType);
3513 path.moveTo(725.911682f, 898.767456f);
3514 path.lineTo(741.232544f, 885.911682f);
3515 path.lineTo(754.088318f, 901.232544f);
3516 path.lineTo(738.767456f, 914.088318f);
3517 path.lineTo(725.911682f, 898.767456f);
3518 path.close();
3526 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3530 SkPath path;
3531 path.setFillType(SkPath::kEvenOdd_FillType);
3532 path.moveTo(4915, 1523);
3533 path.quadTo(4887.24756f, 1523, 4867.62402f, 1542.6239f);
3534 path.quadTo(4848, 1562.24768f, 4848, 1590);
3535 path.quadTo(4848, 1617.75232f, 4867.62402f, 1637.3761f);
3536 path.quadTo(4887.24756f, 1657, 4915, 1657);
3537 path.quadTo(4942.75244f, 1657, 4962.37598f, 1637.3761f);
3538 path.quadTo(4982, 1617.75232f, 4982, 1590);
3539 path.quadTo(4982, 1562.24768f, 4962.37598f, 1542.6239f);
3540 path.quadTo(4942.75244f, 1523, 4915, 1523);
3541 path.close();
3554 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3558 SkPath path;
3559 path.setFillType(SkPath::kEvenOdd_FillType);
3560 path.moveTo(10210.8789f, 5315.87891f);
3561 path.quadTo(10211.7578f, 5315, 10213, 5315);
3562 path.lineTo(10230, 5315);
3563 path.quadTo(10231.2422f, 5315, 10232.1211f, 5315.87891f);
3564 path.quadTo(10233, 5316.75732f, 10233, 5318);
3565 path.lineTo(10233, 5338);
3566 path.quadTo(10233, 5339.24268f, 10232.1211f, 5340.12109f);
3567 path.quadTo(10231.2422f, 5341, 10230, 5341);
3568 path.lineTo(10213, 5341);
3569 path.quadTo(10211.7578f, 5341, 10210.8789f, 5340.12109f);
3570 path.quadTo(10210, 5339.24268f, 10210, 5338);
3571 path.lineTo(10210, 5318);
3572 path.quadTo(10210, 5316.75732f, 10210.8789f, 5315.87891f);
3573 path.close();
3586 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3590 SkPath path;
3591 path.setFillType(SkPath::kEvenOdd_FillType);
3592 path.moveTo(143, 14557);
3593 path.lineTo(165, 14557);
3594 path.lineTo(165, 14555.9902f);
3595 path.lineTo(143, 14556);
3596 path.lineTo(143, 14557);
3597 path.close();
3604 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3608 SkPath path;
3609 path.setFillType(SkPath::kEvenOdd_FillType);
3610 path.moveTo(808.585815f, 11673.5859f);
3611 path.quadTo(809.17157f, 11673, 810, 11673);
3612 path.lineTo(1032, 11673);
3613 path.quadTo(1038.21326f, 11673, 1042.60657f, 11677.3936f);
3614 path.quadTo(1047, 11681.7871f, 1047, 11688);
3615 path.quadTo(1047, 11682.2012f, 1042.60657f, 11678.1006f);
3616 path.quadTo(1038.21326f, 11674, 1032, 11674);
3617 path.lineTo(810, 11674);
3618 path.quadTo(809.585815f, 11674, 809.292908f, 11674.293f);
3619 path.quadTo(809, 11674.5859f, 809, 11675);
3620 path.lineTo(809, 11701);
3621 path.quadTo(809, 11701.4141f, 809.292908f, 11701.707f);
3622 path.quadTo(809.585815f, 11702, 810, 11702);
3623 path.lineTo(1032, 11702);
3624 path.quadTo(1038.21326f, 11702, 1042.60657f, 11697.8994f);
3625 path.quadTo(1047, 11693.7988f, 1047, 11688);
3626 path.quadTo(1047, 11694.2129f, 1042.60657f, 11698.6064f);
3627 path.quadTo(1038.21326f, 11703, 1032, 11703);
3628 path.lineTo(810, 11703);
3629 path.quadTo(809.17157f, 11703, 808.585815f, 11702.4141f);
3630 path.quadTo(808, 11701.8281f, 808, 11701);
3631 path.lineTo(808, 11675);
3632 path.quadTo(808, 11674.1719f, 808.585815f, 11673.5859f);
3633 path.close();
3640 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3644 SkPath path;
3645 path.setFillType(SkPath::kEvenOdd_FillType);
3646 path.moveTo(205.884888f, 648.203857f);
3647 path.lineTo(771.570374f, 82.5183716f);
3648 path.lineTo(1110.98169f, 421.929626f);
3649 path.lineTo(545.296143f, 987.615112f);
3650 path.lineTo(205.884888f, 648.203857f);
3651 path.close();
3659 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3663 SkPath path;
3664 path.setFillType(SkPath::kEvenOdd_FillType);
3665 path.moveTo(78.6429825f, 1394.30969f);
3666 path.quadTo(79.6192932f, 1393.33337f, 81.0000076f, 1393.33337f);
3667 path.lineTo(341, 1393.33337f);
3668 path.quadTo(342.380707f, 1393.33337f, 343.357025f, 1394.30969f);
3669 path.quadTo(344.333344f, 1395.28601f, 344.333344f, 1396.66675f);
3670 path.lineTo(344.333344f, 1465.66663f);
3671 path.quadTo(344.333344f, 1467.04736f, 343.357025f, 1468.02368f);
3672 path.quadTo(342.380707f, 1469, 341, 1469);
3673 path.lineTo(81.0000076f, 1469);
3674 path.quadTo(79.6192932f, 1469, 78.6429825f, 1468.02368f);
3675 path.quadTo(77.6666718f, 1467.04736f, 77.6666718f, 1465.66663f);
3676 path.lineTo(77.6666718f, 1396.66675f);
3677 path.quadTo(77.6666718f, 1395.28601f, 78.6429825f, 1394.30969f);
3678 path.close();
3691 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3695 SkPath path;
3696 path.setFillType(SkPath::kEvenOdd_FillType);
3697 path.moveTo(1000, 310.947968f);
3698 path.lineTo(771.570374f, 82.5183716f);
3699 path.lineTo(205.884888f, 648.203857f);
3700 path.lineTo(448.68103f, 891);
3701 path.lineTo(641.911255f, 891);
3702 path.lineTo(1000, 532.911316f);
3703 path.lineTo(1000, 310.947968f);
3704 path.close();
3712 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3716 SkPath path;
3717 path.setFillType(SkPath::kEvenOdd_FillType);
3718 path.moveTo(78.6429825f, 3150.97632f);
3719 path.quadTo(79.6192932f, 3150, 81.0000076f, 3150);
3720 path.lineTo(341, 3150);
3721 path.quadTo(342.380707f, 3150, 343.357025f, 3150.97632f);
3722 path.quadTo(344.333344f, 3151.95264f, 344.333344f, 3153.33325f);
3723 path.lineTo(344.333344f, 5205.3335f);
3724 path.quadTo(344.333344f, 5206.71436f, 343.357025f, 5207.69092f);
3725 path.quadTo(342.380707f, 5208.66699f, 341, 5208.66699f);
3726 path.lineTo(81.0000076f, 5208.66699f);
3727 path.quadTo(79.6192932f, 5208.66699f, 78.6429825f, 5207.69092f);
3728 path.quadTo(77.6666718f, 5206.71436f, 77.6666718f, 5205.3335f);
3729 path.lineTo(77.6666718f, 3153.33325f);
3730 path.quadTo(77.6666718f, 3151.95264f, 78.6429825f, 3150.97632f);
3731 path.close();
3744 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3748 SkPath path;
3749 path.setFillType(SkPath::kEvenOdd_FillType);
3750 path.moveTo(941, 1494);
3751 path.lineTo(941, 1464);
3752 path.lineTo(985, 1464);
3753 path.lineTo(985, 1494);
3754 path.lineTo(941, 1494);
3755 path.close();
3764 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3769 SkPath path;
3770 path.setFillType((SkPath::FillType) 1);
3771 path.moveTo(SkBits2Float(0x44472795), SkBits2Float(0x455cdb8d)); // 796.618f, 3533.72f
3772 path.lineTo(SkBits2Float(0x44467c27), SkBits2Float(0x455cdb8d)); // 793.94f, 3533.72f
3773 path.lineTo(SkBits2Float(0x44467c27), SkBits2Float(0x455d055d)); // 793.94f, 3536.34f
3774 path.lineTo(SkBits2Float(0x44472795), SkBits2Float(0x455d055d)); // 796.618f, 3536.34f
3775 path.lineTo(SkBits2Float(0x44472795), SkBits2Float(0x455cdb8d)); // 796.618f, 3533.72f
3776 SkPath path1(path);
3777 path.reset();
3778 path.setFillType((SkPath::FillType) 0);
3779 path.moveTo(SkBits2Float(0x4446861c), SkBits2Float(0x455cdb8d)); // 794.095f, 3533.72f
3780 path.cubicTo(SkBits2Float(0x4446a0d8), SkBits2Float(0x455cefbb), SkBits2Float(0x444727a5), SkBits2Float(0x455d055d), SkBits2Float(0x444727a5), SkBits2Float(0x455d055d)); // 794.513f, 3534.98f, 796.619f, 3536.34f, 796.619f, 3536.34f
3781 path.cubicTo(SkBits2Float(0x4446c5b0), SkBits2Float(0x455cf8a4), SkBits2Float(0x444693af), SkBits2Float(0x455cedad), SkBits2Float(0x44467c1b), SkBits2Float(0x455ce4b8)); // 795.089f, 3535.54f, 794.308f, 3534.85f, 793.939f, 3534.29f
3782 path.lineTo(SkBits2Float(0x44467d70), SkBits2Float(0x455ce016)); // 793.96f, 3534.01f
3783 path.cubicTo(SkBits2Float(0x44467fa9), SkBits2Float(0x455cde82), SkBits2Float(0x444682b5), SkBits2Float(0x455cdd03), SkBits2Float(0x4446861c), SkBits2Float(0x455cdb8d)); // 793.995f, 3533.91f, 794.042f, 3533.81f, 794.095f, 3533.72f
3784 SkPath path2(path);
3789 SkPath path;
3790 path.setFillType((SkPath::FillType) 1);
3791 path.moveTo(SkBits2Float(0x44924000), SkBits2Float(0x458e7800)); // 1170, 4559
3792 path.conicTo(SkBits2Float(0x44930000), SkBits2Float(0x458e7800), SkBits2Float(0x44930000), SkBits2Float(0x458ea800), SkBits2Float(0x3f3504f3)); // 1176, 4559, 1176, 4565, 0.707107f
3793 path.lineTo(SkBits2Float(0x44930000), SkBits2Float(0x458f7000)); // 1176, 4590
3794 path.conicTo(SkBits2Float(0x44930000), SkBits2Float(0x458f9800), SkBits2Float(0x44926000), SkBits2Float(0x458f9800), SkBits2Float(0x3f3504f3)); // 1176, 4595, 1171, 4595, 0.707107f
3795 path.lineTo(SkBits2Float(0x42a60000), SkBits2Float(0x458f9800)); // 83, 4595
3796 path.conicTo(SkBits2Float(0x429c0471), SkBits2Float(0x458f9800), SkBits2Float(0x429c0000), SkBits2Float(0x458f700c), SkBits2Float(0x3f352d2d)); // 78.0087f, 4595, 78, 4590.01f, 0.707721f
3797 path.lineTo(SkBits2Float(0x429c0000), SkBits2Float(0x458ea800)); // 78, 4565
3798 path.conicTo(SkBits2Float(0x429c0000), SkBits2Float(0x458e7800), SkBits2Float(0x42a80000), SkBits2Float(0x458e7800), SkBits2Float(0x3f3504f3)); // 78, 4559, 84, 4559, 0.707107f
3799 path.lineTo(SkBits2Float(0x44924000), SkBits2Float(0x458e7800)); // 1170, 4559
3800 path.close();
3801 SkPath path1(path);
3802 path.reset();
3803 path.setFillType((SkPath::FillType) 0);
3804 path.moveTo(SkBits2Float(0x429c0000), SkBits2Float(0x458f7000)); // 78, 4590
3805 path.lineTo(SkBits2Float(0x429c0000), SkBits2Float(0x458ea800)); // 78, 4565
3806 path.conicTo(SkBits2Float(0x429c0000), SkBits2Float(0x458e7800), SkBits2Float(0x42a80000), SkBits2Float(0x458e7800), SkBits2Float(0x3f3504f3)); // 78, 4559, 84, 4559, 0.707107f
3807 path.lineTo(SkBits2Float(0x431e0000), SkBits2Float(0x458e7800)); // 158, 4559
3808 path.conicTo(SkBits2Float(0x431e0000), SkBits2Float(0x458e7800), SkBits2Float(0x431e0000), SkBits2Float(0x458e7800), SkBits2Float(0x3f3504f3)); // 158, 4559, 158, 4559, 0.707107f
3809 path.lineTo(SkBits2Float(0x431e0000), SkBits2Float(0x458fa000)); // 158, 4596
3810 path.conicTo(SkBits2Float(0x431e0000), SkBits2Float(0x458fa000), SkBits2Float(0x431e0000), SkBits2Float(0x458fa000), SkBits2Float(0x3f3504f3)); // 158, 4596, 158, 4596, 0.707107f
3811 path.lineTo(SkBits2Float(0x42a80000), SkBits2Float(0x458fa000)); // 84, 4596
3812 path.conicTo(SkBits2Float(0x429c0000), SkBits2Float(0x458fa000), SkBits2Float(0x429c0000), SkBits2Float(0x458f7000), SkBits2Float(0x3f3504f3)); // 78, 4596, 78, 4590, 0.707107f
3813 path.close();
3815 SkPath path2(path);
3820 SkPath path;
3821 path.setFillType((SkPath::FillType) 1);
3822 path.moveTo(SkBits2Float(0x447a0000), SkBits2Float(0x00000000)); // 1000, 0
3823 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
3824 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x44b6e000)); // 0, 1463
3825 path.lineTo(SkBits2Float(0x447a0000), SkBits2Float(0x44b6e000)); // 1000, 1463
3826 path.lineTo(SkBits2Float(0x447a0000), SkBits2Float(0x00000000)); // 1000, 0
3827 path.close();
3828 SkPath path1(path);
3829 path.reset();
3830 path.setFillType((SkPath::FillType) 0);
3831 path.moveTo(SkBits2Float(0x366a410f), SkBits2Float(0x43a38000)); // 3.49066e-06f, 327
3832 path.lineTo(SkBits2Float(0x447a0000), SkBits2Float(0x43a38001)); // 1000, 327
3833 path.lineTo(SkBits2Float(0x447a0000), SkBits2Float(0x4435c000)); // 1000, 727
3834 path.lineTo(SkBits2Float(0xb66a410d), SkBits2Float(0x4435c000)); // -3.49066e-06f, 727
3835 path.lineTo(SkBits2Float(0x366a410f), SkBits2Float(0x43a38000)); // 3.49066e-06f, 327
3836 path.close();
3837 SkPath path2(path);
3843 SkPath path;
3844 path.setFillType((SkPath::FillType) 1);
3845 path.moveTo(SkBits2Float(0x442fc000), SkBits2Float(0x4546a000)); // 703, 3178
3846 path.lineTo(SkBits2Float(0x441f4000), SkBits2Float(0x4546a000)); // 637, 3178
3847 path.lineTo(SkBits2Float(0x441f4000), SkBits2Float(0x454ab000)); // 637, 3243
3848 path.lineTo(SkBits2Float(0x442fc000), SkBits2Float(0x454ab000)); // 703, 3243
3849 path.lineTo(SkBits2Float(0x442fc000), SkBits2Float(0x4546a000)); // 703, 3178
3850 path.close();
3851 SkPath path1(path);
3852 path.reset();
3853 path.setFillType((SkPath::FillType) 0);
3854 path.moveTo(SkBits2Float(0x44220e6e), SkBits2Float(0x45469c4c)); // 648.225f, 3177.77f
3855 path.lineTo(SkBits2Float(0x442fc01c), SkBits2Float(0x45475696)); // 703.002f, 3189.41f
3856 path.lineTo(SkBits2Float(0x442cf191), SkBits2Float(0x454aa3b5)); // 691.774f, 3242.23f
3857 path.lineTo(SkBits2Float(0x441f3fe3), SkBits2Float(0x4549e96b)); // 636.998f, 3230.59f
3858 path.lineTo(SkBits2Float(0x44220e6e), SkBits2Float(0x45469c4c)); // 648.225f, 3177.77f
3859 path.close();
3860 SkPath path2(path);
3865 SkPath path;
3866 path.setFillType(SkPath::kEvenOdd_FillType);
3867 path.moveTo(1000, 659);
3868 path.lineTo(1000, 377);
3869 path.lineTo(455, 377);
3870 path.lineTo(455, 659);
3871 path.lineTo(1000, 659);
3872 path.close();
3873 SkPath path1(path);
3874 path.reset();
3875 path.setFillType(SkPath::kEvenOdd_FillType);
3876 path.moveTo(921.472f, 414.086f);
3877 path.lineTo(968.815f, 386.754f);
3878 path.lineTo(993.069f, 428.761f);
3879 path.lineTo(945.726f, 456.096f);
3880 path.lineTo(921.471f, 414.086f);
3881 path.lineTo(921.472f, 414.086f);
3882 path.close();
3883 path.moveTo(971.151f, 422.889f);
3884 path.cubicTo(966.509f, 414.848f, 957.649f, 411.727f, 950.181f, 416.038f);
3885 path.lineTo(947.224f, 417.746f);
3886 path.lineTo(946.979f, 417.887f);
3887 path.lineTo(947.838f, 419.371f);
3888 path.lineTo(947.844f, 419.367f);
3889 path.lineTo(947.868f, 419.353f);
3890 path.lineTo(947.945f, 419.309f);
3891 path.cubicTo(947.988f, 419.285f, 947.988f, 419.285f, 948.023f, 419.263f);
3892 path.cubicTo(948.039f, 419.255f, 948.039f, 419.255f, 948.047f, 419.25f);
3893 path.lineTo(948.052f, 419.247f);
3894 path.lineTo(947.196f, 417.762f);
3895 path.lineTo(947.195f, 417.762f);
3896 path.lineTo(946.888f, 417.939f);
3897 path.lineTo(943.39f, 419.959f);
3898 path.lineTo(944.249f, 421.443f);
3899 path.lineTo(947.745f, 419.424f);
3900 path.lineTo(948.05f, 419.247f);
3901 path.lineTo(948.052f, 419.247f);
3902 path.lineTo(947.195f, 417.763f);
3903 path.cubicTo(947.193f, 417.763f, 947.193f, 417.763f, 947.19f, 417.766f);
3904 path.lineTo(947.166f, 417.779f);
3905 path.lineTo(947.087f, 417.825f);
3906 path.lineTo(947.011f, 417.868f);
3907 path.lineTo(946.987f, 417.883f);
3908 path.lineTo(946.982f, 417.886f);
3909 path.lineTo(946.98f, 417.886f);
3910 path.lineTo(947.839f, 419.37f);
3911 path.lineTo(948.083f, 419.229f);
3912 path.lineTo(951.039f, 417.522f);
3913 path.cubicTo(957.631f, 413.716f, 965.471f, 416.477f, 969.669f, 423.746f);
3914 path.lineTo(971.153f, 422.889f);
3915 path.lineTo(971.151f, 422.889f);
3916 path.close();
3917 SkPath path2(path);
3922 SkPath path;
3923 path.setFillType(SkPath::kEvenOdd_FillType);
3924 path.moveTo(188.6f, 1988.8f);
3925 path.lineTo(188.6f, 2041.6f);
3926 path.cubicTo(188.6f, 2065.4f, 208, 2084.8f, 231.8f, 2084.8f);
3927 path.cubicTo(255.6f, 2084.8f, 275, 2065.4f, 275, 2041.6f);
3928 path.lineTo(275.2f, 2041.6f);
3929 path.lineTo(275.2f, 1988.8f);
3930 path.lineTo(188.6f, 1988.8f);
3931 path.close();
3932 SkPath path1(path);
3933 path.reset();
3934 path.setFillType(SkPath::kWinding_FillType);
3935 path.moveTo(275, 2041.6f);
3936 path.conicTo(275, 2084.8f, 231.8f, 2084.8f, 0.707107f);
3937 path.conicTo(188.6f, 2084.8f, 188.6f, 2041.6f, 0.707107f);
3938 path.conicTo(188.6f, 1998.4f, 231.8f, 1998.4f, 0.707107f);
3939 path.conicTo(275, 1998.4f, 275, 2041.6f, 0.707107f);
3940 path.close();
3941 SkPath path2(path);
3946 SkPath path;
3947 path.setFillType(SkPath::kEvenOdd_FillType);
3948 path.moveTo(75.96f, 26.318f);
3949 path.lineTo(70.337f, 26.318f);
3950 path.lineTo(70.337f, 32.376f);
3951 path.lineTo(75.96f, 32.376f);
3952 path.lineTo(75.96f, 26.318f);
3953 path.close();
3954 SkPath path1(path);
3955 path.reset();
3956 path.setFillType(SkPath::kWinding_FillType);
3957 path.moveTo(75.88f, 27.873f);
3958 path.cubicTo(75.929f, 28.138f, 75.956f, 29.196f, 75.96f, 31.046f);
3959 path.lineTo(72.766f, 32.376f);
3960 path.cubicTo(72.763f, 30.525f, 72.735f, 29.468f, 72.686f, 29.203f);
3961 path.cubicTo(72.636f, 28.94f, 72.519f, 28.722f, 72.335f, 28.552f);
3962 path.cubicTo(72.248f, 28.472f, 72.058f, 28.364f, 71.763f, 28.228f);
3963 path.cubicTo(72.425f, 27.933f, 72.425f, 27.933f, 73.395f, 27.498f);
3964 path.cubicTo(72.425f, 27.933f, 72.425f, 27.933f, 71.763f, 28.228f);
3965 path.cubicTo(71.425f, 28.072f, 70.95f, 27.878f, 70.337f, 27.647f);
3966 path.lineTo(73.531f, 26.317f);
3967 path.cubicTo(74.144f, 26.547f, 74.619f, 26.741f, 74.957f, 26.898f);
3968 path.cubicTo(74.475f, 27.113f, 73.993f, 27.329f, 73.511f, 27.544f);
3969 path.cubicTo(73.993f, 27.329f, 74.475f, 27.114f, 74.957f, 26.898f);
3970 path.cubicTo(75.252f, 27.034f, 75.442f, 27.142f, 75.529f, 27.222f);
3971 path.cubicTo(75.713f, 27.393f, 75.83f, 27.61f, 75.88f, 27.873f);
3972 SkPath path2(path);
3977 SkPath path;
3978 path.setFillType((SkPath::FillType) 1);
3979 path.moveTo(SkBits2Float(0x3f800000), SkBits2Float(0x44370000)); // 1, 732
3980 path
3981 path.conicTo(SkBits2Float(0x40400000), SkBits2Float(0x4428c000), SkBits2Float(0x40400000), SkBits2Float(0x44370000), SkBits2Float(0x3f3504f3)); // 3, 675, 3, 732, 0.707107f
3982 path.conicTo(SkBits2Float(0x40400000), SkBits2Float(0x44444000), SkBits2Float(0x42680000), SkBits2Float(0x44444000), SkBits2Float(0x3f3504f3)); // 3, 785, 58, 785, 0.707107f
3983 path.lineTo(SkBits2Float(0x446d0000), SkBits2Float(0x44444000)); // 948, 785
3984 path.conicTo(SkBits2Float(0x447ac000), SkBits2Float(0x44444000), SkBits2Float(0x447ac000), SkBits2Float(0x44370000), SkBits2Float(0x3f3504f3)); // 1003, 785, 1003, 732, 0.707107f
3985 path.conicTo(SkBits2Float(0x447ac000), SkBits2Float(0x4428c000), SkBits2Float(0x446d0000), SkBits2Float(0x4428c000), SkBits2Float(0x3f3504f3)); // 1003, 675, 948, 675, 0.707107f
3986 path.conicTo(SkBits2Float(0x447b4000), SkBits2Float(0x4428c000), SkBits2Float(0x447b4000), SkBits2Float(0x44370000), SkBits2Float(0x3f3504f3)); // 1005, 675, 1005, 732, 0.707107f
3987 path.conicTo(SkBits2Float(0x447b4000), SkBits2Float(0x44454000), SkBits2Float(0x446d0000), SkBits2Float(0x44454000), SkBits2Float(0x3f3504f3)); // 1005, 789, 948, 789, 0.707107f
3988 path.lineTo(SkBits2Float(0x42680000), SkBits2Float(0x44454000)); // 58, 789
3989 path.conicTo(SkBits2Float(0x3f800000), SkBits2Float(0x44454000), SkBits2Float(0x3f800000), SkBits2Float(0x44370000), SkBits2Float(0x3f3504f3)); // 1, 789, 1, 732, 0.707107f
3990 path.close();
3992 SkPath path1(path);
3993 path.reset();
3994 path.setFillType((SkPath::FillType) 0);
3995 path.moveTo(SkBits2Float(0x3f800000), SkBits2Float(0x4428c000)); // 1, 675
3996 path.lineTo(SkBits2Float(0x42680000), SkBits2Float(0x4428c000)); // 58, 675
3997 path.lineTo(SkBits2Float(0x3fc8f676), SkBits2Float(0x44454000)); // 1.57002f, 789
3998 path.lineTo(SkBits2Float(0x3f800000), SkBits2Float(0x44454000)); // 1, 789
4000 SkPath path2(path);
4005 SkPath path;
4006 path.setFillType((SkPath::FillType) 1);
4007 path.moveTo(SkBits2Float(0x42680000), SkBits2Float(0x4428c000)); // 58, 675
4008 path.conicTo(SkBits2Float(0x3f800000), SkBits2Float(0x4428c000), SkBits2Float(0x3f800000), SkBits2Float(0x44370000), SkBits2Float(0x3f3504f3)); // 1, 675, 1, 732, 0.707107f
4009 path.conicTo(SkBits2Float(0x3f800000), SkBits2Float(0x443bd045), SkBits2Float(0x414acf56), SkBits2Float(0x443fa420), SkBits2Float(0x3f778612)); // 1, 751.254f, 12.6756f, 766.564f, 0.96689f
4010 path.lineTo(SkBits2Float(0x41606e3d), SkBits2Float(0x443ef569)); // 14.0269f, 763.835f
4011 path.conicTo(SkBits2Float(0x40400000), SkBits2Float(0x443b6c34), SkBits2Float(0x40400000), SkBits2Float(0x44370000), SkBits2Float(0x3f77ac46)); // 3, 749.691f, 3, 732, 0.967472f
4012 path.conicTo(SkBits2Float(0x40400000), SkBits2Float(0x4428c000), SkBits2Float(0x42680000), SkBits2Float(0x4428c000), SkBits2Float(0x3f3504f3)); // 3, 675, 58, 675, 0.707107f
4013 path.close();
4015 SkPath path1(path);
4016 path.reset();
4017 path.setFillType((SkPath::FillType) 0);
4018 path.moveTo(SkBits2Float(0x3f800000), SkBits2Float(0x4428c000)); // 1, 675
4019 path.lineTo(SkBits2Float(0x4c4a3de6), SkBits2Float(0xccca3d89)); // 5.30165e+07f, -1.06032e+08f
4020 path.lineTo(SkBits2Float(0x41a71147), SkBits2Float(0x443b4eec)); // 20.8834f, 749.233f
4021 path.lineTo(SkBits2Float(0x3f800000), SkBits2Float(0x44454000)); // 1, 789
4023 SkPath path2(path);
4028 SkPath path;
4029 path.setFillType(SkPath::kEvenOdd_FillType);
4031 SkPath path1(path);
4032 path.reset();
4033 path.setFillType(SkPath::kWinding_FillType);
4034 path.moveTo(SkBits2Float(0x3f800000), SkBits2Float(0x4428c000)); // 1, 675
4035 path.lineTo(SkBits2Float(0x4c4a3de6), SkBits2Float(0xccca3d89)); // 5.30165e+07f, -1.06032e+08f
4036 path.lineTo(SkBits2Float(0x41a71147), SkBits2Float(0x443b4eec)); // 20.8834f, 749.233f
4037 path.lineTo(SkBits2Float(0x3f800000), SkBits2Float(0x44454000)); // 1, 789
4038 SkPath path2(path);
4043 SkPath path;
4044 path.setFillType(SkPath::kEvenOdd_FillType);
4045 path.moveTo(751, 62);
4046 path.lineTo(497, 62);
4047 path.lineTo(497, 138);
4048 path.lineTo(751, 138);
4049 path.lineTo(751, 62);
4050 path.close();
4051 SkPath path1(path);
4052 path.reset();
4053 path.setFillType(SkPath::kWinding_FillType);
4054 path.moveTo(699.889f, 115.29f);
4055 path.cubicTo(699.889f, 114.913f, 699.627f, 114.723f, 699.111f, 114.723f);
4056 path.cubicTo(698.604f, 114.723f, 697.843f, 114.671f, 697.096f, 114.423f);
4057 path.cubicTo(695.94f, 114.094f, 694.53f, 113.168f, 692.746f, 108.775f);
4058 path.cubicTo(690.469f, 103.12f, 685.644f, 90.563f, 682.761f, 83.061f);
4059 path.lineTo(680.541f, 77.301f);
4060 path.cubicTo(679.927f, 75.721f, 679.67f, 75.261f, 679.151f, 75.261f);
4061 path.cubicTo(678.636f, 75.261f, 678.392f, 75.73f, 677.759f, 77.464f);
4062 path.lineTo(665.868f, 109.881f);
4063 path.cubicTo(664.861f, 112.669f, 663.852f, 114.339f, 661.675f, 114.622f);
4064 path.cubicTo(661.675f, 114.622f, 661.551f, 114.631f, 661.378f, 114.642f);
4065 path.cubicTo(661.072f, 114.597f, 660.75f, 114.531f, 660.427f, 114.424f);
4066 path.cubicTo(659.272f, 114.095f, 657.861f, 113.169f, 656.078f, 108.776f);
4067 path.cubicTo(653.797f, 103.112f, 648.967f, 90.541f, 646.08f, 83.029f);
4068 path.lineTo(643.873f, 77.302f);
4069 path.cubicTo(643.259f, 75.722f, 643.002f, 75.262f, 642.484f, 75.262f);
4070 path.cubicTo(641.968f, 75.262f, 641.724f, 75.731f, 641.092f, 77.465f);
4071 path.lineTo(629.2f, 109.879f);
4072 path.cubicTo(628.193f, 112.667f, 627.184f, 114.337f, 625.007f, 114.62f);
4073 path.cubicTo(625.007f, 114.62f, 624.884f, 114.629f, 624.71f, 114.64f);
4074 path.cubicTo(624.404f, 114.595f, 624.081f, 114.529f, 623.759f, 114.422f);
4075 path.cubicTo(622.603f, 114.093f, 621.193f, 113.167f, 619.409f, 108.774f);
4076 path.cubicTo(617.132f, 103.119f, 612.307f, 90.562f, 609.424f, 83.06f);
4077 path.lineTo(607.204f, 77.3f);
4078 path.cubicTo(606.59f, 75.72f, 606.333f, 75.26f, 605.815f, 75.26f);
4079 path.cubicTo(605.3f, 75.26f, 605.055f, 75.729f, 604.423f, 77.463f);
4080 path.lineTo(592.531f, 109.879f);
4081 path.cubicTo(591.524f, 112.667f, 590.514f, 114.337f, 588.338f, 114.62f);
4082 path.cubicTo(588.337f, 114.62f, 586.852f, 114.722f, 586.852f, 114.722f);
4083 path.cubicTo(586.418f, 114.722f, 586.126f, 114.95f, 586.126f, 115.289f);
4084 path.cubicTo(586.126f, 115.96f, 586.97f, 115.96f, 587.376f, 115.96f);
4085 path.lineTo(592.101f, 115.843f);
4086 path.lineTo(593.295f, 115.804f);
4087 path.lineTo(594.624f, 115.86f);
4088 path.lineTo(597.381f, 115.961f);
4089 path.cubicTo(598.241f, 115.961f, 598.422f, 115.596f, 598.422f, 115.29f);
4090 path.cubicTo(598.422f, 115.078f, 598.321f, 114.723f, 597.643f, 114.723f);
4091 path.lineTo(597.119f, 114.723f);
4092 path.cubicTo(596.448f, 114.723f, 595.383f, 114.381f, 595.383f, 113.463f);
4093 path.cubicTo(595.383f, 112.545f, 595.638f, 111.334f, 596.101f, 110.052f);
4094 path.cubicTo(596.103f, 110.048f, 599.246f, 100.809f, 599.246f, 100.809f);
4095 path.cubicTo(599.337f, 100.583f, 599.435f, 100.564f, 599.528f, 100.564f);
4096 path.lineTo(610.791f, 100.564f);
4097 path.cubicTo(610.929f, 100.564f, 610.958f, 100.585f, 611.035f, 100.737f);
4098 path.cubicTo(611.035f, 100.741f, 615.896f, 113.554f, 615.896f, 113.554f);
4099 path.cubicTo(615.972f, 113.754f, 616.01f, 113.942f, 616.01f, 114.105f);
4100 path.cubicTo(616.01f, 114.228f, 615.988f, 114.338f, 615.945f, 114.429f);
4101 path.cubicTo(615.876f, 114.573f, 615.779f, 114.619f, 615.741f, 114.631f);
4102 path.cubicTo(615.272f, 114.748f, 615.2f, 115.061f, 615.2f, 115.237f);
4103 path.cubicTo(615.2f, 115.766f, 615.792f, 115.796f, 616.772f, 115.844f);
4104 path.lineTo(617.012f, 115.857f);
4105 path.cubicTo(618.978f, 115.913f, 621.359f, 115.948f, 623.835f, 115.958f);
4106 path.cubicTo(623.912f, 115.961f, 623.984f, 115.961f, 624.045f, 115.961f);
4107 path.lineTo(624.118f, 115.959f);
4108 path.cubicTo(624.494f, 115.961f, 624.871f, 115.961f, 625.25f, 115.961f);
4109 path.cubicTo(625.47f, 115.961f, 625.662f, 115.946f, 625.827f, 115.917f);
4110 path.lineTo(628.77f, 115.844f);
4111 path.lineTo(629.965f, 115.805f);
4112 path.lineTo(631.293f, 115.861f);
4113 path.lineTo(634.051f, 115.962f);
4114 path.cubicTo(634.911f, 115.962f, 635.092f, 115.597f, 635.092f, 115.291f);
4115 path.cubicTo(635.092f, 115.079f, 634.991f, 114.724f, 634.313f, 114.724f);
4116 path.lineTo(633.789f, 114.724f);
4117 path.cubicTo(633.118f, 114.724f, 632.053f, 114.382f, 632.053f, 113.464f);
4118 path.cubicTo(632.053f, 112.546f, 632.308f, 111.335f, 632.771f, 110.053f);
4119 path.cubicTo(632.773f, 110.049f, 635.916f, 100.81f, 635.916f, 100.81f);
4120 path.cubicTo(636.007f, 100.584f, 636.105f, 100.565f, 636.198f, 100.565f);
4121 path.lineTo(647.46f, 100.565f);
4122 path.cubicTo(647.598f, 100.565f, 647.627f, 100.586f, 647.704f, 100.737f);
4123 path.cubicTo(647.704f, 100.741f, 652.565f, 113.554f, 652.565f, 113.554f);
4124 path.cubicTo(652.641f, 113.754f, 652.679f, 113.942f, 652.679f, 114.105f);
4125 path.cubicTo(652.679f, 114.228f, 652.657f, 114.338f, 652.613f, 114.43f);
4126 path.cubicTo(652.544f, 114.574f, 652.447f, 114.619f, 652.409f, 114.632f);
4127 path.cubicTo(651.94f, 114.749f, 651.868f, 115.062f, 651.868f, 115.238f);
4128 path.cubicTo(651.868f, 115.767f, 652.46f, 115.797f, 653.44f, 115.845f);
4129 path.lineTo(653.681f, 115.858f);
4130 path.cubicTo(655.647f, 115.914f, 658.028f, 115.949f, 660.503f, 115.959f);
4131 path.cubicTo(660.58f, 115.962f, 660.652f, 115.962f, 660.713f, 115.962f);
4132 path.lineTo(660.787f, 115.96f);
4133 path.cubicTo(661.162f, 115.962f, 661.54f, 115.962f, 661.918f, 115.962f);
4134 path.cubicTo(662.139f, 115.962f, 662.33f, 115.947f, 662.496f, 115.918f);
4135 path.lineTo(665.439f, 115.845f);
4136 path.lineTo(666.633f, 115.806f);
4137 path.lineTo(667.962f, 115.862f);
4138 path.lineTo(670.719f, 115.963f);
4139 path.cubicTo(671.579f, 115.963f, 671.76f, 115.598f, 671.76f, 115.292f);
4140 path.cubicTo(671.76f, 115.08f, 671.659f, 114.725f, 670.981f, 114.725f);
4141 path.lineTo(670.457f, 114.725f);
4142 path.cubicTo(669.786f, 114.725f, 668.721f, 114.383f, 668.721f, 113.465f);
4143 path.cubicTo(668.721f, 112.547f, 668.976f, 111.336f, 669.439f, 110.054f);
4144 path.cubicTo(669.441f, 110.05f, 672.584f, 100.811f, 672.584f, 100.811f);
4145 path.cubicTo(672.675f, 100.585f, 672.773f, 100.566f, 672.866f, 100.566f);
4146 path.lineTo(684.128f, 100.566f);
4147 path.cubicTo(684.266f, 100.566f, 684.295f, 100.587f, 684.372f, 100.739f);
4148 path.cubicTo(684.372f, 100.743f, 689.233f, 113.556f, 689.233f, 113.556f);
4149 path.cubicTo(689.309f, 113.756f, 689.347f, 113.944f, 689.347f, 114.107f);
4150 path.cubicTo(689.347f, 114.23f, 689.325f, 114.34f, 689.281f, 114.431f);
4151 path.cubicTo(689.212f, 114.575f, 689.115f, 114.621f, 689.077f, 114.633f);
4152 path.cubicTo(688.608f, 114.75f, 688.536f, 115.063f, 688.536f, 115.239f);
4153 path.cubicTo(688.536f, 115.768f, 689.128f, 115.798f, 690.108f, 115.846f);
4154 path.lineTo(690.348f, 115.859f);
4155 path.cubicTo(692.687f, 115.926f, 695.611f, 115.963f, 698.586f, 115.963f);
4156 path.cubicTo(699.451f, 115.961f, 699.889f, 115.735f, 699.889f, 115.29f);
4157 path.close();
4158 path.moveTo(600.18f, 98.176f);
4159 path.cubicTo(600.181f, 98.171f, 600.185f, 98.158f, 600.185f, 98.158f);
4160 path.cubicTo(600.191f, 98.142f, 604.801f, 84.049f, 604.801f, 84.049f);
4161 path.cubicTo(604.865f, 83.857f, 604.915f, 83.756f, 604.951f, 83.697f);
4162 path.cubicTo(604.987f, 83.756f, 605.037f, 83.858f, 605.102f, 84.051f);
4163 path.cubicTo(605.103f, 84.054f, 610.08f, 98.149f, 610.08f, 98.149f);
4164 path.cubicTo(610.079f, 98.145f, 610.079f, 98.145f, 610.079f, 98.147f);
4165 path.cubicTo(610.079f, 98.149f, 610.081f, 98.164f, 610.083f, 98.176f);
4166 path.lineTo(600.18f, 98.176f);
4167 path.close();
4168 path.moveTo(636.849f, 98.176f);
4169 path.cubicTo(636.851f, 98.171f, 636.854f, 98.158f, 636.854f, 98.158f);
4170 path.cubicTo(636.859f, 98.142f, 641.469f, 84.049f, 641.469f, 84.049f);
4171 path.cubicTo(641.533f, 83.857f, 641.584f, 83.756f, 641.62f, 83.697f);
4172 path.cubicTo(641.656f, 83.756f, 641.706f, 83.857f, 641.771f, 84.051f);
4173 path.cubicTo(641.773f, 84.054f, 646.749f, 98.149f, 646.749f, 98.149f);
4174 path.cubicTo(646.749f, 98.145f, 646.748f, 98.145f, 646.748f, 98.147f);
4175 path.cubicTo(646.748f, 98.15f, 646.75f, 98.165f, 646.751f, 98.176f);
4176 path.lineTo(636.849f, 98.176f);
4177 path.close();
4178 path.moveTo(673.517f, 98.176f);
4179 path.cubicTo(673.519f, 98.171f, 673.522f, 98.158f, 673.522f, 98.158f);
4180 path.cubicTo(673.528f, 98.142f, 678.138f, 84.049f, 678.138f, 84.049f);
4181 path.cubicTo(678.202f, 83.857f, 678.252f, 83.756f, 678.288f, 83.697f);
4182 path.cubicTo(678.324f, 83.756f, 678.375f, 83.858f, 678.439f, 84.051f);
4183 path.cubicTo(678.44f, 84.054f, 683.417f, 98.149f, 683.417f, 98.149f);
4184 path.cubicTo(683.416f, 98.145f, 683.416f, 98.145f, 683.416f, 98.147f);
4185 path.cubicTo(683.416f, 98.149f, 683.418f, 98.164f, 683.42f, 98.176f);
4186 path.lineTo(673.517f, 98.176f);
4187 path.close();
4188 path.moveTo(702.086f, 115.256f);
4189 path.lineTo(702.089f, 115.257f);
4190 path.cubicTo(704.075f, 116.223f, 706.408f, 116.692f, 709.22f, 116.692f);
4191 path.cubicTo(712.384f, 116.692f, 715.17f, 115.918f, 717.275f, 114.454f);
4192 path.cubicTo(720.639f, 112.074f, 721.837f, 108.31f, 721.837f, 105.581f);
4193 path.cubicTo(721.837f, 101.538f, 720.57f, 98.203f, 714.092f, 93.115f);
4194 path.lineTo(712.625f, 91.966f);
4195 path.cubicTo(707.567f, 87.838f, 706.331f, 86.155f, 706.331f, 83.396f);
4196 path.cubicTo(706.331f, 79.927f, 708.819f, 77.595f, 712.519f, 77.595f);
4197 path.cubicTo(716.925f, 77.595f, 718.41f, 79.437f, 718.843f, 80.229f);
4198 path.cubicTo(719.131f, 80.754f, 719.442f, 82.122f, 719.494f, 82.739f);
4199 path.cubicTo(719.543f, 83.13f, 719.608f, 83.65f, 720.167f, 83.65f);
4200 path.cubicTo(720.789f, 83.65f, 720.789f, 82.704f, 720.789f, 82.195f);
4201 path.cubicTo(720.789f, 79.413f, 720.918f, 77.758f, 720.973f, 77.052f);
4202 path.lineTo(720.998f, 76.662f);
4203 path.cubicTo(720.998f, 76.113f, 720.581f, 76.043f, 720.219f, 76.043f);
4204 path.cubicTo(719.847f, 76.043f, 719.469f, 76.003f, 718.438f, 75.788f);
4205 path.cubicTo(716.936f, 75.428f, 715.369f, 75.26f, 713.514f, 75.26f);
4206 path.cubicTo(706.771f, 75.26f, 702.415f, 79.048f, 702.415f, 84.91f);
4207 path.cubicTo(702.415f, 88.438f, 703.589f, 91.748f, 709.319f, 96.434f);
4208 path.lineTo(711.676f, 98.365f);
4209 path.cubicTo(716.332f, 102.196f, 717.607f, 104.172f, 717.607f, 107.564f);
4210 path.cubicTo(717.607f, 110.888f, 715.121f, 114.253f, 710.371f, 114.253f);
4211 path.cubicTo(708.428f, 114.253f, 703.808f, 113.754f, 702.868f, 109.132f);
4212 path.cubicTo(702.716f, 108.424f, 702.716f, 107.718f, 702.716f, 107.25f);
4213 path.cubicTo(702.716f, 106.94f, 702.716f, 106.422f, 702.094f, 106.422f);
4214 path.cubicTo(701.519f, 106.422f, 701.455f, 107.116f, 701.421f, 107.488f);
4215 path.cubicTo(701.421f, 107.495f, 701.375f, 108.117f, 701.375f, 108.117f);
4216 path.cubicTo(701.293f, 109.171f, 701.158f, 110.933f, 701.158f, 113.044f);
4217 path.cubicTo(701.16f, 114.432f, 701.197f, 114.813f, 702.086f, 115.256f);
4218 path.close();
4219 path.moveTo(501.274f, 129.973f);
4220 path.lineTo(498.058f, 136.963f);
4221 path.lineTo(498.62f, 136.963f);
4222 path.lineTo(499.723f, 134.561f);
4223 path.lineTo(503.124f, 134.561f);
4224 path.lineTo(504.227f, 136.963f);
4225 path.lineTo(504.788f, 136.963f);
4226 path.lineTo(501.571f, 129.973f);
4227 path.lineTo(501.274f, 129.973f);
4228 path.close();
4229 path.moveTo(499.926f, 134.114f);
4230 path.lineTo(501.417f, 130.848f);
4231 path.lineTo(502.918f, 134.114f);
4232 path.lineTo(499.926f, 134.114f);
4233 path.close();
4234 path.moveTo(510.117f, 130.023f);
4235 path.lineTo(507.677f, 130.023f);
4236 path.lineTo(507.677f, 136.963f);
4237 path.lineTo(510.209f, 136.963f);
4238 path.cubicTo(512.966f, 136.963f, 513.916f, 135.101f, 513.916f, 133.493f);
4239 path.cubicTo(513.916f, 131.967f, 513.078f, 130.023f, 510.117f, 130.023f);
4240 path.close();
4241 path.moveTo(510.178f, 136.515f);
4242 path.lineTo(508.217f, 136.515f);
4243 path.lineTo(508.217f, 130.471f);
4244 path.lineTo(510.147f, 130.471f);
4245 path.cubicTo(512.036f, 130.471f, 513.333f, 131.712f, 513.333f, 133.493f);
4246 path.cubicTo(513.333f, 135.447f, 511.853f, 136.515f, 510.178f, 136.515f);
4247 path.close();
4248 path.moveTo(519.105f, 135.894f);
4249 path.lineTo(516.634f, 130.023f);
4250 path.lineTo(516.093f, 130.023f);
4251 path.lineTo(519.024f, 137.034f);
4252 path.lineTo(519.177f, 137.034f);
4253 path.lineTo(522.098f, 130.023f);
4254 path.lineTo(521.557f, 130.023f);
4255 path.lineTo(519.105f, 135.894f);
4256 path.close();
4257 path.moveTo(526.817f, 129.973f);
4258 path.lineTo(523.601f, 136.963f);
4259 path.lineTo(524.162f, 136.963f);
4260 path.lineTo(525.265f, 134.561f);
4261 path.lineTo(528.665f, 134.561f);
4262 path.lineTo(529.768f, 136.963f);
4263 path.lineTo(530.33f, 136.963f);
4264 path.lineTo(527.113f, 129.973f);
4265 path.lineTo(526.817f, 129.973f);
4266 path.close();
4267 path.moveTo(525.469f, 134.114f);
4268 path.lineTo(526.96f, 130.848f);
4269 path.lineTo(528.461f, 134.114f);
4270 path.lineTo(525.469f, 134.114f);
4271 path.close();
4272 path
4273 path.lineTo(533.668f, 130.024f);
4274 path.lineTo(533.208f, 130.024f);
4275 path.lineTo(533.208f, 136.964f);
4276 path.lineTo(533.749f, 136.964f);
4277 path.lineTo(533.749f, 130.899f);
4278 path.lineTo(539.038f, 136.964f);
4279 path.lineTo(539.487f, 136.964f);
4280 path.lineTo(539.487f, 130.024f);
4281 path.lineTo(538.946f, 130.024f);
4282 path.lineTo(538.946f, 136.088f);
4283 path.lineTo(538.947f, 136.088f);
4284 path.close();
4285 path.moveTo(543.41f, 133.503f);
4286 path.cubicTo(543.41f, 131.743f, 544.717f, 130.43f, 546.453f, 130.43f);
4287 path.cubicTo(547.28f, 130.43f, 548.067f, 130.644f, 548.934f, 131.102f);
4288 path.lineTo(548.934f, 130.512f);
4289 path.cubicTo(548.087f, 130.125f, 547.26f, 129.932f, 546.483f, 129.932f);
4290 path.cubicTo(544.574f, 129.932f, 542.828f, 131.377f, 542.828f, 133.503f);
4291 path.cubicTo(542.828f, 135.538f, 544.411f, 137.054f, 546.534f, 137.054f);
4292 path.cubicTo(547.341f, 137.054f, 548.198f, 136.83f, 549.005f, 136.402f);
4293 path.lineTo(549.005f, 135.843f);
4294 path.cubicTo(548.055f, 136.341f, 547.31f, 136.555f, 546.523f, 136.555f);
4295 path.cubicTo(544.707f, 136.556f, 543.41f, 135.294f, 543.41f, 133.503f);
4296 path.close();
4297 path.moveTo(552.079f, 136.963f);
4298 path.lineTo(552.62f, 136.963f);
4299 path.lineTo(552.62f, 130.023f);
4300 path.lineTo(552.079f, 130.023f);
4301 path.lineTo(552.079f, 136.963f);
4302 path.close();
4303 path.moveTo(561.984f, 136.088f);
4304 path.lineTo(556.705f, 130.024f);
4305 path.lineTo(556.245f, 130.024f);
4306 path.lineTo(556.245f, 136.964f);
4307 path.lineTo(556.786f, 136.964f);
4308 path.lineTo(556.786f, 130.899f);
4309 path.lineTo(562.075f, 136.964f);
4310 path.lineTo(562.524f, 136.964f);
4311 path.lineTo(562.524f, 130.024f);
4312 path.lineTo(561.983f, 130.024f);
4313 path.lineTo(561.983f, 136.088f);
4314 path.lineTo(561.984f, 136.088f);
4315 path.close();
4316 path.moveTo(570.122f, 134.257f);
4317 path.lineTo(571.592f, 134.257f);
4318 path.lineTo(571.592f, 136.129f);
4319 path.cubicTo(571.041f, 136.403f, 570.489f, 136.556f, 569.683f, 136.556f);
4320 path.cubicTo(567.488f, 136.556f, 566.456f, 135.05f, 566.456f, 133.493f);
4321 path.cubicTo(566.456f, 131.733f, 567.763f, 130.43f, 569.529f, 130.43f);
4322 path.cubicTo(570.366f, 130.43f, 571.153f, 130.654f, 572, 131.132f);
4323 path.lineTo(572, 130.522f);
4324 path.cubicTo(571.02f, 130.084f, 570.397f, 129.932f, 569.61f, 129.932f);
4325 path.cubicTo(567.455f, 129.932f, 565.873f, 131.438f, 565.873f, 133.473f);
4326 path.cubicTo(565.873f, 135.529f, 567.496f, 137.055f, 569.661f, 137.055f);
4327 path.cubicTo(570.468f, 137.055f, 571.305f, 136.862f, 572.132f, 136.465f);
4328 path.lineTo(572.132f, 133.809f);
4329 path.lineTo(570.121f, 133.809f);
4330 path.lineTo(570.121f, 134.257f);
4331 path.lineTo(570.122f, 134.257f);
4332 path.close();
4333 path.moveTo(580.681f, 131.753f);
4334 path.cubicTo(580.681f, 131.001f, 581.314f, 130.43f, 582.151f, 130.43f);
4335 path.cubicTo(582.631f, 130.43f, 582.998f, 130.552f, 583.713f, 130.959f);
4336 path.lineTo(583.713f, 130.37f);
4337 path.cubicTo(583.172f, 130.075f, 582.641f, 129.933f, 582.099f, 129.933f);
4338 path.cubicTo(580.996f, 129.933f, 580.098f, 130.747f, 580.098f, 131.775f);
4339 path.cubicTo(580.098f, 134.065f, 583.417f, 133.2f, 583.417f, 135.173f);
4340 path.cubicTo(583.417f, 135.956f, 582.774f, 136.557f, 581.947f, 136.557f);
4341 path.cubicTo(581.406f, 136.557f, 580.966f, 136.374f, 580.191f, 135.814f);
4342 path.lineTo(580.191f, 136.445f);
4343 path.cubicTo(580.804f, 136.852f, 581.406f, 137.055f, 581.978f, 137.055f);
4344 path.cubicTo(583.111f, 137.055f, 584, 136.221f, 584, 135.152f);
4345 path.cubicTo(584, 132.72f, 580.681f, 133.605f, 580.681f, 131.753f);
4346 path.close();
4347 path.moveTo(587.543f, 133.503f);
4348 path.cubicTo(587.543f, 131.743f, 588.85f, 130.43f, 590.586f, 130.43f);
4349 path.cubicTo(591.413f, 130.43f, 592.199f, 130.644f, 593.067f, 131.102f);
4350 path.lineTo(593.067f, 130.512f);
4351 path.cubicTo(592.22f, 130.125f, 591.393f, 129.932f, 590.616f, 129.932f);
4352 path.cubicTo(588.707f, 129.932f, 586.96f, 131.377f, 586.96f, 133.503f);
4353 path.cubicTo(586.96f, 135.538f, 588.543f, 137.054f, 590.667f, 137.054f);
4354 path.cubicTo(591.473f, 137.054f, 592.331f, 136.83f, 593.138f, 136.402f);
4355 path.lineTo(593.138f, 135.843f);
4356 path.cubicTo(592.188f, 136.341f, 591.443f, 136.555f, 590.657f, 136.555f);
4357 path.cubicTo(588.84f, 136.556f, 587.543f, 135.294f, 587.543f, 133.503f);
4358 path.close();
4359 path.moveTo(596.212f, 136.963f);
4360 path.lineTo(596.753f, 136.963f);
4361 path.lineTo(596.753f, 130.023f);
4362 path.lineTo(596.212f, 130.023f);
4363 path.lineTo(596.212f, 136.963f);
4364 path.close();
4365 path.moveTo(600.94f, 133.697f);
4366 path.lineTo(604.116f, 133.697f);
4367 path.lineTo(604.116f, 133.25f);
4368 path.lineTo(600.94f, 133.25f);
4369 path.lineTo(600.94f, 130.472f);
4370 path.lineTo(604.198f, 130.472f);
4371 path.lineTo(604.198f, 130.024f);
4372 path.lineTo(600.399f, 130.024f);
4373 path.lineTo(600.399f, 136.964f);
4374 path.lineTo(604.279f, 136.964f);
4375 path.lineTo(604.279f, 136.516f);
4376 path.lineTo(600.94f, 136.516f);
4377 path.lineTo(600.94f, 133.697f);
4378 path.close();
4379 path.moveTo(613.163f, 136.088f);
4380 path.lineTo(607.884f, 130.024f);
4381 path.lineTo(607.424f, 130.024f);
4382 path.lineTo(607.424f, 136.964f);
4383 path.lineTo(607.965f, 136.964f);
4384 path.lineTo(607.965f, 130.899f);
4385 path.lineTo(613.254f, 136.964f);
4386 path.lineTo(613.703f, 136.964f);
4387 path.lineTo(613.703f, 130.024f);
4388 path.lineTo(613.162f, 130.024f);
4389 path.lineTo(613.162f, 136.088f);
4390 path.lineTo(613.163f, 136.088f);
4391 path.close();
4392 path.moveTo(617.625f, 133.503f);
4393 path.cubicTo(617.625f, 131.743f, 618.932f, 130.43f, 620.668f, 130.43f);
4394 path.cubicTo(621.495f, 130.43f, 622.281f, 130.644f, 623.149f, 131.102f);
4395 path.lineTo(623.149f, 130.512f);
4396 path.cubicTo(622.301f, 130.125f, 621.474f, 129.932f, 620.698f, 129.932f);
4397 path.cubicTo(618.789f, 129.932f, 617.042f, 131.377f, 617.042f, 133.503f);
4398 path.cubicTo(617.042f, 135.538f, 618.625f, 137.054f, 620.749f, 137.054f);
4399 path.cubicTo(621.556f, 137.054f, 622.413f, 136.83f, 623.22f, 136.402f);
4400 path.lineTo(623.22f, 135.843f);
4401 path.cubicTo(622.27f, 136.341f, 621.525f, 136.555f, 620.739f, 136.555f);
4402 path.cubicTo(618.922f, 136.556f, 617.625f, 135.294f, 617.625f, 133.503f);
4403 path.close();
4404 path.moveTo(626.856f, 133.697f);
4405 path.lineTo(630.032f, 133.697f);
4406 path.lineTo(630.032f, 133.25f);
4407 path.lineTo(626.856f, 133.25f);
4408 path.lineTo(626.856f, 130.472f);
4409 path.lineTo(630.114f, 130.472f);
4410 path.lineTo(630.114f, 130.024f);
4411 path.lineTo(626.316f, 130.024f);
4412 path.lineTo(626.316f, 136.964f);
4413 path.lineTo(630.196f, 136.964f);
4414 path.lineTo(630.196f, 136.516f);
4415 path.lineTo(626.857f, 136.516f);
4416 path.lineTo(626.857f, 133.697f);
4417 path.lineTo(626.856f, 133.697f);
4418 path.close();
4419 path.moveTo(633.115f, 136.963f);
4420 path.lineTo(633.33f, 136.963f);
4421 path.cubicTo(633.33f, 137.309f, 633.299f, 137.523f, 633.115f, 137.797f);
4422 path.lineTo(633.115f, 138.154f);
4423 path.cubicTo(633.565f, 137.828f, 633.779f, 137.269f, 633.779f, 136.75f);
4424 path.lineTo(633.779f, 135.976f);
4425 path.lineTo(633.115f, 135.976f);
4426 path.lineTo(633.115f, 136.963f);
4427 path.close();
4428 path.moveTo(641.511f, 131.753f);
4429 path.cubicTo(641.511f, 131.001f, 642.144f, 130.43f, 642.981f, 130.43f);
4430 path.cubicTo(643.461f, 130.43f, 643.828f, 130.552f, 644.544f, 130.959f);
4431 path.lineTo(644.544f, 130.37f);
4432 path.cubicTo(644.003f, 130.075f, 643.472f, 129.933f, 642.931f, 129.933f);
4433 path.cubicTo(641.828f, 129.933f, 640.929f, 130.747f, 640.929f, 131.775f);
4434 path.cubicTo(640.929f, 134.065f, 644.247f, 133.2f, 644.247f, 135.173f);
4435 path.cubicTo(644.247f, 135.956f, 643.604f, 136.557f, 642.777f, 136.557f);
4436 path.cubicTo(642.236f, 136.557f, 641.797f, 136.374f, 641.02f, 135.814f);
4437 path.lineTo(641.02f, 136.445f);
4438 path.cubicTo(641.633f, 136.852f, 642.235f, 137.055f, 642.807f, 137.055f);
4439 path.cubicTo(643.941f, 137.055f, 644.829f, 136.221f, 644.829f, 135.152f);
4440 path.cubicTo(644.829f, 132.72f, 641.511f, 133.605f, 641.511f, 131.753f);
4441 path.close();
4442 path.moveTo(648.649f, 133.697f);
4443 path.lineTo(651.824f, 133.697f);
4444 path.lineTo(651.824f, 133.25f);
4445 path.lineTo(648.649f, 133.25f);
4446 path.lineTo(648.649f, 130.472f);
4447 path.lineTo(651.906f, 130.472f);
4448 path.lineTo(651.906f, 130.024f);
4449 path.lineTo(648.107f, 130.024f);
4450 path.lineTo(648.107f, 136.964f);
4451 path.lineTo(651.988f, 136.964f);
4452 path.lineTo(651.988f, 136.516f);
4453 path.lineTo(648.649f, 136.516f);
4454 path.lineTo(648.649f, 133.697f);
4455 path.close();
4456 path.moveTo(657.91f, 133.503f);
4457 path.cubicTo(658.799f, 133.177f, 659.237f, 132.618f, 659.237f, 131.814f);
4458 path.cubicTo(659.237f, 130.888f, 658.635f, 130.023f, 656.929f, 130.023f);
4459 path.lineTo(655.142f, 130.023f);
4460 path.lineTo(655.142f, 136.963f);
4461 path.lineTo(655.683f, 136.963f);
4462 path.lineTo(655.683f, 133.635f);
4463 path.lineTo(656.623f, 133.635f);
4464 path.cubicTo(657.46f, 133.635f, 657.726f, 133.747f, 658.563f, 135.06f);
4465 path.lineTo(659.778f, 136.963f);
4466 path.lineTo(660.411f, 136.963f);
4467 path.lineTo(658.838f, 134.561f);
4468 path.cubicTo(658.513f, 134.073f, 658.237f, 133.676f, 657.91f, 133.503f);
4469 path.close();
4470 path.moveTo(656.838f, 133.188f);
4471 path.lineTo(655.684f, 133.188f);
4472 path.lineTo(655.684f, 130.472f);
4473 path.lineTo(656.817f, 130.472f);
4474 path.cubicTo(658.094f, 130.472f, 658.655f, 131.041f, 658.655f, 131.825f);
4475 path.cubicTo(658.655f, 132.659f, 658.063f, 133.188f, 656.838f, 133.188f);
4476 path.close();
4477 path.moveTo(664.968f, 135.894f);
4478 path.lineTo(662.497f, 130.023f);
4479 path.lineTo(661.956f, 130.023f);
4480 path.lineTo(664.887f, 137.034f);
4481 path.lineTo(665.04f, 137.034f);
4482 path.lineTo(667.961f, 130.023f);
4483 path.lineTo(667.42f, 130.023f);
4484 path.lineTo(664.968f, 135.894f);
4485 path.close();
4486 path.moveTo(670.829f, 136.963f);
4487 path.lineTo(671.37f, 136.963f);
4488 path.lineTo(671.37f, 130.023f);
4489 path.lineTo(670.829f, 130.023f);
4490 path.lineTo(670.829f, 136.963f);
4491 path.close();
4492 path.moveTo(680.734f, 136.088f);
4493 path.lineTo(675.455f, 130.024f);
4494 path.lineTo(674.995f, 130.024f);
4495 path.lineTo(674.995f, 136.964f);
4496 path.lineTo(675.536f, 136.964f);
4497 path.lineTo(675.536f, 130.899f);
4498 path.lineTo(680.826f, 136.964f);
4499 path.lineTo(681.275f, 136.964f);
4500 path.lineTo(681.275f, 130.024f);
4501 path.lineTo(680.733f, 130.024f);
4502 path.lineTo(680.733f, 136.088f);
4503 path.lineTo(680.734f, 136.088f);
4504 path.close();
4505 path.moveTo(688.873f, 134.257f);
4506 path.lineTo(690.343f, 134.257f);
4507 path.lineTo(690.343f, 136.129f);
4508 path.cubicTo(689.791f, 136.403f, 689.24f, 136.556f, 688.433f, 136.556f);
4509 path.cubicTo(686.238f, 136.556f, 685.206f, 135.05f, 685.206f, 133.493f);
4510 path.cubicTo(685.206f, 131.733f, 686.514f, 130.43f, 688.28f, 130.43f);
4511 path.cubicTo(689.117f, 130.43f, 689.903f, 130.654f, 690.751f, 131.132f);
4512 path.lineTo(690.751f, 130.522f);
4513 path.cubicTo(689.771f, 130.084f, 689.148f, 129.932f, 688.362f, 129.932f);
4514 path.cubicTo(686.207f, 129.932f, 684.624f, 131.438f, 684.624f, 133.473f);
4515 path.cubicTo(684.624f, 135.529f, 686.247f, 137.055f, 688.413f, 137.055f);
4516 path.cubicTo(689.219f, 137.055f, 690.057f, 136.862f, 690.884f, 136.465f);
4517 path.lineTo(690.884f, 133.809f);
4518 path.lineTo(688.873f, 133.809f);
4519 path.lineTo(688.873f, 134.257f);
4520 path.close();
4521 path.moveTo(699.432f, 131.753f);
4522 path.cubicTo(699.432f, 131.001f, 700.065f, 130.43f, 700.902f, 130.43f);
4523 path.cubicTo(701.381f, 130.43f, 701.749f, 130.552f, 702.464f, 130.959f);
4524 path.lineTo(702.464f, 130.37f);
4525 path.cubicTo(701.923f, 130.075f, 701.391f, 129.933f, 700.85f, 129.933f);
4526 path.cubicTo(699.747f, 129.933f, 698.849f, 130.747f, 698.849f, 131.775f);
4527 path.cubicTo(698.849f, 134.065f, 702.168f, 133.2f, 702.168f, 135.173f);
4528 path.cubicTo(702.168f, 135.956f, 701.525f, 136.557f, 700.698f, 136.557f);
4529 path.cubicTo(700.156f, 136.557f, 699.718f, 136.374f, 698.941f, 135.814f);
4530 path.lineTo(698.941f, 136.445f);
4531 path.cubicTo(699.553f, 136.852f, 700.156f, 137.055f, 700.728f, 137.055f);
4532 path.cubicTo(701.862f, 137.055f, 702.75f, 136.221f, 702.75f, 135.152f);
4533 path.cubicTo(702.75f, 132.72f, 699.432f, 133.605f, 699.432f, 131.753f);
4534 path.close();
4535 path.moveTo(709.407f, 129.932f);
4536 path.cubicTo(707.345f, 129.932f, 705.731f, 131.499f, 705.731f, 133.493f);
4537 path.cubicTo(705.731f, 135.488f, 707.345f, 137.054f, 709.407f, 137.054f);
4538 path.cubicTo(711.48f, 137.054f, 713.104f, 135.487f, 713.104f, 133.493f);
4539 path.cubicTo(713.104f, 131.499f, 711.481f, 129.932f, 709.407f, 129.932f);
4540 path.close();
4541 path.moveTo(709.428f, 136.556f);
4542 path.cubicTo(707.683f, 136.556f, 706.314f, 135.223f, 706.314f, 133.493f);
4543 path.cubicTo(706.314f, 131.763f, 707.682f, 130.43f, 709.428f, 130.43f);
4544 path.cubicTo(711.175f, 130.43f, 712.523f, 131.763f, 712.523f, 133.493f);
4545 path.cubicTo(712.522f, 135.223f, 711.175f, 136.556f, 709.428f, 136.556f);
4546 path.close();
4547 path.moveTo(716.739f, 133.503f);
4548 path.cubicTo(716.739f, 131.743f, 718.046f, 130.43f, 719.782f, 130.43f);
4549 path.cubicTo(720.609f, 130.43f, 721.395f, 130.644f, 722.264f, 131.102f);
4550 path.lineTo(722.264f, 130.512f);
4551 path.cubicTo(721.416f, 130.125f, 720.589f, 129.932f, 719.813f, 129.932f);
4552 path.cubicTo(717.903f, 129.932f, 716.157f, 131.377f, 716.157f, 133.503f);
4553 path.cubicTo(716.157f, 135.538f, 717.74f, 137.054f, 719.863f, 137.054f);
4554 path.cubicTo(720.67f, 137.054f, 721.528f, 136.83f, 722.335f, 136.402f);
4555 path.lineTo(722.335f, 135.843f);
4556 path.cubicTo(721.385f, 136.341f, 720.64f, 136.555f, 719.854f, 136.555f);
4557 path.cubicTo(718.037f, 136.556f, 716.739f, 135.294f, 716.739f, 133.503f);
4558 path.close();
4559 path.moveTo(725.409f, 136.963f);
4560 path.lineTo(725.95f, 136.963f);
4561 path.lineTo(725.95f, 130.023f);
4562 path.lineTo(725.409f, 130.023f);
4563 path.lineTo(725.409f, 136.963f);
4564 path.close();
4565 path.moveTo(730.136f, 133.697f);
4566 path.lineTo(733.312f, 133.697f);
4567 path.lineTo(733.312f, 133.25f);
4568 path.lineTo(730.136f, 133.25f);
4569 path.lineTo(730.136f, 130.472f);
4570 path.lineTo(733.393f, 130.472f);
4571 path.lineTo(733.393f, 130.024f);
4572 path.lineTo(729.595f, 130.024f);
4573 path.lineTo(729.595f, 136.964f);
4574 path.lineTo(733.475f, 136.964f);
4575 path.lineTo(733.475f, 136.516f);
4576 path.lineTo(730.136f, 136.516f);
4577 path.lineTo(730.136f, 133.697f);
4578 path.close();
4579 path.moveTo(735.865f, 130.472f);
4580 path.lineTo(738.479f, 130.472f);
4581 path.lineTo(738.479f, 136.964f);
4582 path.lineTo(739.02f, 136.964f);
4583 path.lineTo(739.02f, 130.472f);
4584 path.lineTo(741.634f, 130.472f);
4585 path.lineTo(741.634f, 130.024f);
4586 path.lineTo(735.865f, 130.024f);
4587 path.lineTo(735.865f, 130.472f);
4588 path.close();
4589 path.moveTo(749.017f, 130.023f);
4590 path.lineTo(746.699f, 132.771f);
4591 path.lineTo(744.371f, 130.023f);
4592 path.lineTo(743.717f, 130.023f);
4593 path.lineTo(746.423f, 133.239f);
4594 path.lineTo(746.423f, 136.963f);
4595 path.lineTo(746.964f, 136.963f);
4596 path.lineTo(746.964f, 133.239f);
4597 path.lineTo(749.67f, 130.023f);
4598 path.lineTo(749.017f, 130.023f);
4599 path.close();
4600 path.moveTo(578.773f, 115.549f);
4601 path.lineTo(578.773f, 62.773f);
4602 path.lineTo(557.571f, 62.773f);
4603 path.cubicTo(562.752f, 67.658f, 575.797f, 106.652f, 578.773f, 115.549f);
4604 path.close();
4605 path.moveTo(544.754f, 62.861f);
4606 path.lineTo(524.496f, 62.861f);
4607 path.lineTo(524.496f, 115.55f);
4608 path.lineTo(524.934f, 115.55f);
4609 path.lineTo(544.544f, 64.169f);
4610 path.lineTo(528.157f, 115.549f);
4611 path.lineTo(528.682f, 115.549f);
4612 path.lineTo(546.557f, 67.658f);
4613 path.lineTo(531.675f, 115.548f);
4614 path.lineTo(532.376f, 115.548f);
4615 path.lineTo(548.57f, 71.846f);
4616 path.lineTo(535.293f, 115.507f);
4617 path.lineTo(535.906f, 115.507f);
4618 path.lineTo(544.281f, 97.58f);
4619 path.lineTo(542.267f, 97.58f);
4620 path.lineTo(550.409f, 76.033f);
4621 path.lineTo(544.281f, 97.578f);
4622 path.lineTo(546.119f, 97.578f);
4623 path.lineTo(538.678f, 115.551f);
4624 path.lineTo(565.029f, 115.551f);
4625 path.cubicTo(562.052f, 106.477f, 550.759f, 67.92f, 544.754f, 62.861f);
4626 path.close();
4627 SkPath path2(path);
