1/*
2 * Copyright 2012 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7#include "PathOpsExtendedTest.h"
8
9#define TEST(name) { name, #name }
10
11static void skpcheeseandburger_com225(skiatest::Reporter* reporter, const char* filename) {
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();
20    SkPath pathB;
21    pathB.setFillType(SkPath::kWinding_FillType);
22    pathB.moveTo(859.11792f, 397.320343f);
23    pathB.cubicTo(855.523071f, 399.691284f, 853.721191f, 402.40863f, 853.721191f, 405.552216f);
24    pathB.cubicTo(853.721191f, 407.911163f, 854.727478f, 410.115387f, 857.043518f, 412.252716f);
25    pathB.cubicTo(859.920532f, 414.916138f, 862.704773f, 417.086426f, 864.679382f, 418.852386f);
26    pathB.cubicTo(866.382446f, 420.371765f, 867.19104f, 422.108795f, 867.19104f, 423.506378f);
27    pathB.cubicTo(867.19104f, 424.551605f, 866.741821f, 425.539886f, 865.935242f, 426.281616f);
28    pathB.cubicTo(865.250366f, 426.910553f, 864.662415f, 427.339813f, 864.139282f, 427.4646f);
29    pathB.cubicTo(863.536377f, 427.605347f, 862.259521f, 426.491272f, 860.366821f, 424.208191f);
30    pathB.cubicTo(858.345276f, 421.770355f, 857.317017f, 419.733856f, 857.317017f, 417.98587f);
31    pathB.cubicTo(857.317017f, 417.198212f, 857.942993f, 415.930389f, 857.942993f, 415.930389f);
32    pathB.cubicTo(857.942993f, 415.930389f, 852.106018f, 421.296173f, 852.279663f, 422.549042f);
33    pathB.cubicTo(852.462402f, 423.890747f, 853.669312f, 425.703613f, 855.876465f, 428.252258f);
34    pathB.cubicTo(858.038818f, 430.754944f, 859.4953f, 431.840088f, 860.190125f, 431.594513f);
35    pathB.cubicTo(862.571045f, 430.754944f, 865.48999f, 429.237549f, 868.44397f, 427.018372f);
36    pathB.cubicTo(870.505371f, 425.470032f, 871.582581f, 423.534332f, 871.582581f, 421.001678f);
37    pathB.cubicTo(871.582581f, 417.945923f, 870.056213f, 415.171692f, 867.015381f, 412.640045f);
38    pathB.cubicTo(863.683105f, 409.872803f, 861.445923f, 408.027954f, 860.551514f, 407.140503f);
39    pathB.cubicTo(858.660767f, 405.264709f, 857.765259f, 403.50174f, 857.765259f, 402.187988f);
40    pathB.cubicTo(857.765259f, 401.141785f, 858.339355f, 400.394073f, 859.476318f, 399.925873f);
41    pathB.cubicTo(860.004395f, 399.704254f, 861.270264f, 400.515869f, 863.156006f, 402.36969f);
42    pathB.cubicTo(865.094727f, 404.28241f, 866.203796f, 405.565186f, 866.383484f, 406.130219f);
43    pathB.cubicTo(868.250244f, 404.305359f, 869.179688f, 403.397919f, 871.046509f, 401.58902f);
44    pathB.cubicTo(868.26825f, 399.296967f, 864.431824f, 394.705841f, 863.156006f, 394.600037f);
45    pathB.cubicTo(863.145996f, 394.600037f, 863.136108f, 394.59903f, 863.126099f, 394.59903f);
46    pathB.cubicTo(862.352417f, 394.598022f, 859.909607f, 396.79425f, 859.11792f, 397.320343f);
47    pathB.moveTo(832.164246f, 394.307526f);
48    pathB.cubicTo(832.451721f, 394.425323f, 832.598511f, 394.486206f, 832.886963f, 394.605011f);
49    pathB.cubicTo(834.078979f, 395.474518f, 834.674927f, 395.90979f, 835.867859f, 396.781281f);
50    pathB.cubicTo(836.502808f, 397.325348f, 836.863159f, 398.000183f, 836.863159f, 398.964539f);
51    pathB.lineTo(836.863159f, 419.740845f);
52    pathB.cubicTo(836.863159f, 420.876923f, 836.319092f, 422.17868f, 835.055298f, 423.617188f);
53    pathB.cubicTo(836.39502f, 424.512665f, 837.063843f, 424.961884f, 838.39856f, 425.864349f);
54    pathB.cubicTo(839.477661f, 426.578125f, 841.37439f, 427.27594f, 842.275879f, 427.443634f);
55    pathB.cubicTo(842.999634f, 427.574402f, 843.82019f, 427.513519f, 844.354309f, 427.216034f);
56    pathB.cubicTo(846.956787f, 425.765503f, 848.689819f, 423.588257f, 848.58606f, 423.483429f);
57    pathB.cubicTo(848.58606f, 423.483429f, 846.877991f, 423.327698f, 845.971558f, 422.807587f);
58    pathB.cubicTo(845.253784f, 422.284485f, 844.892395f, 422.022949f, 844.171631f, 421.502838f);
59    pathB.cubicTo(843.361023f, 420.915833f, 842.907837f, 420.308899f, 842.907837f, 419.350525f);
60    pathB.lineTo(842.907837f, 399.445709f);
61    pathB.cubicTo(842.907837f, 398.053101f, 843.272217f, 397.417175f, 843.812256f, 397.518005f);
62    pathB.cubicTo(844.170654f, 397.583893f, 844.711731f, 398.122986f, 845.432495f, 398.782837f);
63    pathB.cubicTo(846.116333f, 399.402771f, 846.459717f, 399.709259f, 847.14856f, 400.3302f);
64    pathB.cubicTo(844.986206f, 402.099152f, 843.988892f, 403.926025f, 843.988892f, 405.932556f);
65    pathB.cubicTo(843.988892f, 410.209229f, 848.272583f, 410.951935f, 849.576355f, 408.394348f);
66    pathB.cubicTo(849.871826f, 407.816345f, 850.421875f, 406.214081f, 850.387939f, 406.196106f);
67    pathB.cubicTo(850.387939f, 406.196106f, 849.305786f, 406.771118f, 848.495239f, 406.615387f);
68    pathB.cubicTo(846.96582f, 406.316895f, 846.153198f, 405.46637f, 846.153198f, 403.89505f);
69    pathB.cubicTo(846.153198f, 401.796661f, 848.50116f, 399.09729f, 852.279663f, 396.270142f);
70    pathB.cubicTo(851.014893f, 395.315796f, 847.723511f, 391.546265f, 846.875f, 391.546265f);
71    pathB.cubicTo(846.330933f, 391.546265f, 843.988892f, 394.403351f, 843.273193f, 394.972382f);
72    pathB.cubicTo(840.889282f, 392.886963f, 839.700317f, 391.850739f, 837.312378f, 389.786285f);
73    pathB.cubicTo(835.257935f, 391.589203f, 834.225708f, 392.491638f, 832.164246f, 394.307526f);
74    pathB.moveTo(818.860107f, 392.707275f);
75    pathB.cubicTo(819.857361f, 393.382111f, 822.302124f, 395.764038f, 824.387573f, 397.051819f);
76    pathB.cubicTo(822.57666f, 398.249756f, 820.582092f, 399.687286f, 818.860107f, 400.827332f);
77    pathB.lineTo(818.860107f, 392.707275f);
78    pathB.close();
79    pathB.moveTo(810.69812f, 391.096039f);
80    pathB.cubicTo(810.69812f, 391.096039f, 812.786499f, 394.093903f, 812.786499f, 394.965393f);
81    pathB.lineTo(812.786499f, 415.743713f);
82    pathB.cubicTo(812.786499f, 417.753265f, 811.881042f, 418.497986f, 810.974609f, 419.769806f);
83    pathB.cubicTo(813.948486f, 421.160431f, 815.437988f, 421.864197f, 818.404846f, 423.283783f);
84    pathB.cubicTo(819.948181f, 423.95462f, 822.417969f, 424.592529f, 823.937317f, 423.782928f);
85    pathB.cubicTo(827.905518f, 421.663544f, 831.53125f, 417.600525f, 832.255005f, 415.191681f);
86    pathB.cubicTo(833.882263f, 409.877808f, 823.095825f, 411.495026f, 823.119751f, 411.518982f);
87    pathB.cubicTo(823.119751f, 411.518982f, 832.000488f, 411.874359f, 830.537964f, 416.29776f);
88    pathB.cubicTo(829.888123f, 418.253418f, 827.278564f, 420.292908f, 825.385864f, 419.55719f);
89    pathB.cubicTo(821.14209f, 417.915985f, 818.861023f, 417.414856f, 818.861023f, 414.970032f);
90    pathB.lineTo(818.861023f, 403.096436f);
91    pathB.cubicTo(822.126404f, 399.132233f, 831.289673f, 395.897797f, 831.356567f, 395.657227f);
92    pathB.cubicTo(831.356567f, 395.657227f, 823.022888f, 387.594055f, 821.763062f, 387.476257f);
93    pathB.cubicTo(821.755066f, 387.47525f, 821.746094f, 387.47525f, 821.737061f, 387.47525f);
94    pathB.cubicTo(820.793701f, 387.47525f, 810.72406f, 390.967255f, 810.69812f, 391.096039f);
95    pathB.moveTo(624.254211f, 390.498077f);
96    pathB.cubicTo(625.252502f, 390.893402f, 627.708252f, 392.592468f, 629.796692f, 393.307251f);
97    pathB.cubicTo(627.978821f, 395.006317f, 625.980225f, 397.000916f, 624.254211f, 398.618134f);
98    pathB.lineTo(624.254211f, 390.498077f);
99    pathB.close();
100    pathB.moveTo(627.160217f, 384.460449f);
101    pathB.cubicTo(626.286743f, 384.51535f, 616.076233f, 390.993225f, 616.086243f, 391.141968f);
102    pathB.cubicTo(616.086243f, 391.141968f, 618.173645f, 393.561798f, 618.173645f, 394.437317f);
103    pathB.lineTo(618.173645f, 415.216614f);
104    pathB.cubicTo(618.173645f, 417.222168f, 617.265198f, 418.219482f, 616.355774f, 419.742859f);
105    pathB.cubicTo(619.331665f, 420.307892f, 620.824097f, 420.599396f, 623.802979f, 421.198364f);
106    pathB.cubicTo(625.346313f, 421.437958f, 627.818115f, 421.39801f, 629.342468f, 420.166138f);
107    pathB.cubicTo(633.340576f, 416.939667f, 636.982361f, 411.871368f, 637.714111f, 409.263855f);
108    pathB.cubicTo(639.348267f, 403.500732f, 628.508911f, 408.111816f, 628.52887f, 408.126801f);
109    pathB.cubicTo(628.52887f, 408.126801f, 637.468506f, 405.998444f, 635.985046f, 410.844147f);
110    pathB.cubicTo(635.332153f, 412.984467f, 632.705688f, 415.748718f, 630.801941f, 415.541077f);
111    pathB.cubicTo(626.537292f, 415.072876f, 624.257202f, 415.202667f, 624.257202f, 412.755859f);
112    pathB.cubicTo(624.257202f, 408.007019f, 624.255188f, 405.636078f, 624.255188f, 400.884247f);
113    pathB.cubicTo(627.525574f, 396.016602f, 636.801636f, 390.283447f, 636.801636f, 389.97995f);
114    pathB.cubicTo(636.801636f, 389.97995f, 628.360168f, 384.458435f, 627.18219f, 384.458435f);
115    pathB.cubicTo(627.174194f, 384.460449f, 627.167236f, 384.460449f, 627.160217f, 384.460449f);
116    pathB.moveTo(796.530396f, 416.438538f);
117    pathB.cubicTo(795.892517f, 416.365662f, 794.527832f, 415.589996f, 792.348572f, 414.036652f);
118    pathB.lineTo(792.348572f, 391.425476f);
119    pathB.cubicTo(792.348572f, 390.465118f, 792.530273f, 390.047852f, 792.89563f, 390.088776f);
120    pathB.cubicTo(793.075317f, 390.109741f, 793.3479f, 390.317383f, 793.804077f, 390.629852f);
121    pathB.cubicTo(795.113831f, 391.585205f, 795.768738f, 392.059387f, 797.077515f, 393.018738f);
122    pathB.cubicTo(797.983948f, 393.648651f, 798.348267f, 394.219666f, 798.348267f, 394.742767f);
123    pathB.lineTo(798.348267f, 413.253998f);
124    pathB.cubicTo(798.348267f, 415.391327f, 797.783264f, 416.451508f, 796.728088f, 416.451508f);
125    pathB.cubicTo(796.664185f, 416.4505f, 796.598267f, 416.446533f, 796.530396f, 416.438538f);
126    pathB.moveTo(795.165771f, 383.714722f);
127    pathB.cubicTo(794.022705f, 383.851471f, 783.959961f, 388.652252f, 783.880127f, 388.873871f);
128    pathB.cubicTo(783.880127f, 388.873871f, 785.054077f, 389.871155f, 785.522339f, 390.606873f);
129    pathB.cubicTo(786.000488f, 391.361603f, 786.246094f, 391.9935f, 786.246094f, 392.427765f);
130    pathB.lineTo(786.246094f, 411.987183f);
131    pathB.cubicTo(786.246094f, 413.733185f, 784.160645f, 416.428558f, 784.246521f, 416.759979f);
132    pathB.cubicTo(784.258484f, 416.79892f, 785.432495f, 417.14032f, 785.793823f, 417.350952f);
133    pathB.cubicTo(786.739258f, 417.937958f, 787.213379f, 418.228455f, 788.161804f, 418.821442f);
134    pathB.cubicTo(789.342773f, 419.554199f, 790.619568f, 419.956482f, 791.892395f, 420.098236f);
135    pathB.cubicTo(794.533813f, 420.390747f, 796.717102f, 419.337555f, 798.349304f, 416.999573f);
136    pathB.lineTo(798.349304f, 425.212463f);
137    pathB.cubicTo(797.94696f, 425.47702f, 797.750305f, 425.609772f, 797.356018f, 425.874329f);
138    pathB.cubicTo(795.259583f, 423.619202f, 792.806824f, 422.286499f, 789.985657f, 421.984009f);
139    pathB.cubicTo(785.157959f, 421.463898f, 780.409119f, 428.344086f, 780.423096f, 428.346069f);
140    pathB.cubicTo(780.423096f, 428.346069f, 783.340088f, 424.960907f, 785.889709f, 425.218445f);
141    pathB.cubicTo(789.25592f, 425.565857f, 793.166199f, 430.745972f, 793.805115f, 430.790894f);
142    pathB.cubicTo(793.940857f, 430.798889f, 795.918457f, 429.091797f, 798.454102f, 427.383728f);
143    pathB.cubicTo(801.049683f, 425.635742f, 804.230225f, 423.886749f, 806.619141f, 423.980591f);
144    pathB.cubicTo(805.621826f, 423.586243f, 805.048828f, 423.074127f, 804.804199f, 422.609924f);
145    pathB.cubicTo(804.616577f, 422.25354f, 804.616577f, 421.539764f, 804.616577f, 420.31488f);
146    pathB.cubicTo(804.623535f, 411.732605f, 804.623535f, 403.147339f, 804.623535f, 394.562073f);
147    pathB.cubicTo(804.623535f, 392.464691f, 805.970215f, 391.000183f, 805.984192f, 390.896362f);
148    pathB.cubicTo(805.984192f, 390.896362f, 796.785034f, 383.7117f, 795.219666f, 383.7117f);
149    pathB.cubicTo(795.19873f, 383.712708f, 795.181763f, 383.712708f, 795.165771f, 383.714722f);
150    pathB.moveTo(648.092285f, 387.883545f);
151    pathB.cubicTo(649.095581f, 388.312805f, 651.55835f, 390.099762f, 653.655701f, 390.884399f);
152    pathB.cubicTo(651.831848f, 392.522583f, 649.82428f, 394.447296f, 648.092285f, 396.003601f);
153    pathB.lineTo(648.092285f, 387.883545f);
154    pathB.close();
155    pathB.moveTo(651.009277f, 381.943756f);
156    pathB.cubicTo(650.147766f, 381.983704f, 639.893372f, 388.105164f, 639.899353f, 388.254913f);
157    pathB.cubicTo(639.899353f, 388.254913f, 641.987793f, 390.744659f, 641.987793f, 391.617157f);
158    pathB.lineTo(641.987793f, 412.399475f);
159    pathB.cubicTo(641.987793f, 414.409027f, 641.082336f, 415.369354f, 640.169861f, 416.864807f);
160    pathB.cubicTo(643.155762f, 417.53064f, 644.650208f, 417.87207f, 647.638062f, 418.573853f);
161    pathB.cubicTo(649.188416f, 418.865356f, 651.666138f, 418.908295f, 653.19751f, 417.725311f);
162    pathB.cubicTo(657.204651f, 414.633636f, 660.859375f, 409.690125f, 661.590088f, 407.106567f);
163    pathB.cubicTo(663.231262f, 401.397339f, 652.356934f, 405.644073f, 652.375916f, 405.663025f);
164    pathB.cubicTo(652.375916f, 405.663025f, 661.338562f, 403.835175f, 659.857056f, 408.632935f);
165    pathB.cubicTo(659.199219f, 410.748291f, 656.568726f, 413.424713f, 654.656982f, 413.151184f);
166    pathB.cubicTo(650.381348f, 412.536224f, 648.092285f, 412.591125f, 648.092285f, 410.146332f);
167    pathB.lineTo(648.092285f, 398.270721f);
168    pathB.cubicTo(651.374634f, 393.5159f, 660.66571f, 388.09021f, 660.674683f, 387.791718f);
169    pathB.cubicTo(660.674683f, 387.791718f, 652.188232f, 381.941772f, 651.022278f, 381.942749f);
170    pathB.cubicTo(651.01825f, 381.942749f, 651.013245f, 381.942749f, 651.009277f, 381.943756f);
171    pathB.moveTo(761.636353f, 385.965851f);
172    pathB.cubicTo(761.927856f, 386.056702f, 762.071594f, 386.098633f, 762.363098f, 386.189453f);
173    pathB.cubicTo(763.570007f, 386.938171f, 764.175964f, 387.311554f, 765.376892f, 388.066254f);
174    pathB.cubicTo(766.019775f, 388.546417f, 766.384155f, 389.184326f, 766.384155f, 390.147675f);
175    pathB.lineTo(766.384155f, 410.924011f);
176    pathB.cubicTo(766.384155f, 412.057037f, 765.836121f, 413.410736f, 764.559326f, 414.979034f);
177    pathB.cubicTo(765.911987f, 415.738739f, 766.579834f, 416.12207f, 767.934509f, 416.887756f);
178    pathB.cubicTo(769.029602f, 417.495728f, 770.944336f, 418.000854f, 771.85675f, 418.075714f);
179    pathB.cubicTo(772.58551f, 418.134613f, 773.413086f, 417.987854f, 773.950195f, 417.638458f);
180    pathB.cubicTo(776.583618f, 415.917419f, 778.332642f, 413.564453f, 778.237793f, 413.473633f);
181    pathB.cubicTo(778.237793f, 413.473633f, 776.507812f, 413.497559f, 775.596313f, 413.066315f);
182    pathB.cubicTo(774.866577f, 412.61908f, 774.497253f, 412.39447f, 773.771484f, 411.951233f);
183    pathB.cubicTo(772.947876f, 411.444092f, 772.493652f, 410.877075f, 772.493652f, 409.919708f);
184    pathB.lineTo(772.493652f, 390.013885f);
185    pathB.cubicTo(772.493652f, 388.618286f, 772.860046f, 387.949432f, 773.407104f, 387.995361f);
186    pathB.cubicTo(773.771484f, 388.026306f, 774.318542f, 388.509491f, 775.049316f, 389.09848f);
187    pathB.cubicTo(775.742065f, 389.646515f, 776.088501f, 389.923065f, 776.77533f, 390.470123f);
188    pathB.cubicTo(774.590088f, 392.45871f, 773.589783f, 394.385376f, 773.589783f, 396.395935f);
189    pathB.cubicTo(773.589783f, 400.673584f, 777.907349f, 401.008026f, 779.237122f, 398.292694f);
190    pathB.cubicTo(779.539551f, 397.684723f, 780.089661f, 396.027557f, 780.058716f, 396.01358f);
191    pathB.cubicTo(780.058716f, 396.01358f, 778.970581f, 396.694427f, 778.149963f, 396.618561f);
192    pathB.cubicTo(776.598633f, 396.4758f, 775.775024f, 395.709106f, 775.775024f, 394.13681f);
193    pathB.cubicTo(775.775024f, 392.042419f, 778.149963f, 389.103455f, 781.973389f, 385.892975f);
194    pathB.cubicTo(780.697571f, 385.06839f, 777.326416f, 381.676208f, 776.506775f, 381.719147f);
195    pathB.cubicTo(775.908813f, 381.747101f, 773.588806f, 384.868744f, 772.860046f, 385.506622f);
196    pathB.cubicTo(770.451172f, 383.664795f, 769.248291f, 382.749359f, 766.843384f, 380.929504f);
197    pathB.cubicTo(764.758972f, 382.934052f, 763.716736f, 383.940338f, 761.636353f, 385.965851f);
198    pathB.moveTo(672.996521f, 379.821411f);
199    pathB.cubicTo(672.123047f, 379.891266f, 669.7052f, 382.898132f, 668.887573f, 383.64682f);
200    pathB.cubicTo(665.239868f, 386.999084f, 663.41095f, 390.213562f, 663.41095f, 393.356171f);
201    pathB.cubicTo(663.41095f, 395.715118f, 664.439209f, 397.642792f, 666.785156f, 399.150208f);
202    pathB.cubicTo(669.702148f, 401.02002f, 672.547302f, 402.439575f, 674.545837f, 403.655487f);
203    pathB.cubicTo(676.261902f, 404.697693f, 677.105469f, 406.231049f, 677.105469f, 407.625671f);
204    pathB.cubicTo(677.105469f, 408.671875f, 676.651245f, 409.777954f, 675.825684f, 410.7453f);
205    pathB.cubicTo(675.12384f, 411.569885f, 674.538879f, 412.145905f, 673.997803f, 412.417419f);
206    pathB.cubicTo(673.38385f, 412.724915f, 672.080078f, 411.958221f, 670.166382f, 410.198242f);
207    pathB.cubicTo(668.113892f, 408.319458f, 667.062683f, 406.55249f, 667.062683f, 404.808502f);
208    pathB.cubicTo(667.062683f, 404.020844f, 667.701599f, 402.580322f, 667.701599f, 402.580322f);
209    pathB.cubicTo(667.701599f, 402.580322f, 661.773804f, 409.542358f, 661.951477f, 410.7453f);
210    pathB.cubicTo(662.13916f, 412.037079f, 663.368042f, 413.524536f, 665.60321f, 415.469208f);
211    pathB.cubicTo(667.791443f, 417.368927f, 669.261963f, 418.074738f, 669.983704f, 417.630493f);
212    pathB.cubicTo(672.412537f, 416.138062f, 675.369446f, 413.822021f, 678.385254f, 410.790222f);
213    pathB.cubicTo(680.485657f, 408.677856f, 681.587769f, 406.446686f, 681.587769f, 403.917023f);
214    pathB.cubicTo(681.587769f, 400.859283f, 680.007446f, 398.490356f, 676.923767f, 396.806244f);
215    pathB.cubicTo(673.540588f, 394.957428f, 671.257507f, 393.71756f, 670.351074f, 393.075653f);
216    pathB.cubicTo(668.434326f, 391.71698f, 667.518921f, 390.193604f, 667.518921f, 388.88385f);
217    pathB.cubicTo(667.518921f, 387.837646f, 668.101929f, 386.934204f, 669.25592f, 386.156525f);
218    pathB.cubicTo(669.796997f, 385.788147f, 671.085815f, 386.257355f, 672.997498f, 387.592072f);
219    pathB.cubicTo(674.966125f, 388.968689f, 676.104187f, 389.951019f, 676.284851f, 390.465118f);
220    pathB.cubicTo(678.186584f, 388.130127f, 679.136963f, 386.966125f, 681.035706f, 384.646118f);
221    pathB.cubicTo(678.244507f, 383.133728f, 674.247375f, 379.819397f, 673.044434f, 379.819397f);
222    pathB.cubicTo(673.027466f, 379.819397f, 673.011475f, 379.820404f, 672.996521f, 379.821411f);
223    pathB.moveTo(732.95459f, 384.60318f);
224    pathB.cubicTo(733.246094f, 384.680054f, 733.391846f, 384.720001f, 733.689331f, 384.794861f);
225    pathB.cubicTo(735.072937f, 385.500641f, 735.769714f, 385.856049f, 737.162354f, 386.563812f);
226    pathB.cubicTo(737.891113f, 386.938171f, 738.164612f, 387.642975f, 738.164612f, 388.6073f);
227    pathB.lineTo(738.164612f, 408.510132f);
228    pathB.cubicTo(738.164612f, 410.257141f, 737.709412f, 411.893341f, 736.064209f, 413.416718f);
229    pathB.cubicTo(737.635498f, 414.235321f, 738.419189f, 414.651611f, 739.991455f, 415.475189f);
230    pathB.cubicTo(740.997742f, 416.034241f, 742.186707f, 416.344696f, 743.098145f, 416.379639f);
231    pathB.cubicTo(743.830872f, 416.410583f, 744.476807f, 416.175964f, 745.019836f, 415.851532f);
232    pathB.cubicTo(746.476318f, 414.977051f, 748.58075f, 413.571442f, 749.225647f, 413.079285f);
233    pathB.cubicTo(751.012573f, 414.253296f, 751.907043f, 414.845276f, 753.69696f, 416.028229f);
234    pathB.cubicTo(754.703247f, 416.610229f, 755.706543f, 416.84082f, 756.528076f, 416.892761f);
235    pathB.cubicTo(757.259827f, 416.93866f, 757.996582f, 416.807892f, 758.537659f, 416.494446f);
236    pathB.cubicTo(760.814758f, 415.174713f, 762.185425f, 413.509552f, 762.552734f, 412.830719f);
237    pathB.cubicTo(761.637329f, 412.681976f, 759.633789f, 411.58786f, 759.263428f, 411.387207f);
238    pathB.cubicTo(758.607544f, 410.994873f, 758.279114f, 410.803223f, 757.621216f, 410.413879f);
239    pathB.cubicTo(756.983276f, 410.020538f, 756.616943f, 409.301788f, 756.616943f, 408.343445f);
240    pathB.lineTo(756.616943f, 388.351746f);
241    pathB.cubicTo(756.616943f, 387.387421f, 757.164978f, 386.548859f, 758.627502f, 385.067383f);
242    pathB.cubicTo(755.523804f, 383.05484f, 753.97052f, 382.057556f, 750.862854f, 380.078949f);
243    pathB.cubicTo(749.001038f, 382.112457f, 748.069641f, 383.130707f, 746.207825f, 385.174194f);
244    pathB.cubicTo(746.501343f, 385.292999f, 746.647095f, 385.353912f, 746.939575f, 385.472687f);
245    pathB.cubicTo(747.996765f, 386.183472f, 748.525879f, 386.538879f, 749.587036f, 387.257629f);
246    pathB.cubicTo(750.224915f, 387.724823f, 750.498474f, 388.351746f, 750.498474f, 389.223267f);
247    pathB.lineTo(750.498474f, 407.822327f);
248    pathB.cubicTo(750.498474f, 408.694824f, 750.339722f, 409.955658f, 749.951416f, 410.847137f);
249    pathB.cubicTo(749.550049f, 411.761566f, 749.039978f, 411.585876f, 748.487915f, 411.560913f);
250    pathB.cubicTo(747.393799f, 411.503998f, 746.385498f, 410.53067f, 745.473083f, 410.022552f);
251    pathB.cubicTo(744.760254f, 409.627228f, 744.380981f, 409.013275f, 744.380981f, 407.965088f);
252    pathB.lineTo(744.380981f, 386.840363f);
253    pathB.cubicTo(744.380981f, 385.791138f, 744.833191f, 384.763916f, 745.657776f, 383.839508f);
254    pathB.cubicTo(742.656921f, 382.101501f, 741.161499f, 381.234985f, 738.162659f, 379.525909f);
255    pathB.cubicTo(736.083191f, 381.548431f, 735.039978f, 382.562683f, 732.95459f, 384.60318f);
256    pathB.moveTo(692.546936f, 385.171204f);
257    pathB.cubicTo(693.552246f, 385.667358f, 696.018005f, 387.607025f, 698.122375f, 388.521454f);
258    pathB.cubicTo(696.293518f, 390.043854f, 694.281982f, 391.844757f, 692.546936f, 393.294281f);
259    pathB.lineTo(692.546936f, 385.171204f);
260    pathB.close();
261    pathB.moveTo(695.4729f, 379.417084f);
262    pathB.cubicTo(694.635376f, 379.426086f, 684.32605f, 384.880707f, 684.322083f, 385.025452f);
263    pathB.cubicTo(684.322083f, 385.025452f, 686.422485f, 387.645966f, 686.422485f, 388.521454f);
264    pathB.lineTo(686.422485f, 409.300781f);
265    pathB.cubicTo(686.422485f, 411.312347f, 685.51001f, 412.21579f, 684.595581f, 413.65033f);
266    pathB.cubicTo(687.592468f, 414.504852f, 689.089905f, 414.945099f, 692.088745f, 415.833557f);
267    pathB.cubicTo(693.645081f, 416.221893f, 696.128784f, 416.420563f, 697.667114f, 415.334412f);
268    pathB.cubicTo(701.67926f, 412.494293f, 705.344971f, 407.783386f, 706.077698f, 405.240753f);
269    pathB.cubicTo(707.721924f, 399.638367f, 696.822632f, 403.198273f, 696.845581f, 403.216248f);
270    pathB.cubicTo(696.845581f, 403.216248f, 705.825134f, 401.960388f, 704.337708f, 406.658325f);
271    pathB.cubicTo(703.683838f, 408.733765f, 701.044373f, 411.241455f, 699.129639f, 410.847137f);
272    pathB.cubicTo(694.843018f, 409.968628f, 692.545959f, 409.876801f, 692.545959f, 407.432983f);
273    pathB.lineTo(692.545959f, 395.563354f);
274    pathB.cubicTo(695.838318f, 391.012177f, 705.134338f, 386.160522f, 705.162292f, 385.873993f);
275    pathB.cubicTo(705.162292f, 385.873993f, 696.635925f, 379.416107f, 695.473938f, 379.417084f);
276    pathB.cubicTo(695.474915f, 379.417084f, 695.473938f, 379.417084f, 695.4729f, 379.417084f);
277    pathB.moveTo(570.463562f, 420.81601f);
278    pathB.lineTo(570.463562f, 402.922729f);
279    pathB.cubicTo(571.039551f, 402.800934f, 571.327087f, 402.743042f, 571.901123f, 402.625244f);
280    pathB.lineTo(571.901123f, 423.142029f);
281    pathB.cubicTo(570.911804f, 422.823578f, 570.463562f, 422.123779f, 570.463562f, 420.81601f);
282    pathB.moveTo(570.463562f, 384.062134f);
283    pathB.cubicTo(571.039551f, 384.149963f, 571.327087f, 384.198883f, 571.901123f, 384.290741f);
284    pathB.lineTo(571.901123f, 401.580048f);
285    pathB.cubicTo(571.327087f, 401.695862f, 571.039551f, 401.756744f, 570.463562f, 401.874542f);
286    pathB.lineTo(570.463562f, 384.062134f);
287    pathB.close();
288    pathB.moveTo(573.880676f, 376.556f);
289    pathB.cubicTo(572.483093f, 376.996246f, 561.476013f, 385.624451f, 561.482971f, 385.70929f);
290    pathB.cubicTo(561.482971f, 385.70929f, 563.637268f, 388.554413f, 563.637268f, 389.688446f);
291    pathB.lineTo(563.637268f, 398.423462f);
292    pathB.cubicTo(556.411682f, 399.838043f, 555.429382f, 404.307373f, 555.418396f, 405.679993f);
293    pathB.lineTo(555.418396f, 405.724915f);
294    pathB.cubicTo(555.42041f, 405.94455f, 555.448364f, 406.073334f, 555.477295f, 406.083313f);
295    pathB.cubicTo(555.477295f, 406.083313f, 558.070862f, 404.250458f, 563.637268f, 403.222229f);
296    pathB.lineTo(563.637268f, 404.797516f);
297    pathB.cubicTo(556.993713f, 406.233063f, 555.191772f, 412.494293f, 555.569153f, 412.614105f);
298    pathB.cubicTo(555.569153f, 412.614105f, 561.572815f, 410.21521f, 563.637268f, 409.598267f);
299    pathB.lineTo(563.637268f, 424.00354f);
300    pathB.cubicTo(563.637268f, 426.357483f, 563.36676f, 427.901855f, 562.291565f, 429.70874f);
301    pathB.cubicTo(565.448181f, 430.067139f, 567.028442f, 430.256805f, 570.192017f, 430.653137f);
302    pathB.cubicTo(571.99292f, 430.893707f, 574.782166f, 430.669098f, 576.403381f, 429.136719f);
303    pathB.cubicTo(580.960571f, 424.828125f, 586.135681f, 419.346527f, 586.135681f, 416.115082f);
304    pathB.lineTo(586.135681f, 406.511566f);
305    pathB.cubicTo(586.135681f, 405.377533f, 586.047791f, 404.608856f, 586.678711f, 403.271149f);
306    pathB.cubicTo(584.151062f, 404.98819f, 582.888245f, 405.851715f, 580.362549f, 407.587738f);
307    pathB.cubicTo(579.281433f, 408.320465f, 579.192566f, 409.2948f, 579.192566f, 410.955933f);
308    pathB.lineTo(579.192566f, 421.869202f);
309    pathB.cubicTo(579.192566f, 423.180969f, 577.746033f, 423.273804f, 577.392639f, 423.266815f);
310    pathB.cubicTo(575.636658f, 423.228882f, 574.153259f, 423.295776f, 573.071106f, 423.077148f);
311    pathB.lineTo(573.071106f, 384.663086f);
312    pathB.cubicTo(575.230408f, 385.379852f, 576.309509f, 385.742249f, 578.473816f, 386.473999f);
313    pathB.cubicTo(579.373291f, 386.996094f, 579.553955f, 387.490234f, 579.553955f, 388.013336f);
314    pathB.cubicTo(581.861023f, 384.848785f, 583.015991f, 383.267487f, 585.325073f, 380.114899f);
315    pathB.cubicTo(581.680298f, 379.229431f, 575.865295f, 376.520081f, 574.157227f, 376.521057f);
316    pathB.cubicTo(574.047424f, 376.522064f, 573.955566f, 376.533051f, 573.880676f, 376.556f);
317    pathB.moveTo(593.447083f, 375.096527f);
318    pathB.cubicTo(592.363953f, 375.804291f, 591.821899f, 376.772644f, 591.821899f, 377.908691f);
319    pathB.lineTo(591.821899f, 419.46933f);
320    pathB.cubicTo(591.821899f, 420.517517f, 591.187012f, 422.018951f, 589.921143f, 423.991577f);
321    pathB.cubicTo(591.2948f, 424.412842f, 591.982605f, 424.622467f, 593.354248f, 425.050751f);
322    pathB.cubicTo(594.53125f, 425.462036f, 595.525513f, 425.555878f, 596.427979f, 425.404144f);
323    pathB.cubicTo(597.150757f, 425.279358f, 597.785645f, 424.914978f, 598.326721f, 424.475739f);
324    pathB.cubicTo(600.935242f, 422.385315f, 602.846985f, 419.809753f, 602.759094f, 419.749847f);
325    pathB.cubicTo(602.759094f, 419.749847f, 601.582153f, 419.935516f, 600.59082f, 419.831696f);
326    pathB.cubicTo(600.0448f, 419.74585f, 599.774231f, 419.700928f, 599.233154f, 419.615082f);
327    pathB.cubicTo(598.416565f, 419.484314f, 597.965332f, 418.860382f, 597.965332f, 417.988861f);
328    pathB.lineTo(597.965332f, 396.857147f);
329    pathB.cubicTo(597.965332f, 395.376678f, 598.326721f, 394.617004f, 598.867798f, 394.528137f);
330    pathB.cubicTo(599.232178f, 394.466248f, 599.773254f, 394.731812f, 600.59082f, 395.124115f);
331    pathB.cubicTo(601.601074f, 395.589325f, 602.111206f, 395.819946f, 603.123474f, 396.288116f);
332    pathB.cubicTo(603.93811f, 396.686432f, 603.93512f, 397.38324f, 603.93512f, 398.169891f);
333    pathB.cubicTo(603.93512f, 405.971497f, 603.93512f, 413.768127f, 603.93811f, 421.569702f);
334    pathB.cubicTo(603.93811f, 425.325256f, 601.109924f, 430.634155f, 601.133911f, 430.656128f);
335    pathB.cubicTo(601.133911f, 430.656128f, 605.184937f, 427.222015f, 607.017822f, 424.414825f);
336    pathB.cubicTo(609.118164f, 421.201355f, 610.280212f, 417.987854f, 610.280212f, 415.109802f);
337    pathB.lineTo(610.280212f, 394.593048f);
338    pathB.cubicTo(610.280212f, 393.890228f, 610.823242f, 393.112579f, 611.728699f, 392.020447f);
339    pathB.cubicTo(608.827698f, 390.960266f, 604.000977f, 387.703857f, 602.759094f, 387.967407f);
340    pathB.cubicTo(602.120239f, 388.104187f, 599.957947f, 391.29071f, 597.965332f, 393.27829f);
341    pathB.lineTo(597.965332f, 374.422668f);
342    pathB.cubicTo(597.965332f, 373.461334f, 598.326721f, 372.440063f, 598.867798f, 371.567566f);
343    pathB.cubicTo(596.701538f, 372.96817f, 595.616394f, 373.677948f, 593.447083f, 375.096527f);
344    pathB.moveTo(718.054138f, 409.318756f);
345    pathB.cubicTo(717.461182f, 408.789673f, 716.867188f, 408.178711f, 716.867188f, 407.218353f);
346    pathB.lineTo(716.867188f, 387.053986f);
347    pathB.cubicTo(716.867188f, 385.305969f, 717.323425f, 385.566528f, 718.328674f, 386.013763f);
348    pathB.cubicTo(719.645386f, 386.859314f, 720.307251f, 387.284576f, 721.622009f, 388.135132f);
349    pathB.cubicTo(722.266907f, 388.4935f, 722.903809f, 388.934753f, 722.903809f, 389.721405f);
350    pathB.lineTo(722.903809f, 407.794373f);
351    pathB.cubicTo(722.903809f, 408.66687f, 722.746094f, 410.490753f, 722.259888f, 410.758301f);
352    pathB.cubicTo(722.125122f, 410.83017f, 721.950439f, 410.862122f, 721.746826f, 410.862122f);
353    pathB.cubicTo(720.655701f, 410.864105f, 718.747925f, 409.936707f, 718.054138f, 409.318756f);
354    pathB.moveTo(711.928711f, 364.782227f);
355    pathB.cubicTo(711.195923f, 365.134613f, 710.648865f, 365.834412f, 710.648865f, 366.794769f);
356    pathB.lineTo(710.648865f, 407.392059f);
357    pathB.cubicTo(710.648865f, 409.397614f, 708.519531f, 411.37323f, 708.547485f, 411.684692f);
358    pathB.cubicTo(708.550476f, 411.745605f, 711.838867f, 413.067322f, 713.849365f, 414.368073f);
359    pathB.cubicTo(717.766663f, 416.906738f, 720.162537f, 415.845551f, 722.354797f, 414.073608f);
360    pathB.cubicTo(724.059875f, 412.69397f, 726.55957f, 410.981903f, 730.675537f, 410.124359f);
361    pathB.cubicTo(729.75708f, 409.143066f, 729.213013f, 407.993042f, 729.213013f, 406.683289f);
362    pathB.cubicTo(729.213013f, 399.630402f, 729.209045f, 396.103455f, 729.209045f, 389.047546f);
363    pathB.cubicTo(729.209045f, 387.648956f, 730.577698f, 385.292023f, 730.583679f, 385.149261f);
364    pathB.cubicTo(730.583679f, 385.149261f, 720.888306f, 378.762207f, 719.609497f, 378.947906f);
365    pathB.cubicTo(719.275085f, 378.996826f, 717.872498f, 381.118164f, 716.868225f, 381.896851f);
366    pathB.lineTo(716.868225f, 365.046783f);
367    pathB.cubicTo(716.868225f, 363.740021f, 716.960083f, 363.043213f, 717.597961f, 362);
368    pathB.cubicTo(715.331848f, 363.104095f, 714.19873f, 363.657166f, 711.928711f, 364.782227f);
369    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
370}
371
372static void skpeverytechpro_blogspot_com100(skiatest::Reporter* reporter, const char* 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();
397    SkPath pathB;
398    pathB.setFillType(SkPath::kWinding_FillType);
399    pathB.moveTo(1074, 627);
400    pathB.lineTo(1075, 628);
401    pathB.lineTo(1116.5f, 644.5f);
402    pathB.lineTo(1134, 627);
403    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
404}
405
406static void skpflite_com41(skiatest::Reporter* reporter, const char* 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();
419    SkPath pathB;
420    pathB.setFillType(SkPath::kWinding_FillType);
421    pathB.moveTo(302.849854f, 421.599762f);
422    pathB.lineTo(311.510101f, 426.599762f);
423    pathB.lineTo(304.510101f, 438.724121f);
424    pathB.lineTo(295.849854f, 433.724121f);
425    pathB.close();
426    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
427}
428
429static void skpilkoora_com37(skiatest::Reporter* reporter, const char* 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();
452    SkPath pathB;
453    pathB.setFillType(SkPath::kWinding_FillType);
454    pathB.moveTo(1185, 142);
455    pathB.lineTo(1001.5f, 325.5f);
456    pathB.lineTo(1001.5f, 782.5f);
457    pathB.lineTo(1185, 966);
458    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
459}
460
461static void skpmm4everfriends_com43(skiatest::Reporter* reporter, const char* 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();
474    SkPath pathB;
475    pathB.setFillType(SkPath::kWinding_FillType);
476    pathB.moveTo(541.015381f, 214.960388f);
477    pathB.lineTo(582.17041f, 227.420883f);
478    pathB.lineTo(576.435852f, 247.626068f);
479    pathB.lineTo(535.280823f, 235.165573f);
480    pathB.close();
481    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
482}
483
484static void skpmtrk_uz27(skiatest::Reporter* reporter, const char* 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();
497    SkPath pathB;
498    pathB.setFillType(SkPath::kWinding_FillType);
499    pathB.moveTo(33, 412);
500    pathB.lineTo(1233, 412);
501    pathB.lineTo(1233, 787);
502    pathB.quadTo(1233, 793.213196f, 1228.60791f, 797.608032f);
503    pathB.quadTo(1224.21313f, 802, 1218, 802);
504    pathB.lineTo(48, 802);
505    pathB.quadTo(41.7867432f, 802, 37.3919678f, 797.608032f);
506    pathB.quadTo(33, 793.213196f, 33, 787);
507    pathB.close();
508    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
509}
510
511static void skpfrauen_magazin_com83(skiatest::Reporter* reporter, const char* 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();
520    SkPath pathB;
521    pathB.setFillType(SkPath::kInverseWinding_FillType);
522    pathB.moveTo(808, 886);
523    pathB.lineTo(1118, 886);
524    pathB.cubicTo(1120.76147f, 886, 1123, 888.238586f, 1123, 891);
525    pathB.lineTo(1123, 1521);
526    pathB.cubicTo(1123, 1523.20911f, 1120.76147f, 1525, 1118, 1525);
527    pathB.lineTo(808, 1525);
528    pathB.cubicTo(805.238586f, 1525, 803, 1523.20911f, 803, 1521);
529    pathB.lineTo(803, 891);
530    pathB.cubicTo(803, 888.238586f, 805.238586f, 886, 808, 886);
531    pathB.close();
532    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
533}
534
535static void skpi_gino_com16(skiatest::Reporter* reporter, const char* 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();
547    SkPath pathB;
548    pathB.setFillType(SkPath::kWinding_FillType);
549    pathB.moveTo(185, 734);
550    pathB.cubicTo(252.93103f, 734, 308, 789.06897f, 308, 857);
551    pathB.cubicTo(308, 924.93103f, 252.93103f, 980, 185, 980);
552    pathB.lineTo(184, 980);
553    pathB.cubicTo(116.068977f, 980, 61, 924.93103f, 61, 857);
554    pathB.cubicTo(61, 789.06897f, 116.068977f, 734, 184, 734);
555    pathB.lineTo(185, 734);
556    pathB.close();
557    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
558}
559
560static void skppchappy_com_au102(skiatest::Reporter* reporter, const char* 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();
573    SkPath pathB;
574    pathB.setFillType(SkPath::kInverseWinding_FillType);
575    pathB.moveTo(362, 494);
576    pathB.lineTo(623, 494);
577    pathB.cubicTo(624.65686f, 494, 626, 494.895416f, 626, 496);
578    pathB.lineTo(626, 657);
579    pathB.cubicTo(626, 658.65686f, 624.65686f, 660, 623, 660);
580    pathB.lineTo(362, 660);
581    pathB.cubicTo(360.34314f, 660, 359, 658.65686f, 359, 657);
582    pathB.lineTo(359, 496);
583    pathB.cubicTo(359, 494.895416f, 360.34314f, 494, 362, 494);
584    pathB.close();
585    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
586}
587
588static void skpsciality_com161(skiatest::Reporter* reporter, const char* 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();
601    SkPath pathB;
602    pathB.setFillType(SkPath::kInverseWinding_FillType);
603    pathB.moveTo(655, 729);
604    pathB.lineTo(769, 729);
605    pathB.cubicTo(770.65686f, 729, 772, 729.895447f, 772, 731);
606    pathB.lineTo(772, 790);
607    pathB.cubicTo(772, 791.65686f, 770.65686f, 793, 769, 793);
608    pathB.lineTo(655, 793);
609    pathB.cubicTo(653.34314f, 793, 652, 791.65686f, 652, 790);
610    pathB.lineTo(652, 731);
611    pathB.cubicTo(652, 729.895447f, 653.34314f, 729, 655, 729);
612    pathB.close();
613    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
614}
615
616static void skpsudoestenegocios_com186(skiatest::Reporter* reporter, const char* 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();
637    SkPath pathB;
638    pathB.setFillType(SkPath::kWinding_FillType);
639    pathB.moveTo(48, 495);
640    pathB.lineTo(24, 471);
641    pathB.lineTo(24, 317);
642    pathB.lineTo(48, 293);
643    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
644}
645
646static void skpthesuburbanite_com213(skiatest::Reporter* reporter, const char* 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();
657    SkPath pathB;
658    pathB.setFillType(SkPath::kWinding_FillType);
659    pathB.moveTo(783.256775f, 713.443054f);
660    pathB.lineTo(863.428589f, 691.96106f);
661    pathB.lineTo(866.016724f, 701.620361f);
662    pathB.lineTo(785.84491f, 723.102356f);
663    pathB.close();
664    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
665}
666
667static void skphostloco_com11(skiatest::Reporter* reporter, const char* 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();
680    SkPath pathB;
681    pathB.setFillType(SkPath::kWinding_FillType);
682    pathB.moveTo(0, 463);
683    pathB.lineTo(30, 463);
684    pathB.lineTo(30, 648);
685    pathB.lineTo(0, 648);
686    pathB.close();
687    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
688}
689
690static void skpsergeychunkevich_com8(skiatest::Reporter* reporter, const char* 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();
699    SkPath pathB;
700    pathB.setFillType(SkPath::kInverseWinding_FillType);
701    pathB.moveTo(37, 374);
702    pathB.lineTo(37, 535);
703    pathB.cubicTo(37, 536.65686f, 35.6568565f, 538, 34, 538);
704    pathB.lineTo(1.02866934e-14f, 538);
705    pathB.lineTo(6.12303177e-17f, 371);
706    pathB.lineTo(34, 371);
707    pathB.cubicTo(35.6568565f, 371, 37, 372.34314f, 37, 374);
708    pathB.close();
709    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
710}
711
712static void skptracksflow_com9(skiatest::Reporter* reporter, const char* 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();
721    SkPath pathB;
722    pathB.setFillType(SkPath::kEvenOdd_FillType);
723    pathB.moveTo(31.65625f, 70.0555649f);
724    pathB.lineTo(31.65625f, 70.0554962f);
725    pathB.lineTo(26.9727192f, 65.3615341f);
726    pathB.cubicTo(27.6210003f, 64.4029694f, 28.0048752f, 63.2470932f, 28.0048752f, 62.0027809f);
727    pathB.cubicTo(28.0048752f, 58.6875305f, 25.3199062f, 56, 22.0046558f, 56);
728    pathB.cubicTo(18.6894073f, 56, 16.0031872f, 58.6875305f, 16.0031872f, 62.0027809f);
729    pathB.cubicTo(16.0031872f, 65.3180008f, 18.6913433f, 68.0055618f, 22.0066261f, 68.0055618f);
730    pathB.cubicTo(23.2509995f, 68.0055618f, 24.4072189f, 67.6187515f, 25.3657818f, 66.9704056f);
731    pathB.lineTo(30.0599365f, 71.65625f);
732    pathB.lineTo(30.0600014f, 71.65625f);
733    pathB.cubicTo(30.2668133f, 71.875f, 30.5524693f, 71.9992828f, 30.868f, 71.9992828f);
734    pathB.cubicTo(31.4994049f, 71.9992828f, 32.0014687f, 71.4909363f, 32.0014687f, 70.8595276f);
735    pathB.cubicTo(32.0015335f, 70.5439072f, 31.875f, 70.2623444f, 31.65625f, 70.0555649f);
736    pathB.close();
737    pathB.moveTo(18.0054054f, 62.0027809f);
738    pathB.cubicTo(18.0054054f, 59.7925949f, 19.7970943f, 58.0009079f, 22.0072823f, 58.0009079f);
739    pathB.cubicTo(24.2174377f, 58.0009079f, 26.0091248f, 59.7925949f, 26.0091248f, 62.0027809f);
740    pathB.cubicTo(26.0091248f, 64.2129364f, 24.2174377f, 66.0046234f, 22.0072803f, 66.0046234f);
741    pathB.cubicTo(19.7970943f, 66.0045929f, 18.0054054f, 64.2129059f, 18.0054054f, 62.0027809f);
742    pathB.close();
743    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
744}
745
746static void skpautobutler_dk29(skiatest::Reporter* reporter, const char* 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();
755    SkPath pathB;
756    pathB.setFillType(SkPath::kWinding_FillType);
757    pathB.moveTo(21, 162);
758    pathB.lineTo(21, 301);
759    pathB.lineTo(8.57224448e-15f, 301);
760    pathB.lineTo(6.12303177e-17f, 162);
761    pathB.close();
762    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
763}
764
765static void skponlinecollege_org144(skiatest::Reporter* reporter, const char* 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();
778    SkPath pathB;
779    pathB.setFillType(SkPath::kInverseWinding_FillType);
780    pathB.moveTo(179, 408);
781    pathB.lineTo(337, 408);
782    pathB.cubicTo(338.65686f, 408, 340, 408.895416f, 340, 410);
783    pathB.lineTo(340, 436);
784    pathB.cubicTo(340, 437.65686f, 338.65686f, 439, 337, 439);
785    pathB.lineTo(179, 439);
786    pathB.cubicTo(177.895432f, 439, 177, 437.65686f, 177, 436);
787    pathB.lineTo(177, 410);
788    pathB.cubicTo(177, 408.895416f, 177.895432f, 408, 179, 408);
789    pathB.close();
790    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
791}
792
793static void skpnational_com_au81(skiatest::Reporter* reporter, const char* 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();
806    SkPath pathB;
807    pathB.setFillType(SkPath::kInverseWinding_FillType);
808    pathB.moveTo(807, 817);
809    pathB.lineTo(1110, 817);
810    pathB.cubicTo(1110.55225f, 817, 1111, 817.447693f, 1111, 818);
811    pathB.lineTo(1111, 880);
812    pathB.lineTo(806, 880);
813    pathB.lineTo(806, 818);
814    pathB.cubicTo(806, 817.447693f, 806.447693f, 817, 807, 817);
815    pathB.close();
816    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
817}
818
819static void skprentacheat_com30(skiatest::Reporter* reporter, const char* 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();
832    SkPath pathB;
833    pathB.setFillType(SkPath::kInverseWinding_FillType);
834    pathB.moveTo(967, 263);
835    pathB.lineTo(1213, 263);
836    pathB.cubicTo(1213.55225f, 263, 1214, 263.447723f, 1214, 264);
837    pathB.lineTo(1214, 300);
838    pathB.lineTo(966, 300);
839    pathB.lineTo(966, 264);
840    pathB.cubicTo(966, 263.447723f, 966.447693f, 263, 967, 263);
841    pathB.close();
842    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
843}
844
845static void skpbreakmystyle_com10(skiatest::Reporter* reporter, const char* filename) {
846    SkPath 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();
859    SkPath pathB;
860    pathB.setFillType(SkPath::kWinding_FillType);
861    pathB.moveTo(327, 123);
862    pathB.quadTo(327, 190.516815f, 279.258392f, 238.258392f);
863    pathB.quadTo(231.516815f, 286, 164, 286);
864    pathB.quadTo(96.4831848f, 286, 48.7416f, 238.258392f);
865    pathB.quadTo(1, 190.516815f, 1, 123);
866    pathB.quadTo(1, 55.4831848f, 48.7416f, 7.74160004f);
867    pathB.quadTo(96.4831848f, -40, 164, -40);
868    pathB.quadTo(231.516815f, -40, 279.258392f, 7.74160004f);
869    pathB.quadTo(327, 55.4831848f, 327, 123);
870    pathB.close();
871    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
872}
873
874static void skpsd_graphic_net104(skiatest::Reporter* reporter, const char* 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();
890    SkPath pathB;
891    pathB.setFillType(SkPath::kWinding_FillType);
892    pathB.moveTo(405.592621f, 909.435547f);
893    pathB.lineTo(390.578583f, 867.014099f);
894    pathB.lineTo(433, 852.000061f);
895    pathB.lineTo(490.435486f, 879.40741f);
896    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
897}
898
899/* this cubic/quad pair
900 c = 430,280 430,278.895416 473.876068,278 528,278
901 q = 430,280 430.009796,277.101196 458.703552,275.050262
902 only intersect at the shared point (430,280)
903 they sort backwards because the tangent from pt[0] to control pt[1]
904 c' = (0.00000000000000000, -1.1045837402343750)
905 q' = (0.0097961425781250000, -2.8988037109375000)
906 suggests that the quad is counterclockwise of the cubic, when the reverse is true
907 the angle code is fooled because the control pt[1] of both the quad and cubic
908 is far away from cubic cntl [2] and quad pt [2].
909 Maybe in angle setup, this instability can be detected to suppress sorting on the initial tangent
910 Or the error term can be passed to NearRay that is magnified by the distance from the next ctrl?
911 */
912static void skpnaoxrane_ru23(skiatest::Reporter* reporter, const char* filename) {
913    SkPath path;
914    path.setFillType(SkPath::kEvenOdd_FillType);
915    path.moveTo(458.703552f, 275.050262f);
916    path.quadTo(487.41687f, 273.000702f, 528, 273);
917    path.lineTo(529, 273);
918    path.quadTo(530.242371f, 273.000305f, 531.121338f, 273.878693f);
919    path.quadTo(531.999695f, 274.75766f, 532, 276);
920    path.lineTo(532, 378);
921    path.quadTo(531.990173f, 380.898804f, 503.296448f, 382.949738f);
922    path.quadTo(474.58313f, 384.999298f, 434, 385);
923    path.lineTo(433, 385);
924    path.quadTo(431.75766f, 384.999695f, 430.878693f, 384.121307f);
925    path.quadTo(430.000305f, 383.24234f, 430, 382);
926    path.lineTo(430, 280);
927    path.quadTo(430.009796f, 277.101196f, 458.703552f, 275.050262f);
928    path.close();
929    SkPath pathB;
930    pathB.setFillType(SkPath::kInverseWinding_FillType);
931    pathB.moveTo(528, 278);
932    pathB.lineTo(529, 278);
933    pathB.cubicTo(530.65686f, 278, 532, 278, 532, 278);
934    pathB.lineTo(532, 378);
935    pathB.cubicTo(532, 379.104584f, 488.123932f, 380, 434, 380);
936    pathB.lineTo(433, 380);
937    pathB.cubicTo(431.34314f, 380, 430, 380, 430, 380);
938    pathB.lineTo(430, 280);
939    pathB.cubicTo(430, 278.895416f, 473.876068f, 278, 528, 278);
940    pathB.close();
941    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
942}
943
944/* didn't investigate thoroughly, but looks to be missorting quad and cubic
945    {{468.507751,560.724426}, {467.275146,552.856262}, {465.84668,547.288391}}
946    {{463.779907,542.671143}, {464.829529,542.672974}, {466.946289,550.755676}, {468.507751,560.724426}}
947    decision maker is case 14 leftLessThanRight
948 */
949static void skptcmevents_org23(skiatest::Reporter* reporter, const char* filename) {
950    SkPath path;
951    path.setFillType(SkPath::kEvenOdd_FillType);
952    path.moveTo(465.503998f, 546);
953    path.lineTo(347, 546);
954    path.lineTo(347, 632);
955    path.lineTo(469.104248f, 632);
956    path.quadTo(470.79007f, 627.638672f, 471.833496f, 621.036255f);
957    path.quadTo(474.902588f, 601.562866f, 470.591064f, 574.024353f);
958    path.lineTo(468.507751f, 560.724426f);
959    path.quadTo(467.275146f, 552.856262f, 465.84668f, 547.288391f);
960    path.quadTo(465.670349f, 546.601501f, 465.503998f, 546);
961    path.close();
962    SkPath pathB;
963    pathB.setFillType(SkPath::kInverseWinding_FillType);
964    pathB.moveTo(363.052246f, 542.495361f);
965    pathB.lineTo(463.779907f, 542.671143f);
966    pathB.cubicTo(464.829529f, 542.672974f, 466.946289f, 550.755676f, 468.507751f, 560.724426f);
967    pathB.lineTo(470.591064f, 574.024353f);
968    pathB.cubicTo(476.26178f, 610.226624f, 471.498932f, 639.557922f, 459.953003f, 639.537781f);
969    pathB.lineTo(368.727936f, 639.378601f);
970    pathB.cubicTo(351.933868f, 639.349304f, 337.053741f, 631.244324f, 335.492249f, 621.275574f);
971    pathB.lineTo(325.968597f, 560.475708f);
972    pathB.cubicTo(324.407104f, 550.506958f, 341.01001f, 542.456909f, 363.052246f, 542.495361f);
973    pathB.close();
974    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
975}
976
977static void skpredbullskatearcade_es16(skiatest::Reporter* reporter, const char* filename) {
978    SkPath path;
979    path.setFillType(SkPath::kEvenOdd_FillType);
980    path.moveTo(936.765625f, 458.965302f);
981    path.cubicTo(937.028442f, 453.863251f, 933.145813f, 449.864502f, 928.093445f, 450.033905f);
982    path.lineTo(661.882263f, 458.958862f);
983    path.lineTo(661.875366f, 458.959106f);
984    path.cubicTo(656.828369f, 459.13205f, 652.525085f, 463.399719f, 652.258545f, 468.496124f);
985    path.lineTo(652.258179f, 468.503662f);
986    path.lineTo(649.021729f, 531.322754f);
987    path.cubicTo(648.75885f, 536.424805f, 652.641479f, 540.423523f, 657.693848f, 540.25415f);
988    path.lineTo(923.905029f, 531.329163f);
989    path.cubicTo(928.955017f, 531.159851f, 933.262268f, 526.890442f, 933.528809f, 521.791565f);
990    path.lineTo(933.529175f, 521.784363f);
991    path.lineTo(936.765625f, 458.965302f);
992    path.close();
993    SkPath pathB;
994    pathB.setFillType(SkPath::kInverseWinding_FillType);
995    pathB.moveTo(661.882263f, 458.958862f);
996    pathB.lineTo(928.093445f, 450.033905f);
997    pathB.cubicTo(929.103882f, 450, 929.709961f, 454.108612f, 929.447144f, 459.210663f);
998    pathB.lineTo(926.210693f, 522.029724f);
999    pathB.cubicTo(926.079224f, 524.58075f, 925.153442f, 526.676208f, 924.143066f, 526.710083f);
1000    pathB.lineTo(657.931885f, 535.635071f);
1001    pathB.cubicTo(652.879456f, 535.804443f, 648.890259f, 533.873779f, 649.021729f, 531.322754f);
1002    pathB.lineTo(652.258179f, 468.503662f);
1003    pathB.cubicTo(652.520996f, 463.401611f, 656.829834f, 459.128235f, 661.882263f, 458.958862f);
1004    pathB.close();
1005    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1006}
1007
1008static void skpfinanzasdigital_com9(skiatest::Reporter* reporter, const char* filename) {
1009    SkPath path;
1010    path.setFillType(SkPath::kEvenOdd_FillType);
1011    path.moveTo(156, 126);
1012    path.quadTo(154.343552f, 126.000397f, 153.17157f, 127.17157f);
1013    path.quadTo(152.000397f, 128.343552f, 152, 130);
1014    path.lineTo(152, 174);
1015    path.lineTo(1114, 174);
1016    path.lineTo(1114, 130);
1017    path.quadTo(1113.99963f, 128.343552f, 1112.82837f, 127.17157f);
1018    path.quadTo(1111.65649f, 126.000397f, 1110, 126);
1019    path.lineTo(156, 126);
1020    path.close();
1021    SkPath pathB;
1022    pathB.setFillType(SkPath::kInverseWinding_FillType);
1023    pathB.moveTo(156, 126);
1024    pathB.lineTo(1110, 126);
1025    pathB.cubicTo(1111.65686f, 126, 1113, 127.790863f, 1113, 130);
1026    pathB.lineTo(1113, 174);
1027    pathB.lineTo(153, 174);
1028    pathB.lineTo(153, 130);
1029    pathB.cubicTo(153, 127.790863f, 154.34314f, 126, 156, 126);
1030    pathB.close();
1031    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1032}
1033
1034static void skppartainasdemo250_org56(skiatest::Reporter* reporter, const char* filename) {
1035    SkPath path;
1036    path.setFillType(SkPath::kEvenOdd_FillType);
1037    path.moveTo(182.000015f, 645);
1038    path.lineTo(182, 640);
1039    path.cubicTo(174.322327f, 640, 166.644669f, 637.071045f, 160.786804f, 631.213196f);
1040    path.cubicTo(149.071075f, 619.497437f, 149.071075f, 600.502563f, 160.786804f, 588.786804f);
1041    path.lineTo(157.251266f, 585.251221f);
1042    path.quadTo(147, 595.502502f, 147.000015f, 610);
1043    path.quadTo(147, 624.482605f, 157.230255f, 634.727722f);
1044    path.quadTo(157.251251f, 634.748779f, 157.251282f, 634.748779f);
1045    path.quadTo(157.282852f, 634.780334f, 157.272263f, 634.769775f);
1046    path.quadTo(167.517334f, 645, 182.000015f, 645);
1047    path.close();
1048    SkPath pathB;
1049    pathB.setFillType(SkPath::kWinding_FillType);
1050    pathB.moveTo(182, 659.497498f);
1051    pathB.lineTo(206.748749f, 634.748718f);
1052    pathB.lineTo(182.000015f, 610);
1053    pathB.lineTo(132.502533f, 610);
1054    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1055}
1056
1057static void skpmlk_com326(skiatest::Reporter* reporter, const char* filename) {
1058    SkPath path;
1059    path.setFillType(SkPath::kEvenOdd_FillType);
1060    path.moveTo(154, 670);
1061    path.cubicTo(151.238571f, 670, 149, 672.238586f, 149, 675);
1062    path.lineTo(149, 710.001465f);
1063    path.cubicTo(149.000809f, 712.209961f, 150.791367f, 714, 153, 714);
1064    path.lineTo(189, 714);
1065    path.cubicTo(191.209137f, 714, 193, 712.209167f, 193, 710);
1066    path.lineTo(193, 675);
1067    path.cubicTo(193, 672.238586f, 190.761429f, 670, 188, 670);
1068    path.lineTo(154, 670);
1069    path.close();
1070    SkPath pathB;
1071    pathB.setFillType(SkPath::kInverseWinding_FillType);
1072    pathB.moveTo(154, 671);
1073    pathB.lineTo(188, 671);
1074    pathB.cubicTo(190.761429f, 671, 193, 672.790833f, 193, 675);
1075    pathB.lineTo(193, 710);
1076    pathB.cubicTo(193, 712.761414f, 190.761429f, 715, 188, 715);
1077    pathB.lineTo(154, 715);
1078    pathB.cubicTo(151.238571f, 715, 149, 712.761414f, 149, 710);
1079    pathB.lineTo(149, 675);
1080    pathB.cubicTo(149, 672.790833f, 151.238571f, 671, 154, 671);
1081    pathB.close();
1082    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1083}
1084
1085static void skpcyclist_friends_gr52(skiatest::Reporter* reporter, const char* filename) {
1086    SkPath path;
1087    path.setFillType(SkPath::kEvenOdd_FillType);
1088    path.moveTo(50, 182);
1089    path.lineTo(1215, 182);
1090    path.lineTo(1215, 202);
1091    path.quadTo(1214.99951f, 204.070572f, 1213.53552f, 205.535538f);
1092    path.quadTo(1212.07056f, 206.999496f, 1210, 207);
1093    path.lineTo(55, 207);
1094    path.quadTo(52.9294319f, 206.999496f, 51.4644661f, 205.535538f);
1095    path.quadTo(50.0004997f, 204.070572f, 50, 202);
1096    path.lineTo(50, 182);
1097    path.close();
1098    SkPath pathB;
1099    pathB.setFillType(SkPath::kInverseWinding_FillType);
1100    pathB.moveTo(50, 183);
1101    pathB.lineTo(1215, 183);
1102    pathB.lineTo(1215, 202);
1103    pathB.cubicTo(1215, 204.761429f, 1212.76147f, 207, 1210, 207);
1104    pathB.lineTo(55, 207);
1105    pathB.cubicTo(52.238575f, 207, 50, 204.761429f, 50, 202);
1106    pathB.lineTo(50, 183);
1107    pathB.close();
1108    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1109}
1110
1111/* cubic ends just above opp line */
1112static void skpwww_fj_p_com_22(skiatest::Reporter* reporter, const char* filename) {
1113    SkPath path;
1114    path.setFillType(SkPath::kEvenOdd_FillType);
1115    path.moveTo(172, 201);
1116    path.lineTo(172, 202);
1117    path.lineTo(220, 202);
1118    path.cubicTo(221.65686f, 202, 223, 200.65686f, 223, 199);
1119    path.cubicTo(223, 200.104568f, 221.65686f, 201, 220, 201);
1120    path.lineTo(172, 201);
1121    path.close();
1122    SkPath pathB;
1123    pathB.setFillType(SkPath::kWinding_FillType);
1124    pathB.moveTo(161, 202);
1125    pathB.lineTo(161, 199);
1126    pathB.lineTo(223, 199.000015f);
1127    pathB.lineTo(223, 202);
1128    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1129}
1130
1131// pair of lines are not quite coincident, so sorting line/cubic fails (i think)
1132static void skpwww_lavoixdunord_fr_11(skiatest::Reporter* reporter, const char* filename) {
1133    SkPath path;
1134    path.setFillType(SkPath::kEvenOdd_FillType);
1135    path.moveTo(806, 57);
1136    path.cubicTo(806, 55.3431473f, 807.34314f, 54, 809, 54);
1137    path.lineTo(930, 54);
1138    path.cubicTo(931.65686f, 54, 933, 55.3431473f, 933, 57);
1139    path.lineTo(933, 91);
1140    path.cubicTo(933, 92.6568527f, 931.65686f, 94, 930, 94);
1141    path.lineTo(809, 94);
1142    path.cubicTo(807.34314f, 94, 806, 92.6568527f, 806, 91);
1143    path.lineTo(806, 57);
1144    path.close();
1145    path.moveTo(808, 58);
1146    path.cubicTo(808, 56.8954315f, 808.895447f, 56, 810, 56);
1147    path.lineTo(929, 56);
1148    path.cubicTo(930.104553f, 56, 931, 56.8954315f, 931, 58);
1149    path.lineTo(931, 90);
1150    path.cubicTo(931, 91.1045685f, 930.104553f, 92, 929, 92);
1151    path.lineTo(810, 92);
1152    path.cubicTo(808.895447f, 92, 808, 91.1045685f, 808, 90);
1153    path.lineTo(808, 58);
1154    path.close();
1155    SkPath pathB;
1156    pathB.setFillType(SkPath::kWinding_FillType);
1157    pathB.moveTo(806, 54);
1158    pathB.lineTo(808, 56);
1159    pathB.lineTo(935.02002f, 56.0200005f);
1160    pathB.lineTo(933, 54);
1161    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1162}
1163
1164// pair of curves have nearly the same initial tangent but are sorting by
1165// that alone sorts them incorrectly. Need to detect that tangents are nearly
1166// identical and not reliable by themselves
1167static void skppptv_com_62(skiatest::Reporter* reporter, const char* filename) {
1168    SkPath path;
1169    path.setFillType(SkPath::kEvenOdd_FillType);
1170    path.moveTo(173, 5342);
1171    path.quadTo(171.343536f, 5342.00049f, 170.17157f, 5343.17139f);
1172    path.quadTo(169.000397f, 5344.34375f, 169, 5346);
1173    path.lineTo(169, 5372);
1174    path.lineTo(234, 5372);
1175    path.lineTo(234, 5346);
1176    path.quadTo(233.999603f, 5344.34375f, 232.82843f, 5343.17139f);
1177    path.quadTo(231.656464f, 5342.00049f, 230, 5342);
1178    path.lineTo(173, 5342);
1179    path.close();
1180    SkPath pathB;
1181    pathB.setFillType(SkPath::kInverseWinding_FillType);
1182    pathB.moveTo(173, 5342);
1183    pathB.lineTo(230, 5342);
1184    pathB.cubicTo(231.65686f, 5342, 233, 5343.79102f, 233, 5346);
1185    pathB.lineTo(233, 5372);
1186    pathB.lineTo(169, 5372);
1187    pathB.lineTo(169, 5346);
1188    pathB.cubicTo(169, 5343.79102f, 170.790863f, 5342, 173, 5342);
1189    pathB.close();
1190    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1191}
1192
1193// nearly identical to lavoixdunord -- to not-quite-coincident lines
1194static void skpwww_booking_com_68(skiatest::Reporter* reporter, const char* filename) {
1195    SkPath path;
1196    path.setFillType(SkPath::kEvenOdd_FillType);
1197    path.moveTo(90, 187);
1198    path.cubicTo(90, 185.34314f, 91.3431473f, 184, 93, 184);
1199    path.lineTo(588, 184);
1200    path.cubicTo(589.65686f, 184, 591, 185.34314f, 591, 187);
1201    path.lineTo(591, 218);
1202    path.cubicTo(591, 219.65686f, 589.65686f, 221, 588, 221);
1203    path.lineTo(93, 221);
1204    path.cubicTo(91.3431473f, 221, 90, 219.65686f, 90, 218);
1205    path.lineTo(90, 187);
1206    path.close();
1207    path.moveTo(92, 188);
1208    path.cubicTo(92, 186.895432f, 92.8954315f, 186, 94, 186);
1209    path.lineTo(587, 186);
1210    path.cubicTo(588.104553f, 186, 589, 186.895432f, 589, 188);
1211    path.lineTo(589, 217);
1212    path.cubicTo(589, 218.104568f, 588.104553f, 219, 587, 219);
1213    path.lineTo(94, 219);
1214    path.cubicTo(92.8954315f, 219, 92, 218.104568f, 92, 217);
1215    path.lineTo(92, 188);
1216    path.close();
1217    SkPath pathB;
1218    pathB.setFillType(SkPath::kWinding_FillType);
1219    pathB.moveTo(90, 184);
1220    pathB.lineTo(92, 186);
1221    pathB.lineTo(593.02002f, 186.020004f);
1222    pathB.lineTo(591, 184);
1223    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1224}
1225
1226// visually looks like lavoixdunord and www_booking_com
1227static void skpwww_despegar_com_mx_272(skiatest::Reporter* reporter, const char* filename) {
1228    SkPath path;
1229    path.setFillType(SkPath::kEvenOdd_FillType);
1230    path.moveTo(635, 1788);
1231    path.cubicTo(635, 1786.34314f, 636.34314f, 1785, 638, 1785);
1232    path.lineTo(832, 1785);
1233    path.cubicTo(833.65686f, 1785, 835, 1786.34314f, 835, 1788);
1234    path.lineTo(835, 1812);
1235    path.cubicTo(835, 1813.65686f, 833.65686f, 1815, 832, 1815);
1236    path.lineTo(638, 1815);
1237    path.cubicTo(636.34314f, 1815, 635, 1813.65686f, 635, 1812);
1238    path.lineTo(635, 1788);
1239    path.close();
1240    path.moveTo(637, 1789);
1241    path.cubicTo(637, 1787.89539f, 637.895447f, 1787, 639, 1787);
1242    path.lineTo(831, 1787);
1243    path.cubicTo(832.104553f, 1787, 833, 1787.89539f, 833, 1789);
1244    path.lineTo(833, 1811);
1245    path.cubicTo(833, 1812.10461f, 832.104553f, 1813, 831, 1813);
1246    path.lineTo(639, 1813);
1247    path.cubicTo(637.895447f, 1813, 637, 1812.10461f, 637, 1811);
1248    path.lineTo(637, 1789);
1249    path.close();
1250    SkPath pathB;
1251    pathB.setFillType(SkPath::kWinding_FillType);
1252    pathB.moveTo(835, 1785);
1253    pathB.lineTo(833, 1787);
1254    pathB.lineTo(832.97998f, 1817.02002f);
1255    pathB.lineTo(835, 1815);
1256    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1257}
1258
1259static void skpwww_joomla_org_23(skiatest::Reporter* reporter, const char* filename) {
1260    SkPath path;
1261    path.setFillType(SkPath::kEvenOdd_FillType);
1262    path.moveTo(320, 347);
1263    path.cubicTo(320, 344.238586f, 322.238586f, 342, 325, 342);
1264    path.lineTo(416, 342);
1265    path.cubicTo(418.761414f, 342, 421, 344.238586f, 421, 347);
1266    path.cubicTo(421, 344.790863f, 418.761414f, 343, 416, 343);
1267    path.lineTo(325, 343);
1268    path.cubicTo(322.238586f, 343, 320, 344.790863f, 320, 347);
1269    path.close();
1270    path.moveTo(320, 378);
1271    path.cubicTo(320, 380.761414f, 322.238586f, 383, 325, 383);
1272    path.lineTo(416, 383);
1273    path.cubicTo(418.761414f, 383, 421, 380.761414f, 421, 378);
1274    path.cubicTo(421, 380.209137f, 418.761414f, 382, 416, 382);
1275    path.lineTo(325, 382);
1276    path.cubicTo(322.238586f, 382, 320, 380.209137f, 320, 378);
1277    path.close();
1278    SkPath pathB;
1279    pathB.setFillType(SkPath::kWinding_FillType);
1280    pathB.moveTo(320, 383);
1281    pathB.lineTo(320, 378);
1282    pathB.lineTo(421, 378.000031f);
1283    pathB.lineTo(421, 383);
1284    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1285}
1286
1287static void skpwww_macrumors_com_131(skiatest::Reporter* reporter, const char* filename) {
1288    SkPath path;
1289    path.setFillType(SkPath::kEvenOdd_FillType);
1290    path.moveTo(136, 14089);
1291    path.lineTo(136, 14056);
1292    path.lineTo(778, 14056);
1293    path.lineTo(778, 14089);
1294    path.quadTo(777.999573f, 14090.6562f, 776.82843f, 14091.8281f);
1295    path.quadTo(775.656433f, 14093, 774, 14093);
1296    path.lineTo(140, 14093);
1297    path.quadTo(138.343552f, 14093, 137.17157f, 14091.8281f);
1298    path.quadTo(136.000397f, 14090.6562f, 136, 14089);
1299    path.close();
1300    SkPath pathB;
1301    pathB.setFillType(SkPath::kInverseWinding_FillType);
1302    pathB.moveTo(136, 14057);
1303    pathB.lineTo(778, 14057);
1304    pathB.lineTo(778, 14089);
1305    pathB.cubicTo(778, 14091.209f, 776.209167f, 14093, 774, 14093);
1306    pathB.lineTo(140, 14093);
1307    pathB.cubicTo(137.790863f, 14093, 136, 14091.209f, 136, 14089);
1308    pathB.lineTo(136, 14057);
1309    pathB.close();
1310    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1311}
1312
1313static void skpwww_leadpages_net_84(skiatest::Reporter* reporter, const char* filename) {
1314    SkPath path;
1315    path.setFillType(SkPath::kEvenOdd_FillType);
1316    path.moveTo(377.1716f, 5910.17139f);
1317    path.cubicTo(376.447723f, 5910.89551f, 376, 5911.89551f, 376, 5913);
1318    path.lineTo(376, 5972);
1319    path.cubicTo(376, 5974.20898f, 377.790863f, 5976, 380, 5976);
1320    path.cubicTo(378.34314f, 5976, 377, 5974.20898f, 377, 5972);
1321    path.lineTo(377, 5913);
1322    path.cubicTo(377, 5912.17139f, 377.335785f, 5911.42188f, 377.878693f, 5910.87891f);
1323    path.lineTo(377.1716f, 5910.17139f);
1324    path.close();
1325    SkPath pathB;
1326    pathB.setFillType(SkPath::kWinding_FillType);
1327    pathB.moveTo(376, 5909);
1328    pathB.lineTo(378.481873f, 5909);
1329    pathB.lineTo(379.999878f, 5976);
1330    pathB.lineTo(376, 5976);
1331    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1332}
1333
1334static void skpwww_briian_com_34(skiatest::Reporter* reporter, const char* filename) {
1335    SkPath path;
1336    path.setFillType(SkPath::kEvenOdd_FillType);
1337    path.moveTo(843, 216);
1338    path.cubicTo(843, 213.238571f, 845.238586f, 211, 848, 211);
1339    path.lineTo(1191, 211);
1340    path.cubicTo(1193.76147f, 211, 1196, 213.238571f, 1196, 216);
1341    path.lineTo(1196, 779);
1342    path.cubicTo(1196, 781.761414f, 1193.76147f, 784, 1191, 784);
1343    path.lineTo(848, 784);
1344    path.cubicTo(845.238586f, 784, 843, 781.761414f, 843, 779);
1345    path.lineTo(843, 216);
1346    path.close();
1347    path.moveTo(844, 217);
1348    path.cubicTo(844, 214.238571f, 846.238586f, 212, 849, 212);
1349    path.lineTo(1190, 212);
1350    path.cubicTo(1192.76147f, 212, 1195, 214.238571f, 1195, 217);
1351    path.lineTo(1195, 778);
1352    path.cubicTo(1195, 779.65686f, 1192.76147f, 781, 1190, 781);
1353    path.lineTo(849, 781);
1354    path.cubicTo(846.238586f, 781, 844, 779.65686f, 844, 778);
1355    path.lineTo(844, 217);
1356    path.close();
1357    SkPath pathB;
1358    pathB.setFillType(SkPath::kWinding_FillType);
1359    pathB.moveTo(843, 784);
1360    pathB.lineTo(843, 779);
1361    pathB.lineTo(1196, 779.000061f);
1362    pathB.lineTo(1196, 784);
1363    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1364}
1365
1366static void skpwww_sciality_com_100(skiatest::Reporter* reporter, const char* filename) {
1367    SkPath path;
1368    path.setFillType(SkPath::kEvenOdd_FillType);
1369    path.moveTo(162, 468);
1370    path.cubicTo(159.790863f, 468, 158, 469.790863f, 158, 472);
1371    path.lineTo(158, 528);
1372    path.cubicTo(158, 530.209106f, 159.790863f, 532, 162, 532);
1373    path.lineTo(275, 532);
1374    path.cubicTo(277.209137f, 532, 279, 530.209106f, 279, 528);
1375    path.lineTo(279, 472);
1376    path.cubicTo(279, 469.790863f, 277.209137f, 468, 275, 468);
1377    path.lineTo(162, 468);
1378    path.close();
1379    SkPath pathB;
1380    pathB.setFillType(SkPath::kWinding_FillType);
1381    pathB.moveTo(275, 468);
1382    pathB.cubicTo(276.65686f, 468, 278, 469.34314f, 278, 471);
1383    pathB.lineTo(278, 529);
1384    pathB.cubicTo(278, 530.65686f, 276.65686f, 532, 275, 532);
1385    pathB.lineTo(161, 532);
1386    pathB.cubicTo(159.34314f, 532, 158, 530.65686f, 158, 529);
1387    pathB.lineTo(158, 471);
1388    pathB.cubicTo(158, 469.34314f, 159.34314f, 468, 161, 468);
1389    pathB.lineTo(275, 468);
1390    pathB.close();
1391    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1392}
1393
1394static void skpwww_sciality_com_101(skiatest::Reporter* reporter, const char* filename) {
1395    SkPath path;
1396    path.setFillType(SkPath::kEvenOdd_FillType);
1397    path.moveTo(162, 468);
1398    path.cubicTo(159.790863f, 468, 158, 469.790863f, 158, 472);
1399    path.lineTo(158, 528);
1400    path.cubicTo(158, 530.209106f, 159.790863f, 532, 162, 532);
1401    path.lineTo(275.009186f, 532);
1402    path.cubicTo(276.661774f, 531.994995f, 278, 530.653748f, 278, 529);
1403    path.lineTo(278, 471);
1404    path.cubicTo(278, 469.346375f, 276.662079f, 468.005249f, 275.009705f, 468);
1405    path.lineTo(162, 468);
1406    path.close();
1407    SkPath pathB;
1408    pathB.setFillType(SkPath::kInverseWinding_FillType);
1409    pathB.moveTo(161, 469);
1410    pathB.lineTo(275, 469);
1411    pathB.cubicTo(276.65686f, 469, 278, 469.895416f, 278, 471);
1412    pathB.lineTo(278, 529);
1413    pathB.cubicTo(278, 530.65686f, 276.65686f, 532, 275, 532);
1414    pathB.lineTo(161, 532);
1415    pathB.cubicTo(159.34314f, 532, 158, 530.65686f, 158, 529);
1416    pathB.lineTo(158, 471);
1417    pathB.cubicTo(158, 469.895416f, 159.34314f, 469, 161, 469);
1418    pathB.close();
1419    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1420}
1421
1422static void skpwww_meb_gov_tr_5(skiatest::Reporter* reporter, const char* filename) {
1423    SkPath path;
1424    path.setFillType(SkPath::kEvenOdd_FillType);
1425    path.moveTo(137.34314f, 145.34314f);
1426    path.quadTo(139.687088f, 143.000793f, 143, 143);
1427    path.lineTo(242, 143);
1428    path.quadTo(245.312912f, 143.000793f, 247.65686f, 145.34314f);
1429    path.quadTo(249.999207f, 147.687088f, 250, 151);
1430    path.lineTo(250, 177);
1431    path.lineTo(135, 177);
1432    path.lineTo(135, 151);
1433    path.quadTo(135.000793f, 147.687088f, 137.34314f, 145.34314f);
1434    path.close();
1435    SkPath pathB;
1436    pathB.setFillType(SkPath::kWinding_FillType);
1437    pathB.moveTo(135, 143);
1438    pathB.lineTo(250, 143);
1439    pathB.lineTo(250, 177);
1440    pathB.lineTo(135, 177);
1441    pathB.close();
1442    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1443}
1444
1445static void skpwww_meb_gov_tr_6(skiatest::Reporter* reporter, const char* filename) {
1446    SkPath path;
1447    path.setFillType(SkPath::kEvenOdd_FillType);
1448    path.moveTo(143, 143);
1449    path.quadTo(139.687088f, 143.000793f, 137.34314f, 145.34314f);
1450    path.quadTo(135.000793f, 147.687088f, 135, 151);
1451    path.lineTo(135, 177);
1452    path.lineTo(250, 177);
1453    path.lineTo(250, 151);
1454    path.quadTo(249.999207f, 147.687088f, 247.65686f, 145.34314f);
1455    path.quadTo(245.312912f, 143.000793f, 242, 143);
1456    path.lineTo(143, 143);
1457    path.close();
1458    SkPath pathB;
1459    pathB.setFillType(SkPath::kInverseWinding_FillType);
1460    pathB.moveTo(143, 143);
1461    pathB.lineTo(242, 143);
1462    pathB.cubicTo(245.865997f, 143, 249, 146.581726f, 249, 151);
1463    pathB.lineTo(249, 177);
1464    pathB.lineTo(135, 177);
1465    pathB.lineTo(135, 151);
1466    pathB.cubicTo(135, 146.581726f, 138.581726f, 143, 143, 143);
1467    pathB.close();
1468    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1469}
1470
1471static void skpgithub_io_25(skiatest::Reporter* reporter, const char* filename) {
1472    SkPath path;
1473    path.setFillType(SkPath::kEvenOdd_FillType);
1474    path.moveTo(1001.87866f, 14.8786793f);
1475    path.quadTo(1002.75745f, 14.0001001f, 1004, 14);
1476    path.lineTo(1105, 14);
1477    path.quadTo(1106.24255f, 14.0001001f, 1107.12134f, 14.8786793f);
1478    path.quadTo(1107.99988f, 15.7574596f, 1108, 17);
1479    path.lineTo(1108, 41);
1480    path.quadTo(1107.99988f, 42.2425423f, 1107.12134f, 43.1213188f);
1481    path.quadTo(1106.24255f, 43.9999008f, 1105, 44);
1482    path.lineTo(1004, 44);
1483    path.quadTo(1002.75745f, 43.9999008f, 1001.87866f, 43.1213188f);
1484    path.quadTo(1001.00012f, 42.2425423f, 1001, 41);
1485    path.lineTo(1001, 17);
1486    path.quadTo(1001.00012f, 15.7574596f, 1001.87866f, 14.8786793f);
1487    path.close();
1488    SkPath pathB;
1489    pathB.setFillType(SkPath::kInverseWinding_FillType);
1490    pathB.moveTo(1005, 16);
1491    pathB.lineTo(1104, 16);
1492    pathB.cubicTo(1105.10461f, 16, 1106, 16.8954296f, 1106, 18);
1493    pathB.lineTo(1106, 40);
1494    pathB.cubicTo(1106, 41.1045685f, 1105.10461f, 42, 1104, 42);
1495    pathB.lineTo(1005, 42);
1496    pathB.cubicTo(1003.89545f, 42, 1003, 41.1045685f, 1003, 40);
1497    pathB.lineTo(1003, 18);
1498    pathB.cubicTo(1003, 16.8954296f, 1003.89545f, 16, 1005, 16);
1499    pathB.close();
1500    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1501}
1502
1503static void skpgithub_io_26(skiatest::Reporter* reporter, const char* filename) {
1504    SkPath path;
1505    path.setFillType(SkPath::kEvenOdd_FillType);
1506    path.moveTo(1001.87866f, 14.8786793f);
1507    path.quadTo(1002.75745f, 14.0001001f, 1004, 14);
1508    path.lineTo(1105, 14);
1509    path.quadTo(1106.24255f, 14.0001001f, 1107.12134f, 14.8786793f);
1510    path.quadTo(1107.99988f, 15.7574596f, 1108, 17);
1511    path.lineTo(1108, 41);
1512    path.quadTo(1107.99988f, 42.2425423f, 1107.12134f, 43.1213188f);
1513    path.quadTo(1106.24255f, 43.9999008f, 1105, 44);
1514    path.lineTo(1004, 44);
1515    path.quadTo(1002.75745f, 43.9999008f, 1001.87866f, 43.1213188f);
1516    path.quadTo(1001.00012f, 42.2425423f, 1001, 41);
1517    path.lineTo(1001, 17);
1518    path.quadTo(1001.00012f, 15.7574596f, 1001.87866f, 14.8786793f);
1519    path.close();
1520    path.moveTo(1003, 18);
1521    path.cubicTo(1003, 16.8954296f, 1003.89545f, 16, 1005, 16);
1522    path.lineTo(1104, 16);
1523    path.cubicTo(1105.10461f, 16, 1106, 16.8954296f, 1106, 18);
1524    path.lineTo(1106, 40);
1525    path.cubicTo(1106, 41.1045685f, 1105.10461f, 42, 1104, 42);
1526    path.lineTo(1005, 42);
1527    path.cubicTo(1003.89545f, 42, 1003, 41.1045685f, 1003, 40);
1528    path.lineTo(1003, 18);
1529    path.close();
1530    SkPath pathB;
1531    pathB.setFillType(SkPath::kWinding_FillType);
1532    pathB.moveTo(1108, 14);
1533    pathB.lineTo(1106, 16);
1534    pathB.lineTo(1105.97998f, 46.0200005f);
1535    pathB.lineTo(1108, 44);
1536    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1537}
1538
1539static void skpskpicture14(skiatest::Reporter* reporter, const char* filename) {
1540    SkPath path;
1541    path.setFillType(SkPath::kEvenOdd_FillType);
1542    path.moveTo(0, 994);
1543    path.lineTo(0, 0);
1544    path.lineTo(512, 0);
1545    path.lineTo(512, 994);
1546    path.lineTo(0, 994);
1547    path.close();
1548    SkPath pathB;
1549    pathB.setFillType(SkPath::kWinding_FillType);
1550    pathB.moveTo(-317, 168);
1551    pathB.quadTo(-317, 166.757385f, -316.121338f, 165.878662f);
1552    pathB.quadTo(-315.242645f, 165, -314, 165);
1553    pathB.lineTo(320, 165);
1554    pathB.quadTo(321.242615f, 165, 322.121338f, 165.878662f);
1555    pathB.quadTo(323, 166.757385f, 323, 168);
1556    pathB.lineTo(323, 193);
1557    pathB.lineTo(-317, 193);
1558    pathB.close();
1559    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1560}
1561
1562static void skpskpicture15(skiatest::Reporter* reporter, const char* filename) {
1563    SkPath path;
1564    path.setFillType(SkPath::kEvenOdd_FillType);
1565    path.moveTo(0, 193);
1566    path.lineTo(323, 193);
1567    path.lineTo(323, 168);
1568    path.quadTo(323, 166.757385f, 322.121338f, 165.878662f);
1569    path.quadTo(321.242615f, 165, 320, 165);
1570    path.lineTo(0, 165);
1571    path.lineTo(0, 193);
1572    path.close();
1573    SkPath pathB;
1574    pathB.setFillType(SkPath::kInverseWinding_FillType);
1575    pathB.moveTo(-314, 165);
1576    pathB.lineTo(320, 165);
1577    pathB.cubicTo(321.65686f, 165, 323, 166.34314f, 323, 168);
1578    pathB.lineTo(323, 192);
1579    pathB.lineTo(-317, 192);
1580    pathB.lineTo(-317, 168);
1581    pathB.cubicTo(-317, 166.34314f, -315.65686f, 165, -314, 165);
1582    pathB.close();
1583    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1584}
1585
1586/* Three edges are partially coincident. Only one of the three knows about the other two.
1587   Subsequently, when the angle loop is created, it misses one of the edges.
1588   After coincident edges are processed, probably need a check-and-correct that makes sure the
1589   coincidences are all self-consistent.
1590 */
1591static void skpelpais_com_18(skiatest::Reporter* reporter, const char* filename) {
1592    SkPath path;
1593    path.setFillType(SkPath::kEvenOdd_FillType);
1594    path.moveTo(183, 8507);
1595    path.lineTo(552, 8506.99023f);
1596    path.lineTo(552, 8508);
1597    path.lineTo(183, 8508);
1598    path.lineTo(183, 8507);
1599    path.close();
1600    SkPath pathB;
1601    pathB.setFillType(SkPath::kWinding_FillType);
1602    pathB.moveTo(183, 8508);
1603    pathB.lineTo(183, 8506.99023f);
1604    pathB.lineTo(552, 8507);
1605    pathB.lineTo(552, 8508);
1606    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1607}
1608
1609/* this generates a pair of lines that are essentially coincident; but the next line at a right
1610   angle is not treated as if it intersects at the same point.
1611   There are several of options:
1612     move the intersection of the right angle line to the coincident point (should 'near' do this?
1613     construct another coincident pair from the right angle line to the coincident point
1614     treat the intersection as simple and not coincident
1615 */
1616static void skpnamecheap_com_405(skiatest::Reporter* reporter, const char* filename) {
1617    SkPath path;
1618    path.setFillType(SkPath::kEvenOdd_FillType);
1619    path.moveTo(140, 1000);
1620    path.lineTo(140, 842);
1621    path.lineTo(141, 842);
1622    path.lineTo(141.14502f, 1000);
1623    path.lineTo(140, 1000);
1624    path.close();
1625    SkPath pathB;
1626    pathB.setFillType(SkPath::kWinding_FillType);
1627    pathB.moveTo(140, 842);
1628    pathB.lineTo(141.008835f, 837.9646f);
1629    pathB.lineTo(141.235291f, 1109.05884f);
1630    pathB.lineTo(140, 1114);
1631    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1632}
1633
1634// fails on angle insert -- haven't investigated yet
1635static void skpwww_alrakoba_net_62(skiatest::Reporter* reporter, const char* filename) {
1636    SkPath path;
1637    path.setFillType(SkPath::kEvenOdd_FillType);
1638    path.moveTo(134.34314f, 9802.34277f);
1639    path.quadTo(132, 9804.68652f, 132, 9808);
1640    path.lineTo(132, 9822);
1641    path.quadTo(132, 9825.31348f, 134.34314f, 9827.65723f);
1642    path.quadTo(136.686295f, 9830, 140, 9830);
1643    path.lineTo(140.028473f, 9830);
1644    path.lineTo(139.877213f, 9828.90723f);
1645    path.quadTo(137.692032f, 9828.5332f, 136.050247f, 9826.65723f);
1646    path.quadTo(134, 9824.31348f, 134, 9821);
1647    path.lineTo(134, 9809);
1648    path.quadTo(134, 9806.10059f, 136.050247f, 9804.0498f);
1649    path.lineTo(134.34314f, 9802.34277f);
1650    path.close();
1651    SkPath pathB;
1652    pathB.setFillType(SkPath::kWinding_FillType);
1653    pathB.moveTo(132, 9800);
1654    pathB.lineTo(135.962357f, 9800);
1655    pathB.lineTo(140, 9830);
1656    pathB.lineTo(132, 9830);
1657    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1658}
1659
1660/* asserts in alignSpanState looks like a coincident related bug */
1661static void skpwww_cityads_ru_249(skiatest::Reporter* reporter, const char* filename) {
1662    SkPath path;
1663    path.setFillType(SkPath::kEvenOdd_FillType);
1664    path.moveTo(817.464478f, 11.4644661f);
1665    path.quadTo(818.928955f, 10, 821, 10);
1666    path.lineTo(998, 10);
1667    path.quadTo(999.082947f, 10, 1000, 10.4003992f);
1668    path.lineTo(1000, 13.3527431f);
1669    path.quadTo(999.917603f, 13.2607508f, 999.82843f, 13.1715727f);
1670    path.quadTo(998.65686f, 12, 997, 12);
1671    path.lineTo(822, 12);
1672    path.quadTo(820.34314f, 12, 819.17157f, 13.1715727f);
1673    path.quadTo(818, 14.3431454f, 818, 16);
1674    path.lineTo(818, 28);
1675    path.quadTo(818, 29.6568546f, 819.17157f, 30.8284264f);
1676    path.quadTo(820.34314f, 32, 822, 32);
1677    path.lineTo(997, 32);
1678    path.quadTo(998.65686f, 32, 999.82843f, 30.8284264f);
1679    path.quadTo(999.917603f, 30.7392426f, 1000, 30.6472569f);
1680    path.lineTo(1000, 33.5996017f);
1681    path.quadTo(999.082947f, 34, 998, 34);
1682    path.lineTo(821, 34);
1683    path.quadTo(818.928955f, 34, 817.464478f, 32.5355339f);
1684    path.quadTo(816, 31.0710678f, 816, 29);
1685    path.lineTo(816, 15);
1686    path.quadTo(816, 12.9289322f, 817.464478f, 11.4644661f);
1687    path.close();
1688    SkPath pathB;
1689    pathB.setFillType(SkPath::kWinding_FillType);
1690    pathB.moveTo(1003, 10);
1691    pathB.lineTo(1000, 13);
1692    pathB.lineTo(999.969971f, 37.0299988f);
1693    pathB.lineTo(1003, 34);
1694    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1695}
1696
1697// fails on angle insert
1698static void skpwww_dealnews_com_315(skiatest::Reporter* reporter, const char* filename) {
1699    SkPath path;
1700    path.setFillType(SkPath::kEvenOdd_FillType);
1701    path.moveTo(966.464478f, 4261.46436f);
1702    path.quadTo(965, 4262.92871f, 965, 4265);
1703    path.lineTo(965, 4276);
1704    path.quadTo(965, 4278.07129f, 966.464478f, 4279.53564f);
1705    path.quadTo(967.928955f, 4281, 970, 4281);
1706    path.lineTo(970.020325f, 4281);
1707    path.lineTo(969.887512f, 4279.81641f);
1708    path.quadTo(968.928284f, 4279.48145f, 968.17157f, 4278.53564f);
1709    path.quadTo(967, 4277.07129f, 967, 4275);
1710    path.lineTo(967, 4266);
1711    path.quadTo(967, 4264.44287f, 968.035217f, 4263.31396f);
1712    path.lineTo(968, 4263);
1713    path.lineTo(966.464478f, 4261.46436f);
1714    path.close();
1715    SkPath pathB;
1716    pathB.setFillType(SkPath::kWinding_FillType);
1717    pathB.moveTo(965, 4260);
1718    pathB.lineTo(967.716675f, 4260);
1719    pathB.lineTo(970, 4281);
1720    pathB.lineTo(965, 4281);
1721    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1722}
1723
1724// fails in intersections insert
1725static void skpwww_inmotionhosting_com_9(skiatest::Reporter* reporter, const char* filename) {
1726    SkPath path;
1727    path.setFillType(SkPath::kEvenOdd_FillType);
1728    path.moveTo(991.633911f, 1839);
1729    path.lineTo(964.265015f, 1839);
1730    path.lineTo(963.734985f, 1893.73242f);
1731    path.lineTo(991.3703f, 1894);
1732    path.lineTo(1018.23492f, 1894);
1733    path.lineTo(1018.76501f, 1839.2627f);
1734    path.lineTo(991.638184f, 1839);
1735    path.lineTo(991.633911f, 1839);
1736    path.close();
1737    SkPath pathB;
1738    pathB.setFillType(SkPath::kWinding_FillType);
1739    pathB.moveTo(964.267578f, 1838.73499f);
1740    pathB.lineTo(1019.26501f, 1839.26758f);
1741    pathB.lineTo(1018.73242f, 1894.26501f);
1742    pathB.lineTo(963.734985f, 1893.73242f);
1743    pathB.close();
1744    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1745}
1746
1747static void skpwww_alucinados_net_101(skiatest::Reporter* reporter, const char* filename) {
1748    SkPath path;
1749    path.setFillType(SkPath::kEvenOdd_FillType);
1750    path.moveTo(1129.53552f, 1164.46448f);
1751    path.lineTo(1128, 1166);
1752    path.lineTo(1128.12231f, 1166.49548f);
1753    path.quadTo(1129, 1167.56592f, 1129, 1169);
1754    path.lineTo(1129, 1170.05054f);
1755    path.lineTo(1130.34509f, 1175.49878f);
1756    path.quadTo(1131, 1174.38513f, 1131, 1173);
1757    path.lineTo(1131, 1168);
1758    path.quadTo(1131, 1165.92896f, 1129.53552f, 1164.46448f);
1759    path.close();
1760    SkPath pathB;
1761    pathB.setFillType(SkPath::kWinding_FillType);
1762    pathB.moveTo(1131, 1163);
1763    pathB.lineTo(-43515.8555f, -177415.594f);
1764    pathB.lineTo(1129.76465f, 1173.05884f);
1765    pathB.lineTo(1131, 1178);
1766    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1767}
1768
1769// /SkOpContour.cpp:278: failed assertion "!approximately_negative(oEndT - oStartT)
1770static void skpwww_hairjobsearch_com_31(skiatest::Reporter* reporter, const char* filename) {
1771    SkPath path;
1772    path.setFillType(SkPath::kEvenOdd_FillType);
1773    path.moveTo(143.292892f, 0.707106769f);
1774    path.quadTo(143, 0.414213538f, 143, 0);
1775    path.lineTo(1123, 0);
1776    path.quadTo(1123, 0.414213538f, 1122.70715f, 0.707106769f);
1777    path.quadTo(1122.41418f, 1, 1122, 1);
1778    path.lineTo(144, 1);
1779    path.quadTo(143.585785f, 1, 143.292892f, 0.707106769f);
1780    path.close();
1781    SkPath pathB;
1782    pathB.setFillType(SkPath::kWinding_FillType);
1783    pathB.moveTo(143, 1);
1784    pathB.lineTo(144, 0);
1785    pathB.lineTo(1122, 0);
1786    pathB.lineTo(1123, 1);
1787    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1788}
1789
1790// SkOpSegment::checkSmallCoincidence; line 1958 SkASSERT(span.fWindValue);
1791static void skpwww_heartiste_wordpress_com_86(skiatest::Reporter* reporter, const char* filename) {
1792    SkPath path;
1793    path.setFillType(SkPath::kEvenOdd_FillType);
1794    path.moveTo(741, 9432);
1795    path.lineTo(761, 9431.99023f);
1796    path.lineTo(761, 9433);
1797    path.lineTo(741, 9433);
1798    path.lineTo(741, 9432);
1799    path.close();
1800    SkPath pathB;
1801    pathB.setFillType(SkPath::kWinding_FillType);
1802    pathB.moveTo(741, 9433);
1803    pathB.lineTo(741, 9431.99023f);
1804    pathB.lineTo(761, 9432);
1805    pathB.lineTo(761, 9433);
1806    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1807}
1808
1809static void skpwww_argus_presse_fr_41(skiatest::Reporter* reporter, const char* filename) {
1810    SkPath path;
1811    path.setFillType(SkPath::kEvenOdd_FillType);
1812    path.moveTo(1000, 343);
1813    path.lineTo(165, 343);
1814    path.lineTo(165, 364.869873f);
1815    path.lineTo(1000, 364.869873f);
1816    path.lineTo(1000, 343);
1817    path.close();
1818    SkPath pathB;
1819    pathB.setFillType(SkPath::kWinding_FillType);
1820    pathB.moveTo(165, 343.000031f);
1821    pathB.lineTo(1000, 343.000031f);
1822    pathB.lineTo(1000, 364.869904f);
1823    pathB.lineTo(165, 364.869904f);
1824    pathB.close();
1825    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1826}
1827
1828// SkOpSegment::checkSmallCoincidence; line 1958 SkASSERT(span.fWindValue);
1829static void skpwww_320kbps_net_2231(skiatest::Reporter* reporter, const char* filename) {
1830    SkPath path;
1831    path.setFillType(SkPath::kEvenOdd_FillType);
1832    path.moveTo(838, 9125);
1833    path.lineTo(862, 9124.99023f);
1834    path.lineTo(862, 9126);
1835    path.lineTo(838, 9126);
1836    path.lineTo(838, 9125);
1837    path.close();
1838    SkPath pathB;
1839    pathB.setFillType(SkPath::kWinding_FillType);
1840    pathB.moveTo(838, 9126);
1841    pathB.lineTo(838, 9124.99023f);
1842    pathB.lineTo(862, 9125);
1843    pathB.lineTo(862, 9126);
1844    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1845}
1846
1847// debugValidateLoop loop sum fails
1848static void skpwww_exystence_net_61(skiatest::Reporter* reporter, const char* filename) {
1849    SkPath path;
1850    path.setFillType(SkPath::kEvenOdd_FillType);
1851    path.moveTo(143, 9075);
1852    path.lineTo(316, 9075);
1853    path.lineTo(316, 9073.99023f);
1854    path.lineTo(143, 9074);
1855    path.lineTo(143, 9075);
1856    path.close();
1857    SkPath pathB;
1858    pathB.setFillType(SkPath::kWinding_FillType);
1859    pathB.moveTo(143, 9075);
1860    pathB.lineTo(143, 9073.99023f);
1861    pathB.lineTo(316, 9074);
1862    pathB.lineTo(316, 9075);
1863    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1864}
1865
1866// debugValidateLoop loop sum fails
1867static void skpwww_trashness_com_36(skiatest::Reporter* reporter, const char* filename) {
1868    SkPath path;
1869    path.setFillType(SkPath::kEvenOdd_FillType);
1870    path.moveTo(541.5f, 4835.99512f);
1871    path.lineTo(91.5f, 4836);
1872    path.lineTo(91.5f, 4836.5f);
1873    path.lineTo(541.5f, 4836.5f);
1874    path.lineTo(541.5f, 4835.99512f);
1875    path.close();
1876    SkPath pathB;
1877    pathB.setFillType(SkPath::kWinding_FillType);
1878    pathB.moveTo(91.5f, 4836.5f);
1879    pathB.lineTo(91.5f, 4835.99512f);
1880    pathB.lineTo(541.5f, 4836);
1881    pathB.lineTo(541.5f, 4836.5f);
1882    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1883}
1884
1885// SkIntersections::lineVertical fUsed >= fMax
1886static void skpwww_getgold_jp_731(skiatest::Reporter* reporter, const char* filename) {
1887    SkPath path;
1888    path.setFillType(SkPath::kEvenOdd_FillType);
1889    path.moveTo(284.878693f, 10134.8789f);
1890    path.quadTo(284, 10135.7578f, 284, 10137);
1891    path.lineTo(284, 10216);
1892    path.quadTo(284, 10217.2422f, 284.878693f, 10218.1211f);
1893    path.quadTo(285.125122f, 10218.3672f, 285.40213f, 10218.5459f);
1894    path.lineTo(286, 10138);
1895    path.lineTo(286, 10136);
1896    path.lineTo(284.878693f, 10134.8789f);
1897    path.close();
1898    SkPath pathB;
1899    pathB.setFillType(SkPath::kWinding_FillType);
1900    pathB.moveTo(284, 10134);
1901    pathB.lineTo(286.05957f, 10129.8809f);
1902    pathB.lineTo(285.399994f, 10216.2002f);
1903    pathB.lineTo(284, 10219);
1904    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1905}
1906
1907// SkOpContour::calcPartialCoincidentWinding SkASSERT(!approximately_negative(endT - startT));
1908static void skpwww_maturesupertube_com_21(skiatest::Reporter* reporter, const char* filename) {
1909    SkPath path;
1910    path.setFillType(SkPath::kEvenOdd_FillType);
1911    path.moveTo(3.17157292f, 11831.1719f);
1912    path.quadTo(4.34314585f, 11830, 6, 11830);
1913    path.lineTo(1259, 11830);
1914    path.quadTo(1260.65686f, 11830, 1261.82837f, 11831.1719f);
1915    path.quadTo(1263, 11832.3428f, 1263, 11834);
1916    path.lineTo(1263, 11848);
1917    path.quadTo(1263, 11849.6572f, 1261.82837f, 11850.8281f);
1918    path.quadTo(1260.65686f, 11852, 1259, 11852);
1919    path.lineTo(6, 11852);
1920    path.quadTo(4.34314585f, 11852, 3.17157292f, 11850.8281f);
1921    path.quadTo(2, 11849.6572f, 2, 11848);
1922    path.lineTo(2, 11834);
1923    path.quadTo(2, 11832.3428f, 3.17157292f, 11831.1719f);
1924    path.close();
1925    path.moveTo(3.87867975f, 11831.8789f);
1926    path.quadTo(4.7573595f, 11831, 6, 11831);
1927    path.lineTo(1259, 11831);
1928    path.quadTo(1260.24268f, 11831, 1261.12134f, 11831.8789f);
1929    path.quadTo(1262, 11832.7578f, 1262, 11834);
1930    path.lineTo(1262, 11848);
1931    path.quadTo(1262, 11849.2422f, 1261.12134f, 11850.1211f);
1932    path.quadTo(1260.24268f, 11851, 1259, 11851);
1933    path.lineTo(6, 11851);
1934    path.quadTo(4.7573595f, 11851, 3.87867975f, 11850.1211f);
1935    path.quadTo(3, 11849.2422f, 3, 11848);
1936    path.lineTo(3, 11834);
1937    path.quadTo(3, 11832.7578f, 3.87867975f, 11831.8789f);
1938    path.close();
1939    SkPath pathB;
1940    pathB.setFillType(SkPath::kWinding_FillType);
1941    pathB.moveTo(2, 11830);
1942    pathB.lineTo(4.5f, 11832.5f);
1943    pathB.lineTo(1260.5f, 11832.5f);
1944    pathB.lineTo(1263, 11830);
1945    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1946}
1947
1948// can't find winding of remaining vertical edges
1949static void skpwww_hubbyscook_com_22(skiatest::Reporter* reporter, const char* filename) {
1950    SkPath path;
1951    path.setFillType(SkPath::kEvenOdd_FillType);
1952    path.moveTo(1000, 902.329346f);
1953    path.quadTo(998, 905.250427f, 998, 909);
1954    path.lineTo(998, 910);
1955    path.quadTo(998, 913.749573f, 1000, 916.670654f);
1956    path.lineTo(1000, 902.329346f);
1957    path.close();
1958    SkPath pathB;
1959    pathB.setFillType(SkPath::kWinding_FillType);
1960    pathB.moveTo(998, 910);
1961    pathB.lineTo(998, 909);
1962    pathB.quadTo(998, 904.029419f, 1001.51471f, 900.514709f);
1963    pathB.quadTo(1005.02942f, 897, 1010, 897);
1964    pathB.lineTo(1011, 897);
1965    pathB.quadTo(1015.14215f, 897, 1018.07104f, 900.514709f);
1966    pathB.quadTo(1021, 904.029419f, 1021, 909);
1967    pathB.lineTo(1021, 910);
1968    pathB.quadTo(1021, 914.142151f, 1018.07104f, 917.071045f);
1969    pathB.quadTo(1015.14215f, 920, 1011, 920);
1970    pathB.lineTo(1010, 920);
1971    pathB.quadTo(1005.02942f, 920, 1001.51471f, 917.071045f);
1972    pathB.quadTo(998, 914.142151f, 998, 910);
1973    pathB.close();
1974    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1975}
1976
1977static void skpwww_gruposejaumdivulgador_com_br_4(skiatest::Reporter* reporter, const char* filename) {
1978    SkPath path;
1979    path.setFillType(SkPath::kEvenOdd_FillType);
1980    path.moveTo(610.5f, 5.78626502e-14f);
1981    path.lineTo(1083.5f, -6.12303177e-17f);
1982    path.lineTo(1083.5f, 469);
1983    path.lineTo(610.5f, 469);
1984    path.lineTo(610.5f, 5.78626502e-14f);
1985    path.close();
1986    SkPath pathB;
1987    pathB.setFillType(SkPath::kWinding_FillType);
1988    pathB.moveTo(611, 0);
1989    pathB.lineTo(1084, 0);
1990    pathB.lineTo(1084, 469);
1991    pathB.lineTo(611, 469);
1992    pathB.close();
1993    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1994}
1995
1996// asserts in bridgeOp simple->isClosed()
1997static void skpwww_phototransferapp_com_24(skiatest::Reporter* reporter, const char* filename) {
1998    SkPath path;
1999    path.setFillType(SkPath::kEvenOdd_FillType);
2000    path.moveTo(85.6091843f, 5.92893219f);
2001    path.quadTo(89.6041641f, 3, 93.7462997f, 3);
2002    path.lineTo(1212.74634f, 3);
2003    path.quadTo(1216.88843f, 3, 1218.75134f, 5.92893219f);
2004    path.quadTo(1220.61414f, 8.85775471f, 1219.10669f, 12.9996767f);
2005    path.quadTo(1220.46338f, 9.27196693f, 1218.4939f, 6.63603878f);
2006    path.quadTo(1216.52441f, 4, 1212.38232f, 4);
2007    path.lineTo(93.3823318f, 4);
2008    path.quadTo(89.2401962f, 4, 85.3518219f, 6.63603878f);
2009    path.quadTo(81.4634476f, 9.27207756f, 80.1065979f, 13);
2010    path.quadTo(81.614212f, 8.85786438f, 85.6091843f, 5.92893219f);
2011    path.close();
2012    SkPath pathB;
2013    pathB.setFillType(SkPath::kWinding_FillType);
2014    pathB.moveTo(83.7462997f, 3);
2015    pathB.lineTo(1222.74634f, 3);
2016    pathB.lineTo(1219.10657f, 13);
2017    pathB.lineTo(80.1065979f, 13);
2018    pathB.close();
2019    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2020}
2021
2022static void skpwww_phototransferapp_com_24x(skiatest::Reporter* reporter, const char* filename) {
2023    SkPath path;
2024    path.setFillType(SkPath::kEvenOdd_FillType);
2025    path.moveTo(85.6091843f, 5.92893219f);
2026    path.quadTo(89.6041641f, 3, 93.7462997f, 3);
2027    path.lineTo(112.74634f, 3);
2028    path.quadTo(116.88843f, 3, 118.75134f, 5.92893219f);
2029    path.quadTo(120.61414f, 8.85775471f, 119.10669f, 12.9996767f);
2030    path.quadTo(120.46338f, 9.27196693f, 118.4939f, 6.63603878f);
2031    path.quadTo(116.52441f, 4, 112.38232f, 4);
2032    path.lineTo(93.3823318f, 4);
2033    path.quadTo(89.2401962f, 4, 85.3518219f, 6.63603878f);
2034    path.quadTo(81.4634476f, 9.27207756f, 80.1065979f, 13);
2035    path.quadTo(81.614212f, 8.85786438f, 85.6091843f, 5.92893219f);
2036    path.close();
2037    SkPath pathB;
2038    pathB.setFillType(SkPath::kWinding_FillType);
2039    pathB.moveTo(83.7462997f, 3);
2040    pathB.lineTo(122.74634f, 3);
2041    pathB.lineTo(119.10657f, 13);
2042    pathB.lineTo(80.1065979f, 13);
2043    pathB.close();
2044    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2045}
2046
2047static void skpwww_helha_be_109(skiatest::Reporter* reporter, const char* filename) {
2048    SkPath path;
2049    path.setFillType(SkPath::kEvenOdd_FillType);
2050    path.moveTo(117.686981f, 3339.08423f);
2051    path.lineTo(109.533035f, 3350.72925f);
2052    path.quadTo(107.120552f, 3354.17456f, 103.879379f, 3354.41821f);
2053    path.quadTo(100.638504f, 3354.66187f, 98.4674301f, 3351.56177f);
2054    path.quadTo(100.87973f, 3355.00635f, 104.291222f, 3355.00635f);
2055    path.quadTo(107.70298f, 3355.00635f, 110.115463f, 3351.56104f);
2056    path.lineTo(118, 3340.30078f);
2057    path.lineTo(118, 3339.53125f);
2058    path.lineTo(117.686981f, 3339.08423f);
2059    path.close();
2060    SkPath pathB;
2061    pathB.setFillType(SkPath::kWinding_FillType);
2062    pathB.moveTo(118.269409f, 3339.91602f);
2063    pathB.lineTo(117.686981f, 3339.08423f);
2064    pathB.lineTo(98.4669647f, 3351.56104f);
2065    pathB.lineTo(104.291214f, 3359.87891f);
2066    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2067}
2068
2069static void skpwww_cooksnaps_com_32(skiatest::Reporter* reporter, const char* filename) {
2070    SkPath path;
2071    path.setFillType(SkPath::kEvenOdd_FillType);
2072    path.moveTo(509.34021f, 176);
2073    path.lineTo(505, 176);
2074    path.quadTo(500.964233f, 176, 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);
2078    path.quadTo(479.69455f, 188.700821f, 477.995941f, 191.618286f);
2079    path.quadTo(476.316772f, 194.550476f, 475.258759f, 197.959335f);
2080    path.quadTo(474, 202.218979f, 474, 207);
2081    path.lineTo(474, 208);
2082    path.quadTo(474, 212.03569f, 474.896851f, 215.699799f);
2083    path.quadTo(475.950256f, 219.315002f, 477.962708f, 222.803986f);
2084    path.lineTo(477.970215f, 222.816986f);
2085    path.lineTo(478.470215f, 223.683014f);
2086    path.quadTo(478.474915f, 223.691162f, 478.479645f, 223.69931f);
2087    path.quadTo(480.867981f, 227.831055f, 484.082947f, 230.885254f);
2088    path.quadTo(486.701447f, 233.305939f, 489.61908f, 235.004517f);
2089    path.quadTo(492.550232f, 236.682983f, 495.957611f, 237.740738f);
2090    path.quadTo(500.217987f, 239, 505, 239);
2091    path.lineTo(509.482178f, 239);
2092    path.quadTo(515.299133f, 238.212051f, 520.801941f, 235.038513f);
2093    path.quadTo(520.809509f, 235.034164f, 520.817017f, 235.0298f);
2094    path.lineTo(521.683044f, 234.5298f);
2095    path.quadTo(521.692078f, 234.524582f, 521.701111f, 234.519348f);
2096    path.quadTo(532.80603f, 228.09938f, 536.126709f, 215.70639f);
2097    path.quadTo(539.450134f, 203.303314f, 533.029785f, 192.183014f);
2098    path.lineTo(532.529785f, 191.316986f);
2099    path.quadTo(526.109497f, 180.196686f, 513.706421f, 176.873276f);
2100    path.quadTo(511.503082f, 176.282898f, 509.34021f, 176);
2101    path.close();
2102    SkPath pathB;
2103    pathB.setFillType(SkPath::kWinding_FillType);
2104    pathB.moveTo(478.470215f, 223.683014f);
2105    pathB.lineTo(477.970215f, 222.816986f);
2106    pathB.quadTo(471.549896f, 211.696686f, 474.873322f, 199.293594f);
2107    pathB.quadTo(478.196686f, 186.890503f, 489.316986f, 180.4702f);
2108    pathB.lineTo(490.183014f, 179.9702f);
2109    pathB.quadTo(501.303345f, 173.549896f, 513.706421f, 176.873276f);
2110    pathB.quadTo(526.109497f, 180.196686f, 532.529785f, 191.316986f);
2111    pathB.lineTo(533.029785f, 192.183014f);
2112    pathB.quadTo(539.450134f, 203.303314f, 536.126709f, 215.70639f);
2113    pathB.quadTo(532.803345f, 228.109497f, 521.683044f, 234.5298f);
2114    pathB.lineTo(520.817017f, 235.0298f);
2115    pathB.quadTo(509.696686f, 241.450104f, 497.29361f, 238.126709f);
2116    pathB.quadTo(484.890533f, 234.803314f, 478.470215f, 223.683014f);
2117    pathB.close();
2118    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2119}
2120
2121static void skpwww_cooksnaps_com_32a(skiatest::Reporter* reporter, const char* filename) {
2122    SkPath path;
2123    path.setFillType(SkPath::kEvenOdd_FillType);
2124    path.moveTo(497.299988f, 176.896912f);
2125    path.quadTo(493.678162f, 177.952286f, 490.183014f, 179.9702f);
2126    path.lineTo(489.316986f, 180.4702f);
2127    path.quadTo(485.175385f, 182.861359f, 482.115265f, 186.082397f);
2128    SkPath pathB;
2129    pathB.setFillType(SkPath::kWinding_FillType);
2130    pathB.moveTo(474.873322f, 199.293594f);
2131    pathB.quadTo(478.196686f, 186.890503f, 489.316986f, 180.4702f);
2132    pathB.lineTo(490.183014f, 179.9702f);
2133    pathB.quadTo(501.303345f, 173.549896f, 513.706421f, 176.873276f);
2134    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2135}
2136
2137// !simple->isClosed()
2138static void skpwww_contextualnewsfeeds_com_346(skiatest::Reporter* reporter, const char* filename) {
2139    SkPath path;
2140    path.setFillType(SkPath::kEvenOdd_FillType);
2141    path.moveTo(460.257355f, 1202.27808f);
2142    path.lineTo(460.257355f, 1204.27808f);
2143    path.quadTo(461.081207f, 1204.27808f, 461.665161f, 1203.69873f);
2144    path.lineTo(461.67157f, 1203.69238f);
2145    path.lineTo(466.621307f, 1198.74268f);
2146    path.quadTo(466.623993f, 1198.73999f, 466.626648f, 1198.7373f);
2147    path.quadTo(466.914185f, 1198.44604f, 466.914185f, 1198.03552f);
2148    path.quadTo(466.914215f, 1197.62122f, 466.621307f, 1197.32837f);
2149    path.lineTo(465.914215f, 1196.62122f);
2150    path.lineTo(460.257355f, 1202.27808f);
2151    path.close();
2152    SkPath pathB;
2153    pathB.setFillType(SkPath::kWinding_FillType);
2154    pathB.moveTo(460.257355f, 1205.10657f);
2155    pathB.lineTo(458.828979f, 1203.67822f);
2156    pathB.lineTo(465.914215f, 1196.62122f);
2157    pathB.lineTo(467.32843f, 1198.03552f);
2158    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2159}
2160
2161// line quad intersection SkIntersections::assert
2162static void skpwww_pindosiya_com_99(skiatest::Reporter* reporter, const char* filename) {
2163    SkPath path;
2164    path.setFillType(SkPath::kEvenOdd_FillType);
2165    path.moveTo(899.17157f, 548.17157f);
2166    path.quadTo(898, 549.34314f, 898, 551);
2167    path.lineTo(898, 556);
2168    path.lineTo(899.027283f, 556);
2169    path.lineTo(900.02356f, 551.602844f);
2170    path.quadTo(900.06073f, 551.297058f, 900.156555f, 551.015747f);
2171    path.lineTo(900.5f, 549.5f);
2172    path.lineTo(899.17157f, 548.17157f);
2173    path.close();
2174    SkPath pathB;
2175    pathB.setFillType(SkPath::kWinding_FillType);
2176    pathB.moveTo(898, 547);
2177    pathB.lineTo(901.086914f, 547);
2178    pathB.lineTo(899, 556);
2179    pathB.lineTo(898, 556);
2180    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2181}
2182
2183// SkOpAngle::setSector SkASSERT(fSectorStart >= 0);
2184static void skpwww_karnivool_com_au_11(skiatest::Reporter* reporter, const char* filename) {
2185    SkPath path;
2186    path.setFillType(SkPath::kEvenOdd_FillType);
2187    path.moveTo(0, 1431);
2188    path.lineTo(0, 775);
2189    path.lineTo(1265, 775);
2190    path.lineTo(1265, 1431);
2191    path.lineTo(0, 1431);
2192    path.close();
2193    SkPath pathB;
2194    pathB.setFillType(SkPath::kWinding_FillType);
2195    pathB.moveTo(32.3243904f, 851);
2196    pathB.lineTo(459.324402f, 851);
2197    pathB.lineTo(427, 1081);
2198    pathB.lineTo(-3.81469727e-06f, 1081);
2199    pathB.close();
2200    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2201}
2202
2203static void skpwww_tunero_de_24(skiatest::Reporter* reporter, const char* filename) {
2204    SkPath path;
2205    path.setFillType(SkPath::kEvenOdd_FillType);
2206    path.moveTo(1020.79303f, 2252);
2207    path.quadTo(1018.72198f, 2252, 1016.86798f, 2253.46436f);
2208    path.quadTo(1015.02032f, 2254.92383f, 1014.4668f, 2256.98584f);
2209    path.lineTo(1014.46301f, 2257);
2210    path.lineTo(1011.53705f, 2268);
2211    path.quadTo(1010.98615f, 2270.07104f, 1012.06104f, 2271.53564f);
2212    path.quadTo(1013.13599f, 2273, 1015.20703f, 2273);
2213    path.lineTo(1083.20703f, 2273);
2214    path.quadTo(1085.27808f, 2273, 1087.13208f, 2271.53564f);
2215    path.quadTo(1088.97144f, 2270.08252f, 1089.52832f, 2268.03271f);
2216    path.lineTo(1089.53711f, 2268);
2217    path.lineTo(1092.46301f, 2257);
2218    path.lineTo(1092.4679f, 2256.98145f);
2219    path.quadTo(1093.00916f, 2254.92236f, 1091.93909f, 2253.46436f);
2220    path.quadTo(1090.86414f, 2252, 1088.79297f, 2252);
2221    path.lineTo(1020.79303f, 2252);
2222    path.close();
2223    SkPath pathB;
2224    pathB.setFillType(SkPath::kWinding_FillType);
2225    pathB.moveTo(1011.53705f, 2268);
2226    pathB.lineTo(1014.46301f, 2257);
2227    pathB.quadTo(1015.01392f, 2254.92896f, 1016.86798f, 2253.46436f);
2228    pathB.quadTo(1018.72198f, 2252, 1020.79303f, 2252);
2229    pathB.lineTo(1088.79297f, 2252);
2230    pathB.quadTo(1090.86414f, 2252, 1091.93909f, 2253.46436f);
2231    pathB.quadTo(1093.01392f, 2254.92896f, 1092.46301f, 2257);
2232    pathB.lineTo(1089.53711f, 2268);
2233    pathB.quadTo(1088.98608f, 2270.07104f, 1087.13208f, 2271.53564f);
2234    pathB.quadTo(1085.27808f, 2273, 1083.20703f, 2273);
2235    pathB.lineTo(1015.20703f, 2273);
2236    pathB.quadTo(1013.13599f, 2273, 1012.06104f, 2271.53564f);
2237    pathB.quadTo(1010.98615f, 2270.07104f, 1011.53705f, 2268);
2238    pathB.close();
2239    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2240}
2241
2242static void skpwww_docgelo_com_66(skiatest::Reporter* reporter, const char* filename) {
2243    SkPath path;
2244    path.setFillType(SkPath::kEvenOdd_FillType);
2245    path.moveTo(22.5f, 24174.5f);
2246    path.lineTo(185.5f, 24174.498f);
2247    path.lineTo(185.5f, 24174.75f);
2248    path.lineTo(22.5f, 24174.75f);
2249    path.lineTo(22.5f, 24174.5f);
2250    path.close();
2251    SkPath pathB;
2252    pathB.setFillType(SkPath::kWinding_FillType);
2253    pathB.moveTo(22.5f, 24174.75f);
2254    pathB.lineTo(22.5f, 24174.498f);
2255    pathB.lineTo(185.5f, 24174.5f);
2256    pathB.lineTo(185.5f, 24174.75f);
2257    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2258}
2259
2260static void skpwww_kpopexplorer_net_22(skiatest::Reporter* reporter, const char* filename) {
2261    SkPath path;
2262    path.setFillType(SkPath::kEvenOdd_FillType);
2263    path.moveTo(1000, 866.329346f);
2264    path.quadTo(998, 869.250427f, 998, 873);
2265    path.lineTo(998, 874);
2266    path.quadTo(998, 877.749573f, 1000, 880.670654f);
2267    path.lineTo(1000, 866.329346f);
2268    path.close();
2269    SkPath pathB;
2270    pathB.setFillType(SkPath::kWinding_FillType);
2271    pathB.moveTo(998, 874);
2272    pathB.lineTo(998, 873);
2273    pathB.quadTo(998, 868.029419f, 1001.51471f, 864.514709f);
2274    pathB.quadTo(1005.02942f, 861, 1010, 861);
2275    pathB.lineTo(1011, 861);
2276    pathB.quadTo(1015.14215f, 861, 1018.07104f, 864.514709f);
2277    pathB.quadTo(1021, 868.029419f, 1021, 873);
2278    pathB.lineTo(1021, 874);
2279    pathB.quadTo(1021, 878.142151f, 1018.07104f, 881.071045f);
2280    pathB.quadTo(1015.14215f, 884, 1011, 884);
2281    pathB.lineTo(1010, 884);
2282    pathB.quadTo(1005.02942f, 884, 1001.51471f, 881.071045f);
2283    pathB.quadTo(998, 878.142151f, 998, 874);
2284    pathB.close();
2285    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
2286}
2287
2288static void skpwww_artblart_com_8(skiatest::Reporter* reporter, const char* filename) {
2289    SkPath path;
2290    path.setFillType(SkPath::kEvenOdd_FillType);
2291    path.moveTo(22.5f, 24527.25f);
2292    path.lineTo(45, 24527.248f);
2293    path.lineTo(45, 24527.5f);
2294    path.lineTo(22.5f, 24527.5f);
2295    path.lineTo(22.5f, 24527.25f);
2296    path.close();
2297    SkPath pathB;
2298    pathB.setFillType(SkPath::kWinding_FillType);
2299    pathB.moveTo(22.5f, 24527.5f);
2300    pathB.lineTo(22.5f, 24527.248f);
2301    pathB.lineTo(45, 24527.25f);
2302    pathB.lineTo(45, 24527.5f);
2303    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2304}
2305
2306// joinCoincidence / findT / assert
2307static void skpwww_jessicaslens_wordpress_com_222(skiatest::Reporter* reporter, const char* filename) {
2308    SkPath path;
2309    path.setFillType(SkPath::kEvenOdd_FillType);
2310    path.moveTo(1000, 844.329346f);
2311    path.quadTo(998, 847.250427f, 998, 851);
2312    path.lineTo(998, 852);
2313    path.quadTo(998, 855.749573f, 1000, 858.670654f);
2314    path.lineTo(1000, 844.329346f);
2315    path.close();
2316    SkPath pathB;
2317    pathB.setFillType(SkPath::kWinding_FillType);
2318    pathB.moveTo(998, 852);
2319    pathB.lineTo(998, 851);
2320    pathB.quadTo(998, 846.029419f, 1001.51471f, 842.514709f);
2321    pathB.quadTo(1005.02942f, 839, 1010, 839);
2322    pathB.lineTo(1011, 839);
2323    pathB.quadTo(1015.14215f, 839, 1018.07104f, 842.514709f);
2324    pathB.quadTo(1021, 846.029419f, 1021, 851);
2325    pathB.lineTo(1021, 852);
2326    pathB.quadTo(1021, 856.142151f, 1018.07104f, 859.071045f);
2327    pathB.quadTo(1015.14215f, 862, 1011, 862);
2328    pathB.lineTo(1010, 862);
2329    pathB.quadTo(1005.02942f, 862, 1001.51471f, 859.071045f);
2330    pathB.quadTo(998, 856.142151f, 998, 852);
2331    pathB.close();
2332    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
2333}
2334
2335// joinCoincidence / findT / assert
2336static void skpwww_simplysaru_com_40(skiatest::Reporter* reporter, const char* filename) {
2337    SkPath path;
2338    path.setFillType(SkPath::kEvenOdd_FillType);
2339    path.moveTo(1000, 866.329346f);
2340    path.quadTo(998, 869.250427f, 998, 873);
2341    path.lineTo(998, 874);
2342    path.quadTo(998, 877.749573f, 1000, 880.670654f);
2343    path.lineTo(1000, 866.329346f);
2344    path.close();
2345    SkPath pathB;
2346    pathB.setFillType(SkPath::kWinding_FillType);
2347    pathB.moveTo(998, 874);
2348    pathB.lineTo(998, 873);
2349    pathB.quadTo(998, 868.029419f, 1001.51471f, 864.514709f);
2350    pathB.quadTo(1005.02942f, 861, 1010, 861);
2351    pathB.lineTo(1011, 861);
2352    pathB.quadTo(1015.14215f, 861, 1018.07104f, 864.514709f);
2353    pathB.quadTo(1021, 868.029419f, 1021, 873);
2354    pathB.lineTo(1021, 874);
2355    pathB.quadTo(1021, 878.142151f, 1018.07104f, 881.071045f);
2356    pathB.quadTo(1015.14215f, 884, 1011, 884);
2357    pathB.lineTo(1010, 884);
2358    pathB.quadTo(1005.02942f, 884, 1001.51471f, 881.071045f);
2359    pathB.quadTo(998, 878.142151f, 998, 874);
2360    pathB.close();
2361    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
2362}
2363
2364// cubic-cubic intersection reduce checkLinear assert
2365static void skpwww_partsdata_de_53(skiatest::Reporter* reporter, const char* filename) {
2366    SkPath path;
2367    path.setFillType(SkPath::kEvenOdd_FillType);
2368    path.moveTo(407, 119);
2369    path.lineTo(407, 28);
2370    path.lineTo(647, 28);
2371    path.lineTo(647, 119);
2372    path.lineTo(407, 119);
2373    path.close();
2374    SkPath pathB;
2375    pathB.setFillType(SkPath::kWinding_FillType);
2376    pathB.moveTo(471.228394f, 64.443222f);
2377    pathB.cubicTo(471.193878f, 60.953373f, 470.234985f, 52.4797592f, 462.201569f, 46.6231461f);
2378    pathB.cubicTo(454.168152f, 40.7665405f, 446.592804f, 41.993145f, 443.033936f, 42.8568878f);
2379    pathB.cubicTo(439.475098f, 43.7206268f, 436.978638f, 45.4052658f, 436.304871f, 45.7851906f);
2380    pathB.cubicTo(435.631104f, 46.1651154f, 435.156006f, 45.8026352f, 434.957306f, 45.6384506f);
2381    pathB.cubicTo(434.758636f, 45.4742737f, 431.460999f, 42.0105858f, 430.916901f, 41.4664841f);
2382    pathB.cubicTo(430.372803f, 40.9223785f, 429.731628f, 41.3303604f, 429.375214f, 41.6996689f);
2383    pathB.cubicTo(429.375214f, 41.6996689f, 420.610016f, 50.5190887f, 419.918793f, 51.1754227f);
2384    pathB.cubicTo(419.22757f, 51.8321419f, 419.331482f, 52.2465706f, 419.884308f, 52.8339005f);
2385    pathB.cubicTo(420.437134f, 53.4212303f, 425.170624f, 58.0167313f, 425.619568f, 58.4660416f);
2386    pathB.cubicTo(426.068512f, 58.9153557f, 426.137878f, 59.2952805f, 426.137878f, 59.8136024f);
2387    pathB.cubicTo(426.137878f, 60.3319244f, 426.103394f, 103.141357f, 426.103394f, 103.970215f);
2388    pathB.cubicTo(426.103394f, 104.799835f, 426.310791f, 105.525177f, 427.17453f, 105.525177f);
2389    pathB.cubicTo(428.038269f, 105.525177f, 440.131409f, 105.491432f, 440.85675f, 105.491432f);
2390    pathB.cubicTo(441.582489f, 105.491432f, 441.996918f, 104.903343f, 441.996918f, 104.17762f);
2391    pathB.cubicTo(441.996918f, 103.452271f, 441.996918f, 89.5622559f, 441.996918f, 87.8002701f);
2392    pathB.cubicTo(441.996918f, 86.0382843f, 442.342712f, 86.2453079f, 442.826141f, 86.3491974f);
2393    pathB.cubicTo(443.309601f, 86.4530945f, 445.832184f, 87.040802f, 448.700195f, 87.040802f);
2394    pathB.cubicTo(466.87442f, 86.6949997f, 471.815338f, 69.4876556f, 471.228394f, 64.443222f);
2395    pathB.close();
2396    pathB.moveTo(448.873108f, 72.4595642f);
2397    pathB.cubicTo(444.636658f, 72.4595642f, 441.202545f, 69.0254517f, 441.202545f, 64.7890244f);
2398    pathB.cubicTo(441.202545f, 60.5525932f, 444.636658f, 57.1184845f, 448.873108f, 57.1184845f);
2399    pathB.cubicTo(453.109528f, 57.1184845f, 456.54364f, 60.552597f, 456.54364f, 64.7890244f);
2400    pathB.cubicTo(456.54364f, 69.0254517f, 453.109528f, 72.4595642f, 448.873108f, 72.4595642f);
2401    pathB.close();
2402    pathB.moveTo(520.242859f, 82.5275803f);
2403    pathB.cubicTo(519.733276f, 81.6547394f, 494.845154f, 41.3379478f, 494.263123f, 40.3923073f);
2404    pathB.cubicTo(493.681122f, 39.4462852f, 493.244324f, 39.5918846f, 492.807495f, 40.3195038f);
2405    pathB.cubicTo(492.515167f, 40.8071136f, 467.238037f, 81.6790085f, 466.528625f, 82.8373566f);
2406    pathB.cubicTo(465.819183f, 83.9945831f, 466.497528f, 84.2975311f, 466.904358f, 84.5792542f);
2407    pathB.cubicTo(466.904358f, 84.5792542f, 477.399689f, 91.2036743f, 478.235748f, 91.6981049f);
2408    pathB.cubicTo(479.071838f, 92.1929092f, 479.396393f, 91.9028473f, 479.669403f, 91.5104141f);
2409    pathB.cubicTo(479.942383f, 91.1175995f, 484.106384f, 84.1549606f, 484.481781f, 83.5570221f);
2410    pathB.cubicTo(484.857147f, 82.9602051f, 485.198792f, 82.8741379f, 485.966583f, 82.8741379f);
2411    pathB.cubicTo(486.734406f, 82.8741379f, 499.635925f, 82.8062668f, 500.830322f, 82.8062668f);
2412    pathB.cubicTo(502.024658f, 82.8062668f, 502.229797f, 83.4038391f, 502.400452f, 83.6427078f);
2413    pathB.cubicTo(502.571045f, 83.8815842f, 506.615631f, 90.7414703f, 506.990997f, 91.2870865f);
2414    pathB.cubicTo(507.651123f, 92.2475128f, 508.017395f, 92.1333847f, 508.672241f, 91.6962051f);
2415    pathB.cubicTo(509.327423f, 91.2597809f, 519.442444f, 85.0744324f, 520.243286f, 84.4920349f);
2416    pathB.cubicTo(521.042908f, 83.9100189f, 520.751709f, 83.4004211f, 520.242859f, 82.5275803f);
2417    pathB.close();
2418    pathB.moveTo(493.720551f, 72.4811783f);
2419    pathB.cubicTo(491.265442f, 72.4811783f, 489.275574f, 70.4905548f, 489.275574f, 68.0362091f);
2420    pathB.cubicTo(489.275574f, 65.5811005f, 491.265808f, 63.5912399f, 493.720551f, 63.5912399f);
2421    pathB.cubicTo(496.175262f, 63.5912399f, 498.165527f, 65.5814819f, 498.165527f, 68.0362091f);
2422    pathB.cubicTo(498.165894f, 70.4905548f, 496.175659f, 72.4811783f, 493.720551f, 72.4811783f);
2423    pathB.close();
2424    pathB.moveTo(526.561707f, 42.132679f);
2425    pathB.cubicTo(526.876404f, 41.786499f, 527.537292f, 41.1881752f, 528.512878f, 42.1956215f);
2426    pathB.cubicTo(529.488892f, 43.2030678f, 531.691833f, 45.2486725f, 531.881042f, 45.4693451f);
2427    pathB.cubicTo(532.07019f, 45.6896439f, 532.762939f, 46.2875862f, 533.517883f, 45.7525826f);
2428    pathB.cubicTo(534.272827f, 45.2172012f, 539.497681f, 41.9753265f, 545.384277f, 42.132679f);
2429    pathB.cubicTo(546.203247f, 42.2270889f, 546.580566f, 42.5421791f, 546.612f, 43.8324814f);
2430    pathB.cubicTo(546.643494f, 45.1227837f, 546.674561f, 55.1957283f, 546.612f, 56.2657356f);
2431    pathB.cubicTo(546.549072f, 57.3361206f, 546.549072f, 57.7452469f, 544.975525f, 57.8396568f);
2432    pathB.cubicTo(543.401978f, 57.9340706f, 538.742798f, 59.5709305f, 538.774658f, 64.6070251f);
2433    pathB.cubicTo(538.806458f, 69.6431122f, 538.806091f, 86.2631226f, 538.806091f, 86.9554901f);
2434    pathB.cubicTo(538.806091f, 87.6478424f, 538.585815f, 88.4349976f, 537.484314f, 88.4349976f);
2435    pathB.cubicTo(536.382446f, 88.4349976f, 524.79895f, 88.4031372f, 524.04364f, 88.4031372f);
2436    pathB.cubicTo(523.287964f, 88.4031372f, 522.910706f, 88.3402023f, 522.910706f, 86.8606949f);
2437    pathB.cubicTo(522.910706f, 85.3823242f, 522.910706f, 60.6094704f, 522.910706f, 60.0740852f);
2438    pathB.cubicTo(522.910706f, 59.5387039f, 522.81665f, 58.9092865f, 522.470093f, 58.6260452f);
2439    pathB.cubicTo(522.123901f, 58.3428116f, 517.465088f, 53.621048f, 517.181885f, 53.3378105f);
2440    pathB.cubicTo(516.898621f, 53.0545731f, 516.300659f, 52.330368f, 517.213318f, 51.5121231f);
2441    pathB.cubicTo(518.125977f, 50.6942635f, 526.561707f, 42.132679f, 526.561707f, 42.132679f);
2442    pathB.close();
2443    pathB.moveTo(550.169006f, 43.7373123f);
2444    pathB.cubicTo(550.169006f, 42.6358337f, 550.767334f, 42.2263336f, 551.49115f, 42.2263336f);
2445    pathB.cubicTo(552.214966f, 42.2263336f, 552.781433f, 42.2263336f, 552.938843f, 42.2263336f);
2446    pathB.cubicTo(553.096191f, 42.2263336f, 553.725586f, 41.8801537f, 553.662598f, 41.124855f);
2447    pathB.cubicTo(553.600098f, 40.369175f, 553.662598f, 31.4614124f, 553.662598f, 30.8005257f);
2448    pathB.cubicTo(553.662598f, 30.1396389f, 553.75708f, 29.1951332f, 555.110657f, 29.1951332f);
2449    pathB.cubicTo(556.463928f, 29.1951332f, 566.536865f, 29.1951332f, 567.859009f, 29.1951332f);
2450    pathB.cubicTo(569.180786f, 29.1951332f, 569.463623f, 30.1711082f, 569.463623f, 30.7690544f);
2451    pathB.cubicTo(569.463623f, 31.3670006f, 569.463623f, 40.2122002f, 569.463623f, 41.0619125f);
2452    pathB.cubicTo(569.463623f, 41.9116249f, 569.746887f, 42.3207474f, 570.659912f, 42.3207474f);
2453    pathB.cubicTo(571.572571f, 42.3207474f, 575.507568f, 42.2263336f, 576.199951f, 42.2263336f);
2454    pathB.cubicTo(576.892273f, 42.2263336f, 577.742004f, 42.5725098f, 577.742004f, 43.8631973f);
2455    pathB.cubicTo(577.742004f, 45.1538811f, 577.742004f, 55.8877106f, 577.742004f, 56.5800705f);
2456    pathB.cubicTo(577.742004f, 57.2724266f, 577.616455f, 58.0595779f, 576.45166f, 58.0595779f);
2457    pathB.cubicTo(575.286865f, 58.0595779f, 570.943115f, 58.0595779f, 570.471069f, 58.0595779f);
2458    pathB.cubicTo(569.999023f, 58.0595779f, 569.479919f, 57.8389015f, 569.479919f, 59.0510979f);
2459    pathB.cubicTo(569.479919f, 60.2629128f, 569.479919f, 66.2124176f, 569.479919f, 67.1880188f);
2460    pathB.cubicTo(569.479919f, 68.1636047f, 570.628418f, 73.6406708f, 575.917053f, 73.6406708f);
2461    pathB.cubicTo(577.018921f, 73.6406708f, 577.742737f, 73.9242859f, 577.742737f, 75.4348907f);
2462    pathB.cubicTo(577.742737f, 76.945488f, 577.742737f, 87.0813751f, 577.742737f, 87.8366699f);
2463    pathB.cubicTo(577.742737f, 88.5915909f, 577.648315f, 89.4416809f, 576.295044f, 89.4416809f);
2464    pathB.cubicTo(574.028809f, 89.6312714f, 553.978088f, 88.0254974f, 553.631897f, 65.928421f);
2465    pathB.cubicTo(553.631897f, 65.928421f, 553.631897f, 59.6964378f, 553.631897f, 58.972229f);
2466    pathB.cubicTo(553.631897f, 58.2484055f, 553.034363f, 58.0436554f, 552.703735f, 58.0436554f);
2467    pathB.cubicTo(552.372681f, 58.0436554f, 551.522949f, 58.0436554f, 551.208252f, 58.0436554f);
2468    pathB.cubicTo(550.893921f, 58.0436554f, 550.170105f, 58.0906677f, 550.170105f, 56.6115417f);
2469    pathB.cubicTo(550.170105f, 55.1324081f, 550.169006f, 43.7373123f, 550.169006f, 43.7373123f);
2470    pathB.close();
2471    pathB.moveTo(611.203857f, 39.5509338f);
2472    pathB.cubicTo(612.084961f, 39.5509338f, 612.620422f, 40.0544662f, 612.620422f, 40.8097687f);
2473    pathB.cubicTo(612.620422f, 41.5650673f, 612.620422f, 53.1486092f, 612.620422f, 53.6839905f);
2474    pathB.cubicTo(612.620422f, 54.2193718f, 612.651489f, 55.2264404f, 611.612976f, 55.2264404f);
2475    pathB.cubicTo(610.574463f, 55.2264404f, 604.404663f, 55.9817429f, 604.404663f, 61.899395f);
2476    pathB.cubicTo(604.404663f, 65.4878235f, 604.373169f, 66.6211548f, 604.373169f, 67.5338135f);
2477    pathB.cubicTo(604.373169f, 68.0684357f, 604.414124f, 74.3353043f, 599.934631f, 80.4702148f);
2478    pathB.cubicTo(596.765564f, 84.8109131f, 590.664368f, 89.3942871f, 582.150208f, 89.630127f);
2479    pathB.cubicTo(580.028015f, 89.630127f, 580.230469f, 88.5286484f, 580.230469f, 88.1820908f);
2480    pathB.cubicTo(580.230469f, 87.5845184f, 580.198975f, 75.8436279f, 580.198975f, 75.2142105f);
2481    pathB.cubicTo(580.198975f, 74.5844116f, 580.608154f, 73.8605804f, 581.58374f, 73.8605804f);
2482    pathB.cubicTo(583.40979f, 73.8605804f, 588.603271f, 72.7905731f, 588.603271f, 66.9043884f);
2483    pathB.cubicTo(588.603271f, 61.3958588f, 588.603271f, 61.8679237f, 588.603271f, 61.0496788f);
2484    pathB.cubicTo(588.603271f, 60.2314377f, 588.666565f, 54.3137856f, 593.230591f, 48.3961296f);
2485    pathB.cubicTo(597.794617f, 42.4784775f, 604.814087f, 39.5509338f, 611.203857f, 39.5509338f);
2486    pathB.close();
2487    pathB.moveTo(635.22937f, 81.9311447f);
2488    pathB.cubicTo(635.057617f, 81.6475296f, 634.869141f, 81.3851471f, 634.664429f, 81.1439972f);
2489    pathB.lineTo(635.039001f, 81.0385895f);
2490    pathB.cubicTo(635.447754f, 80.9233246f, 635.729858f, 80.5509796f, 635.729858f, 80.1263123f);
2491    pathB.lineTo(635.729858f, 78.6149597f);
2492    pathB.cubicTo(635.729858f, 78.3309631f, 635.602417f, 78.0617523f, 635.382935f, 77.8816452f);
2493    pathB.cubicTo(635.162598f, 77.7015381f, 634.873291f, 77.6295013f, 634.595764f, 77.6852341f);
2494    pathB.cubicTo(633.906799f, 77.8232498f, 633.194397f, 77.9017334f, 632.478149f, 77.9191818f);
2495    pathB.cubicTo(631.714844f, 77.9373779f, 630.851501f, 77.9464874f, 629.911133f, 77.9464874f);
2496    pathB.lineTo(615.131226f, 77.9464874f);
2497    pathB.cubicTo(614.607605f, 77.9464874f, 614.18335f, 78.3707733f, 614.18335f, 78.8944016f);
2498    pathB.lineTo(614.18335f, 81.1337585f);
2499    pathB.cubicTo(614.18335f, 81.6573868f, 614.607605f, 82.0816803f, 615.131226f, 82.0816803f);
2500    pathB.lineTo(619.693787f, 82.0816803f);
2501    pathB.cubicTo(619.680908f, 82.1423492f, 619.669128f, 82.2026367f, 619.657776f, 82.2629166f);
2502    pathB.cubicTo(619.571289f, 82.728157f, 619.529602f, 83.3200302f, 619.529602f, 84.0730591f);
2503    pathB.cubicTo(619.529602f, 86.3196259f, 620.260254f, 88.1236954f, 621.701477f, 89.4348602f);
2504    pathB.cubicTo(623.116516f, 90.7225037f, 625.163269f, 91.3754272f, 627.784058f, 91.3754272f);
2505    pathB.cubicTo(630.525024f, 91.3754272f, 632.517944f, 90.8669662f, 633.876099f, 89.8208466f);
2506    pathB.cubicTo(635.291565f, 88.7314987f, 636.009705f, 87.0798492f, 636.009705f, 84.9129181f);
2507    pathB.cubicTo(636.010071f, 83.7905807f, 635.747314f, 82.7873077f, 635.22937f, 81.9311447f);
2508    pathB.close();
2509    pathB.moveTo(631.880554f, 85.7326736f);
2510    pathB.cubicTo(631.690552f, 86.0545807f, 631.436157f, 86.307869f, 631.102844f, 86.5076904f);
2511    pathB.cubicTo(630.736206f, 86.7279816f, 630.277039f, 86.8906479f, 629.737854f, 86.9903717f);
2512    pathB.cubicTo(629.146362f, 87.1003265f, 628.488892f, 87.1564484f, 627.783997f, 87.1564484f);
2513    pathB.cubicTo(626.159668f, 87.1564484f, 624.996399f, 86.8656235f, 624.327881f, 86.293457f);
2514    pathB.cubicTo(623.693604f, 85.7489777f, 623.385315f, 84.995575f, 623.385315f, 83.9896393f);
2515    pathB.cubicTo(623.385315f, 83.3655396f, 623.431519f, 82.8718567f, 623.522583f, 82.5215149f);
2516    pathB.cubicTo(623.563477f, 82.3645325f, 623.616943f, 82.2189331f, 623.684448f, 82.0824356f);
2517    pathB.lineTo(630.008179f, 82.0824356f);
2518    pathB.cubicTo(630.758911f, 82.247757f, 631.311401f, 82.5256805f, 631.650757f, 82.9101562f);
2519    pathB.cubicTo(631.990112f, 83.2942505f, 632.154663f, 83.8303986f, 632.154663f, 84.549675f);
2520    pathB.cubicTo(632.154663f, 85.02742f, 632.062927f, 85.4251709f, 631.880554f, 85.7326736f);
2521    pathB.close();
2522    pathB.moveTo(635.667664f, 69.5979919f);
2523    pathB.cubicTo(635.518311f, 69.0645142f, 635.325684f, 68.5818329f, 635.093994f, 68.1620941f);
2524    pathB.cubicTo(634.940796f, 67.8856812f, 634.770569f, 67.6316376f, 634.586304f, 67.4026184f);
2525    pathB.lineTo(635.054565f, 67.2619476f);
2526    pathB.cubicTo(635.455322f, 67.1417542f, 635.729858f, 66.7724457f, 635.729858f, 66.3538437f);
2527    pathB.lineTo(635.729858f, 64.7021942f);
2528    pathB.cubicTo(635.729858f, 64.4045486f, 635.590332f, 64.1243439f, 635.3526f, 63.9449997f);
2529    pathB.cubicTo(635.115234f, 63.7660294f, 634.807373f, 63.7087784f, 634.521057f, 63.7906761f);
2530    pathB.cubicTo(634.059998f, 63.9226265f, 633.544678f, 64.0155258f, 632.988831f, 64.0659485f);
2531    pathB.cubicTo(631.578735f, 64.1941071f, 629.921387f, 64.1565704f, 628.141968f, 64.0632935f);
2532    pathB.cubicTo(627.067383f, 64.0068054f, 625.948853f, 63.9779854f, 624.81665f, 63.9779854f);
2533    pathB.cubicTo(624.253601f, 63.9779854f, 623.681396f, 64.0359955f, 623.116089f, 64.1512604f);
2534    pathB.cubicTo(622.479126f, 64.2809448f, 621.888367f, 64.5437012f, 621.35907f, 64.9315872f);
2535    pathB.cubicTo(620.807007f, 65.3365402f, 620.360352f, 65.9159088f, 620.031189f, 66.6548996f);
2536    pathB.cubicTo(619.712708f, 67.3722839f, 619.557983f, 68.2625656f, 619.557983f, 69.3769379f);
2537    pathB.cubicTo(619.557983f, 70.4655304f, 619.669128f, 71.5268097f, 619.887878f, 72.5323639f);
2538    pathB.cubicTo(620.11499f, 73.573555f, 620.473694f, 74.5040283f, 620.954468f, 75.2983856f);
2539    pathB.cubicTo(621.196411f, 75.6976471f, 621.693481f, 75.861824f, 622.124939f, 75.6847534f);
2540    pathB.lineTo(623.832336f, 74.9851913f);
2541    pathB.cubicTo(624.086365f, 74.8809204f, 624.282776f, 74.6716156f, 624.370728f, 74.4111328f);
2542    pathB.cubicTo(624.45874f, 74.15065f, 624.429138f, 73.8651276f, 624.290405f, 73.6281509f);
2543    pathB.cubicTo(624.166382f, 73.416954f, 624.051147f, 73.1644287f, 623.947205f, 72.875885f);
2544    pathB.cubicTo(623.836853f, 72.5702744f, 623.741333f, 72.2407837f, 623.663574f, 71.8968811f);
2545    pathB.cubicTo(623.584717f, 71.549942f, 623.522217f, 71.2018585f, 623.477417f, 70.8621292f);
2546    pathB.cubicTo(623.434937f, 70.5409775f, 623.41333f, 70.2391663f, 623.41333f, 69.9646454f);
2547    pathB.cubicTo(623.41333f, 68.8229752f, 623.672729f, 68.4748993f, 623.75116f, 68.3960266f);
2548    pathB.cubicTo(623.853577f, 68.2940369f, 624.20166f, 68.0574341f, 625.236755f, 68.0574341f);
2549    pathB.cubicTo(625.39679f, 68.0574341f, 625.566284f, 68.0616074f, 625.744446f, 68.0695648f);
2550    pathB.lineTo(625.744446f, 68.7331085f);
2551    pathB.cubicTo(625.744446f, 69.8065338f, 625.819153f, 70.8048782f, 625.967041f, 71.70047f);
2552    pathB.cubicTo(626.12323f, 72.6483841f, 626.392456f, 73.4825516f, 626.767456f, 74.1794586f);
2553    pathB.cubicTo(627.173523f, 74.9328613f, 627.730957f, 75.5292969f, 628.424438f, 75.9528198f);
2554    pathB.cubicTo(629.123596f, 76.3790054f, 629.981628f, 76.5951309f, 630.975464f, 76.5951309f);
2555    pathB.cubicTo(631.722046f, 76.5951309f, 632.406799f, 76.4597626f, 633.009644f, 76.1924591f);
2556    pathB.cubicTo(633.611816f, 75.9262848f, 634.136536f, 75.5543213f, 634.567688f, 75.0875626f);
2557    pathB.cubicTo(634.998779f, 74.6223297f, 635.333191f, 74.0672302f, 635.561096f, 73.4370575f);
2558    pathB.cubicTo(635.78479f, 72.8212891f, 635.898193f, 72.1520538f, 635.898193f, 71.4479446f);
2559    pathB.cubicTo(635.898193f, 70.7688599f, 635.820496f, 70.1462708f, 635.667664f, 69.5979919f);
2560    pathB.close();
2561    pathB.moveTo(631.656494f, 71.9905396f);
2562    pathB.cubicTo(631.416077f, 72.2574692f, 631.13739f, 72.3765259f, 630.751404f, 72.3765259f);
2563    pathB.cubicTo(630.390015f, 72.3765259f, 630.239502f, 72.2536774f, 630.190247f, 72.2127228f);
2564    pathB.cubicTo(630.002197f, 72.0587845f, 629.853149f, 71.8483429f, 629.735596f, 71.5704193f);
2565    pathB.cubicTo(629.594177f, 71.2348557f, 629.494507f, 70.8310394f, 629.439453f, 70.3714905f);
2566    pathB.cubicTo(629.379211f, 69.8607559f, 629.348511f, 69.3284073f, 629.348511f, 68.7892303f);
2567    pathB.cubicTo(629.348511f, 68.5765228f, 629.351929f, 68.3603973f, 629.357971f, 68.1416168f);
2568    pathB.lineTo(630.581177f, 68.1416168f);
2569    pathB.cubicTo(630.702515f, 68.2026672f, 630.831787f, 68.2841797f, 630.967163f, 68.3857956f);
2570    pathB.cubicTo(631.149902f, 68.523056f, 631.322815f, 68.703537f, 631.480225f, 68.922699f);
2571    pathB.cubicTo(631.639038f, 69.1437531f, 631.77478f, 69.4186478f, 631.884399f, 69.7390442f);
2572    pathB.cubicTo(631.989807f, 70.0488281f, 632.04364f, 70.4169922f, 632.04364f, 70.8329391f);
2573    pathB.cubicTo(632.042847f, 71.3228302f, 631.916565f, 71.7012329f, 631.656494f, 71.9905396f);
2574    pathB.close();
2575    pathB.moveTo(622.689575f, 63.4953079f);
2576    pathB.lineTo(620.72998f, 63.4953079f);
2577    pathB.cubicTo(620.206421f, 63.4953079f, 619.782104f, 63.0710182f, 619.782104f, 62.54739f);
2578    pathB.lineTo(619.782104f, 61.3116837f);
2579    pathB.lineTo(617.958679f, 61.3116837f);
2580    pathB.cubicTo(617.536255f, 61.3116837f, 617.164307f, 61.0318604f, 617.047913f, 60.6257744f);
2581    pathB.lineTo(616.404114f, 58.3864136f);
2582    pathB.cubicTo(616.321411f, 58.1001472f, 616.378662f, 57.7922592f, 616.557678f, 57.5541458f);
2583    pathB.cubicTo(616.737061f, 57.3164062f, 617.017212f, 57.1764946f, 617.31488f, 57.1764946f);
2584    pathB.lineTo(619.782104f, 57.1764946f);
2585    pathB.lineTo(619.782104f, 54.3171997f);
2586    pathB.cubicTo(619.782104f, 53.7935715f, 620.206421f, 53.3692818f, 620.730042f, 53.3692818f);
2587    pathB.lineTo(622.689575f, 53.3692818f);
2588    pathB.cubicTo(623.213196f, 53.3692818f, 623.637512f, 53.7935715f, 623.637512f, 54.3171997f);
2589    pathB.lineTo(623.637512f, 57.1764946f);
2590    pathB.lineTo(630.443176f, 57.1764946f);
2591    pathB.cubicTo(631.548828f, 57.1764946f, 631.921936f, 57.0028381f, 632.009888f, 56.9493713f);
2592    pathB.cubicTo(632.057617f, 56.9205589f, 632.154724f, 56.8621674f, 632.154724f, 56.5288773f);
2593    pathB.cubicTo(632.154724f, 56.139473f, 632.116821f, 55.8179398f, 632.04248f, 55.5737572f);
2594    pathB.cubicTo(631.949219f, 55.268528f, 631.822205f, 54.9193192f, 631.665588f, 54.5363579f);
2595    pathB.cubicTo(631.563599f, 54.288002f, 631.572327f, 54.0085602f, 631.688354f, 53.7670288f);
2596    pathB.cubicTo(631.804749f, 53.5251198f, 632.017456f, 53.3438797f, 632.274536f, 53.2680435f);
2597    pathB.lineTo(633.9823f, 52.7641296f);
2598    pathB.cubicTo(634.430115f, 52.6325607f, 634.90332f, 52.8437576f, 635.105042f, 53.2623596f);
2599    pathB.cubicTo(635.375f, 53.8235245f, 635.59491f, 54.4404297f, 635.758301f, 55.0956268f);
2600    pathB.cubicTo(635.925537f, 55.7656174f, 636.010498f, 56.4928589f, 636.010498f, 57.2565002f);
2601    pathB.cubicTo(636.010498f, 58.7109833f, 635.553589f, 59.7790947f, 634.653076f, 60.4316406f);
2602    pathB.cubicTo(633.835938f, 61.0235176f, 632.596069f, 61.311306f, 630.863647f, 61.311306f);
2603    pathB.lineTo(623.637878f, 61.311306f);
2604    pathB.lineTo(623.637878f, 62.5470123f);
2605    pathB.cubicTo(623.637451f, 63.071022f, 623.213196f, 63.4953079f, 622.689575f, 63.4953079f);
2606    pathB.close();
2607    pathB.moveTo(635.667664f, 46.2246475f);
2608    pathB.cubicTo(635.518311f, 45.6911545f, 635.325684f, 45.2084808f, 635.093994f, 44.7887421f);
2609    pathB.cubicTo(634.940796f, 44.5123291f, 634.770569f, 44.2582855f, 634.586304f, 44.029274f);
2610    pathB.lineTo(635.054565f, 43.8886032f);
2611    pathB.cubicTo(635.455322f, 43.7684059f, 635.729858f, 43.3990974f, 635.729858f, 42.9804955f);
2612    pathB.lineTo(635.729858f, 41.328846f);
2613    pathB.cubicTo(635.729858f, 41.0312004f, 635.590332f, 40.7509995f, 635.3526f, 40.5716515f);
2614    pathB.cubicTo(635.115234f, 40.3926849f, 634.807373f, 40.3354301f, 634.521057f, 40.4173279f);
2615    pathB.cubicTo(634.059998f, 40.5492783f, 633.544678f, 40.6421738f, 632.988831f, 40.6926041f);
2616    pathB.cubicTo(631.578735f, 40.8207626f, 629.921387f, 40.7836075f, 628.141968f, 40.689949f);
2617    pathB.cubicTo(627.067383f, 40.6334534f, 625.948853f, 40.6046371f, 624.81665f, 40.6046371f);
2618    pathB.cubicTo(624.253601f, 40.6046371f, 623.681396f, 40.6626511f, 623.116089f, 40.777916f);
2619    pathB.cubicTo(622.479126f, 40.9075928f, 621.888367f, 41.1703568f, 621.35907f, 41.5582428f);
2620    pathB.cubicTo(620.807007f, 41.963192f, 620.360352f, 42.5425606f, 620.031189f, 43.2815552f);
2621    pathB.cubicTo(619.712708f, 43.9989395f, 619.557983f, 44.8892212f, 619.557983f, 46.0035934f);
2622    pathB.cubicTo(619.557983f, 47.0921783f, 619.669128f, 48.1534653f, 619.887878f, 49.1590195f);
2623    pathB.cubicTo(620.11499f, 50.2002106f, 620.473694f, 51.1306839f, 620.954468f, 51.9250374f);
2624    pathB.cubicTo(621.196411f, 52.3243027f, 621.693481f, 52.4880981f, 622.124939f, 52.311409f);
2625    pathB.lineTo(623.832336f, 51.6118431f);
2626    pathB.cubicTo(624.086365f, 51.5075722f, 624.282776f, 51.2982712f, 624.370728f, 51.0377846f);
2627    pathB.cubicTo(624.45874f, 50.777298f, 624.429138f, 50.4917831f, 624.290405f, 50.2548065f);
2628    pathB.cubicTo(624.166382f, 50.0436096f, 624.051147f, 49.7910843f, 623.947205f, 49.5025406f);
2629    pathB.cubicTo(623.836853f, 49.1969299f, 623.741333f, 48.8674355f, 623.663574f, 48.5235291f);
2630    pathB.cubicTo(623.584717f, 48.1765938f, 623.522217f, 47.8285179f, 623.477417f, 47.4887848f);
2631    pathB.cubicTo(623.434937f, 47.1676331f, 623.41333f, 46.8658142f, 623.41333f, 46.5912971f);
2632    pathB.cubicTo(623.41333f, 45.4496269f, 623.672729f, 45.1015511f, 623.75116f, 45.0226822f);
2633    pathB.cubicTo(623.853577f, 44.9206886f, 624.20166f, 44.6840897f, 625.236755f, 44.6840897f);
2634    pathB.cubicTo(625.39679f, 44.6840897f, 625.566284f, 44.6882591f, 625.744446f, 44.6962204f);
2635    pathB.lineTo(625.744446f, 45.3597641f);
2636    pathB.cubicTo(625.744446f, 46.4331856f, 625.819153f, 47.43153f, 625.967041f, 48.3271217f);
2637    pathB.cubicTo(626.12323f, 49.2750397f, 626.392456f, 50.1092072f, 626.767456f, 50.8061142f);
2638    pathB.cubicTo(627.173523f, 51.5595169f, 627.730957f, 52.1559486f, 628.424438f, 52.5794754f);
2639    pathB.cubicTo(629.123596f, 53.005661f, 629.981628f, 53.2217865f, 630.975464f, 53.2217865f);
2640    pathB.cubicTo(631.722046f, 53.2217865f, 632.406799f, 53.086422f, 633.009644f, 52.8191147f);
2641    pathB.cubicTo(633.611816f, 52.5529366f, 634.136536f, 52.1809769f, 634.567688f, 51.7142181f);
2642    pathB.cubicTo(634.998779f, 51.2489815f, 635.333191f, 50.693882f, 635.561096f, 50.0637054f);
2643    pathB.cubicTo(635.78479f, 49.4479408f, 635.898193f, 48.7787094f, 635.898193f, 48.0746002f);
2644    pathB.cubicTo(635.898193f, 47.3958893f, 635.820496f, 46.7733002f, 635.667664f, 46.2246475f);
2645    pathB.close();
2646    pathB.moveTo(631.656494f, 48.6171875f);
2647    pathB.cubicTo(631.416077f, 48.8841209f, 631.13739f, 49.0031815f, 630.751404f, 49.0031815f);
2648    pathB.cubicTo(630.390015f, 49.0031815f, 630.239502f, 48.8803291f, 630.190247f, 48.8393784f);
2649    pathB.cubicTo(630.002197f, 48.6854401f, 629.853149f, 48.4749985f, 629.735596f, 48.1970711f);
2650    pathB.cubicTo(629.594177f, 47.8615112f, 629.494507f, 47.457695f, 629.439453f, 46.9981461f);
2651    pathB.cubicTo(629.379211f, 46.4874115f, 629.348511f, 45.9550591f, 629.348511f, 45.4158859f);
2652    pathB.cubicTo(629.348511f, 45.2031708f, 629.351929f, 44.9870453f, 629.357971f, 44.7682648f);
2653    pathB.lineTo(630.581177f, 44.7682648f);
2654    pathB.cubicTo(630.702515f, 44.8293152f, 630.831787f, 44.9108353f, 630.967163f, 45.0124512f);
2655    pathB.cubicTo(631.149902f, 45.1497116f, 631.322815f, 45.3301926f, 631.480225f, 45.5493507f);
2656    pathB.cubicTo(631.639038f, 45.7704048f, 631.77478f, 46.0453033f, 631.884399f, 46.3656998f);
2657    pathB.cubicTo(631.989807f, 46.6754761f, 632.04364f, 47.0436478f, 632.04364f, 47.4595947f);
2658    pathB.cubicTo(632.042847f, 47.949852f, 631.916565f, 48.3282623f, 631.656494f, 48.6171875f);
2659    pathB.close();
2660    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2661}
2662
2663// SkOpAngle::setSector SkASSERT(fSectorStart >= 0);
2664static void skpwww_seopack_blogspot_com_2153(skiatest::Reporter* reporter, const char* filename) {
2665    SkPath path;
2666    path.setFillType(SkPath::kEvenOdd_FillType);
2667    path.moveTo(999.892212f, 246);
2668    path.lineTo(927.340759f, 245.505722f);
2669    path.quadTo(928.068054f, 246, 929, 246);
2670    path.lineTo(999.892212f, 246);
2671    path.close();
2672    path.moveTo(927.340759f, 245.505722f);
2673    path.lineTo(926.5f, 245.5f);
2674    path.lineTo(925.17157f, 246.82843f);
2675    path.quadTo(926.34314f, 248, 928, 248);
2676    path.lineTo(1000, 248);
2677    path.lineTo(1000, 246);
2678    SkPath pathB;
2679    pathB.setFillType(SkPath::kWinding_FillType);
2680    pathB.moveTo(924, 248);
2681    pathB.lineTo(924, 245.472672f);
2682    pathB.lineTo(1143, 247);
2683    pathB.lineTo(1143, 248);
2684    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2685}
2686
2687// joinCoincidence / findT / assert
2688static void skpwww_lokado_de_173(skiatest::Reporter* reporter, const char* filename) {
2689    SkPath path;
2690    path.setFillType(SkPath::kEvenOdd_FillType);
2691    path.moveTo(1000, 896.991394f);
2692    path.quadTo(999.789917f, 896.718872f, 999.535522f, 896.464478f);
2693    path.quadTo(998.071045f, 895, 996, 895);
2694    path.lineTo(956, 895);
2695    path.quadTo(951.857849f, 895, 948.928955f, 897.928955f);
2696    path.quadTo(946, 900.857849f, 946, 905);
2697    path.lineTo(946, 906);
2698    path.quadTo(946, 910.142151f, 948.928955f, 913.071045f);
2699    path.quadTo(951.857849f, 916, 956, 916);
2700    path.lineTo(996, 916);
2701    path.quadTo(998.071045f, 916, 999.535522f, 914.535522f);
2702    path.quadTo(999.789917f, 914.281128f, 1000, 914.008606f);
2703    path.lineTo(1000, 896.991394f);
2704    path.close();
2705    SkPath pathB;
2706    pathB.setFillType(SkPath::kWinding_FillType);
2707    pathB.moveTo(946, 906);
2708    pathB.lineTo(946, 905);
2709    pathB.quadTo(946, 901.272095f, 948.928955f, 898.636047f);
2710    pathB.quadTo(951.857849f, 896, 956, 896);
2711    pathB.lineTo(996, 896);
2712    pathB.quadTo(998.071045f, 896, 999.535522f, 897.17157f);
2713    pathB.quadTo(1001, 898.34314f, 1001, 900);
2714    pathB.lineTo(1001, 911);
2715    pathB.quadTo(1001, 913.071045f, 999.535522f, 914.535522f);
2716    pathB.quadTo(998.071045f, 916, 996, 916);
2717    pathB.lineTo(956, 916);
2718    pathB.quadTo(951.857849f, 916, 948.928955f, 913.071045f);
2719    pathB.quadTo(946, 910.142151f, 946, 906);
2720    pathB.close();
2721    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
2722}
2723
2724// !simple->isClosed()
2725static void skpwww_wartepop_blogspot_com_br_6(skiatest::Reporter* reporter, const char* filename) {
2726    SkPath path;
2727    path.setFillType(SkPath::kEvenOdd_FillType);
2728    path.moveTo(90.9763107f, 153.309662f);
2729    path.quadTo(91.9526215f, 152.333344f, 93.3333359f, 152.333344f);
2730    path.lineTo(124.666664f, 152.333344f);
2731    path.quadTo(126.047379f, 152.333344f, 127.023689f, 153.309662f);
2732    path.quadTo(128, 154.285965f, 128, 155.666672f);
2733    path.lineTo(128, 163.666672f);
2734    path.lineTo(90, 163.666672f);
2735    path.lineTo(90, 155.666672f);
2736    path.quadTo(90, 154.285965f, 90.9763107f, 153.309662f);
2737    path.close();
2738    SkPath pathB;
2739    pathB.setFillType(SkPath::kWinding_FillType);
2740    pathB.moveTo(90, 163.666672f);
2741    pathB.lineTo(90, 155.666672f);
2742    pathB.quadTo(90, 154.285965f, 90.9763107f, 153.309662f);
2743    pathB.quadTo(91.9526215f, 152.333344f, 93.3333359f, 152.333344f);
2744    pathB.lineTo(124.666672f, 152.333344f);
2745    pathB.quadTo(125.909309f, 152.333344f, 126.787994f, 153.309662f);
2746    pathB.quadTo(127.666672f, 154.285965f, 127.666672f, 155.666672f);
2747    pathB.lineTo(127.666672f, 163.666672f);
2748    pathB.lineTo(127.666672f, 163.666672f);
2749    pathB.lineTo(127.666672f, 163.666672f);
2750    pathB.lineTo(90, 163.666672f);
2751    pathB.lineTo(90, 163.666672f);
2752    pathB.lineTo(90, 163.666672f);
2753    pathB.close();
2754    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
2755}
2756
2757static void skpwww_wartepop_blogspot_com_br_6a(skiatest::Reporter* reporter, const char* filename) {
2758    SkPath path;
2759    path.setFillType(SkPath::kEvenOdd_FillType);
2760    path.moveTo(90.9763107f, 153.309662f);
2761    path.quadTo(91.9526215f, 152.333344f, 93.3333359f, 152.333344f);
2762    path.lineTo(124.666672f, 152.333344f);
2763    path.quadTo(126.047379f, 152.333344f, 127.023689f, 153.309662f);
2764    path.quadTo(128, 154.285965f, 128, 155.666672f);
2765    path.lineTo(128, 163.666672f);
2766    path.lineTo(90, 163.666672f);
2767    path.lineTo(90, 155.666672f);
2768    path.quadTo(90, 154.285965f, 90.9763107f, 153.309662f);
2769    path.close();
2770    SkPath pathB;
2771    pathB.setFillType(SkPath::kWinding_FillType);
2772    pathB.moveTo(90, 163.666672f);
2773    pathB.lineTo(90, 155.666672f);
2774    pathB.quadTo(90, 154.285965f, 90.9763107f, 153.309662f);
2775    pathB.quadTo(91.9526215f, 152.333344f, 93.3333359f, 152.333344f);
2776    pathB.lineTo(124.666672f, 152.333344f);
2777    pathB.quadTo(125.909309f, 152.333344f, 126.787994f, 153.309662f);
2778    pathB.quadTo(127.666672f, 154.285965f, 127.666672f, 155.666672f);
2779    pathB.lineTo(127.666672f, 163.666672f);
2780    pathB.lineTo(127.666672f, 163.666672f);
2781    pathB.lineTo(127.666672f, 163.666672f);
2782    pathB.lineTo(90, 163.666672f);
2783    pathB.lineTo(90, 163.666672f);
2784    pathB.lineTo(90, 163.666672f);
2785    pathB.close();
2786    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
2787}
2788
2789// !simple->isClosed()
2790static void skpwww_odia_com_br_26(skiatest::Reporter* reporter, const char* filename) {
2791    SkPath path;
2792    path.setFillType(SkPath::kEvenOdd_FillType);
2793    path.moveTo(360.740479f, 741.040771f);
2794    path.quadTo(360.378967f, 741, 360, 741);
2795    path.quadTo(359.159821f, 741, 358.403076f, 741.200745f);
2796    path.quadTo(357.649658f, 741.415833f, 356.92746f, 741.846436f);
2797    path.quadTo(356.600769f, 742.041199f, 356.310211f, 742.262268f);
2798    path.quadTo(356.025513f, 742.489197f, 355.757355f, 742.757385f);
2799    path.quadTo(355.16394f, 743.350769f, 354.770874f, 744.027283f);
2800    path.quadTo(354.389618f, 744.71283f, 354.183258f, 745.528564f);
2801    path.quadTo(354.090027f, 745.897095f, 354.040833f, 746.259277f);
2802    path.quadTo(354, 746.621216f, 354, 747);
2803    path.quadTo(354, 747.839844f, 354.200653f, 748.596497f);
2804    path.quadTo(354.415771f, 749.35022f, 354.846466f, 750.072632f);
2805    path.quadTo(355.040741f, 750.398438f, 355.261444f, 750.688721f);
2806    path.quadTo(355.488861f, 750.974121f, 355.757355f, 751.242615f);
2807    path.quadTo(356.352142f, 751.837402f, 357.030304f, 752.230896f);
2808    path.quadTo(357.714539f, 752.610901f, 358.528564f, 752.816833f);
2809    path.quadTo(358.895294f, 752.909607f, 359.25528f, 752.95874f);
2810    path.quadTo(359.618896f, 753, 360, 753);
2811    path.quadTo(360.842285f, 753, 361.600952f, 752.798157f);
2812    path.quadTo(362.352386f, 752.583008f, 363.072601f, 752.153625f);
2813    path.quadTo(363.397339f, 751.960022f, 363.686829f, 751.740051f);
2814    path.quadTo(363.973297f, 751.511963f, 364.242645f, 751.242615f);
2815    path.quadTo(364.837799f, 750.647461f, 365.231354f, 749.968933f);
2816    path.quadTo(365.610992f, 749.285034f, 365.816803f, 748.471497f);
2817    path.quadTo(365.909668f, 748.104431f, 365.958832f, 747.743713f);
2818    path.quadTo(366, 747.380371f, 366, 747);
2819    path.quadTo(366, 746.158997f, 365.798767f, 745.401367f);
2820    path.quadTo(365.583618f, 744.648682f, 365.153595f, 743.927429f);
2821    path.quadTo(364.959442f, 743.601807f, 364.738678f, 743.311462f);
2822    path.quadTo(364.511108f, 743.025818f, 364.242645f, 742.757385f);
2823    path.quadTo(363.649017f, 742.163757f, 362.972168f, 741.770569f);
2824    path.quadTo(362.286835f, 741.389526f, 361.471497f, 741.183289f);
2825    path.quadTo(361.102509f, 741.089966f, 360.740479f, 741.040771f);
2826    path.close();
2827    SkPath pathB;
2828    pathB.setFillType(SkPath::kWinding_FillType);
2829    pathB.moveTo(355.654724f, 739.711792f);
2830    pathB.lineTo(367.288269f, 742.654724f);
2831    pathB.lineTo(364.345337f, 754.288269f);
2832    pathB.lineTo(352.711792f, 751.345337f);
2833    pathB.close();
2834    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2835}
2836
2837static void skpwww_evolvehq_com_210(skiatest::Reporter* reporter, const char* filename) {
2838    SkPath path;
2839    path.setFillType(SkPath::kEvenOdd_FillType);
2840    path.moveTo(172, 972);
2841    path.quadTo(170.757355f, 972, 169.878677f, 972.878662f);
2842    path.quadTo(169, 973.757385f, 169, 975);
2843    path.lineTo(169, 1171);
2844    path.quadTo(169, 1172.24268f, 169.878677f, 1173.12134f);
2845    path.quadTo(170.757355f, 1174, 172, 1174);
2846    path.lineTo(308, 1174);
2847    path.quadTo(309.242645f, 1174, 310.121307f, 1173.12134f);
2848    path.quadTo(310.337311f, 1172.9054f, 310.5f, 1172.66772f);
2849    path.lineTo(310.5f, 973.332336f);
2850    path.quadTo(310.337219f, 973.094604f, 310.121307f, 972.878662f);
2851    path.quadTo(309.242645f, 972, 308, 972);
2852    path.lineTo(172, 972);
2853    path.close();
2854    SkPath pathB;
2855    pathB.setFillType(SkPath::kWinding_FillType);
2856    pathB.moveTo(170, 1171);
2857    pathB.lineTo(170, 975);
2858    pathB.quadTo(170, 974.17157f, 170.585785f, 973.585815f);
2859    pathB.quadTo(171.17157f, 973, 172, 973);
2860    pathB.lineTo(308, 973);
2861    pathB.quadTo(309.242645f, 973, 310.121307f, 973.585815f);
2862    pathB.quadTo(311, 974.17157f, 311, 975);
2863    pathB.lineTo(311, 1171);
2864    pathB.quadTo(311, 1172.24268f, 310.121307f, 1173.12134f);
2865    pathB.quadTo(309.242645f, 1174, 308, 1174);
2866    pathB.lineTo(172, 1174);
2867    pathB.quadTo(171.17157f, 1174, 170.585785f, 1173.12134f);
2868    pathB.quadTo(170, 1172.24268f, 170, 1171);
2869    pathB.close();
2870    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
2871}
2872
2873// hangs
2874static void skpwww_catingueiraonline_com_352(skiatest::Reporter* reporter, const char* filename) {
2875    SkPath path;
2876    path.setFillType(SkPath::kEvenOdd_FillType);
2877    path.moveTo(443, 8292);
2878    path.lineTo(443, 8140);
2879    path.lineTo(444, 8140);
2880    path.lineTo(444.01001f, 8292);
2881    path.lineTo(443, 8292);
2882    path.close();
2883    SkPath pathB;
2884    pathB.setFillType(SkPath::kWinding_FillType);
2885    pathB.moveTo(443, 8140);
2886    pathB.lineTo(444.01001f, 8140);
2887    pathB.lineTo(444, 8292);
2888    pathB.lineTo(443, 8292);
2889    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2890}
2891
2892// hangs
2893static void skpwww_galaxystwo_com_4(skiatest::Reporter* reporter, const char* filename) {
2894    SkPath path;
2895    path.setFillType(SkPath::kEvenOdd_FillType);
2896    path.moveTo(10105, 2510);
2897    path.lineTo(10123, 2509.98999f);
2898    path.lineTo(10123, 2511);
2899    path.lineTo(10105, 2511);
2900    path.lineTo(10105, 2510);
2901    path.close();
2902    SkPath pathB;
2903    pathB.setFillType(SkPath::kWinding_FillType);
2904    pathB.moveTo(10105, 2511);
2905    pathB.lineTo(10105, 2509.98999f);
2906    pathB.lineTo(10123, 2510);
2907    pathB.lineTo(10123, 2511);
2908    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2909}
2910
2911static void skpwww_thaienews_blogspot_com_36(skiatest::Reporter* reporter, const char* filename) {
2912    SkPath path;
2913    path.setFillType(SkPath::kEvenOdd_FillType);
2914    path.moveTo(429.994995f, 6268);
2915    path.lineTo(430, 2187);
2916    path.lineTo(430.5f, 2187);
2917    path.lineTo(430.5f, 6268);
2918    path.lineTo(429.994995f, 6268);
2919    path.close();
2920    SkPath pathB;
2921    pathB.setFillType(SkPath::kWinding_FillType);
2922    pathB.moveTo(430.5f, 2187);
2923    pathB.lineTo(429.994995f, 2187);
2924    pathB.lineTo(430, 6268);
2925    pathB.lineTo(430.5f, 6268);
2926    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2927}
2928
2929static void skpwww_fashionscandal_com_94(skiatest::Reporter* reporter, const char* filename) {
2930    SkPath path;
2931    path.setFillType(SkPath::kEvenOdd_FillType);
2932    path.moveTo(25.9107456f, 272.577423f);
2933    path.quadTo(26.1548233f, 272.333344f, 26.5000019f, 272.333344f);
2934    path.lineTo(131.166672f, 272.333344f);
2935    path.quadTo(131.511841f, 272.333344f, 131.75592f, 272.577423f);
2936    path.quadTo(132, 272.821503f, 132, 273.166687f);
2937    path.lineTo(132, 417.166656f);
2938    path.quadTo(132, 417.511841f, 131.75592f, 417.75592f);
2939    path.quadTo(131.511841f, 418, 131.166672f, 418);
2940    path.lineTo(26.5000019f, 418);
2941    path.quadTo(26.1548233f, 418, 25.9107456f, 417.75592f);
2942    path.quadTo(25.6666679f, 417.511841f, 25.6666679f, 417.166656f);
2943    path.lineTo(25.6666679f, 273.166687f);
2944    path.quadTo(25.6666679f, 272.821503f, 25.9107456f, 272.577423f);
2945    path.close();
2946    SkPath pathB;
2947    pathB.setFillType(SkPath::kWinding_FillType);
2948    pathB.moveTo(25.833334f, 417.166656f);
2949    pathB.lineTo(25.833334f, 273.166656f);
2950    pathB.quadTo(25.833334f, 272.890533f, 26.0285969f, 272.695251f);
2951    pathB.quadTo(26.2238579f, 272.5f, 26.5f, 272.5f);
2952    pathB.lineTo(131.166672f, 272.5f);
2953    pathB.quadTo(131.442825f, 272.5f, 131.638077f, 272.695251f);
2954    pathB.quadTo(131.833344f, 272.890533f, 131.833344f, 273.166656f);
2955    pathB.lineTo(131.833344f, 417.166656f);
2956    pathB.quadTo(131.833344f, 417.511841f, 131.638077f, 417.75592f);
2957    pathB.quadTo(131.442825f, 418, 131.166672f, 418);
2958    pathB.lineTo(26.5f, 418);
2959    pathB.quadTo(26.2238579f, 418, 26.0285969f, 417.75592f);
2960    pathB.quadTo(25.833334f, 417.511841f, 25.833334f, 417.166656f);
2961    pathB.close();
2962    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
2963}
2964
2965static void skpwww_kenlevine_blogspot_com_28(skiatest::Reporter* reporter, const char* filename) {
2966    SkPath path;
2967    path.setFillType(SkPath::kEvenOdd_FillType);
2968    path.moveTo(276, 9506);
2969    path.lineTo(276, 7531);
2970    path.lineTo(277, 7531);
2971    path.lineTo(277.01001f, 9506);
2972    path.lineTo(276, 9506);
2973    path.close();
2974    SkPath pathB;
2975    pathB.setFillType(SkPath::kWinding_FillType);
2976    pathB.moveTo(276, 7531);
2977    pathB.lineTo(277.01001f, 7531);
2978    pathB.lineTo(277, 9506);
2979    pathB.lineTo(276, 9506);
2980    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2981}
2982
2983static void skpwww_defense_studies_blogspot_com_64(skiatest::Reporter* reporter, const char* filename) {
2984    SkPath path;
2985    path.setFillType(SkPath::kEvenOdd_FillType);
2986    path.moveTo(276, 9600);
2987    path.lineTo(276, 7703);
2988    path.lineTo(277, 7703);
2989    path.lineTo(277.01001f, 9600);
2990    path.lineTo(276, 9600);
2991    path.close();
2992    SkPath pathB;
2993    pathB.setFillType(SkPath::kWinding_FillType);
2994    pathB.moveTo(276, 7703);
2995    pathB.lineTo(277.01001f, 7703);
2996    pathB.lineTo(277, 9600);
2997    pathB.lineTo(276, 9600);
2998    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2999}
3000
3001static void skpwww_uniquefx_net_442(skiatest::Reporter* reporter, const char* filename) {
3002    SkPath path;
3003    path.setFillType(SkPath::kEvenOdd_FillType);
3004    path.moveTo(960, 306);
3005    path.lineTo(960, 305);
3006    path.lineTo(1000, 305);
3007    path.lineTo(1000, 306.708527f);
3008    path.lineTo(960, 306);
3009    path.close();
3010    SkPath pathB;
3011    pathB.setFillType(SkPath::kWinding_FillType);
3012    pathB.moveTo(960, 305);
3013    pathB.lineTo(958.997253f, 306.002747f);
3014    pathB.lineTo(1017, 307);
3015    pathB.lineTo(1019, 305);
3016    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3017}
3018
3019static void skpwww_kitcheninspirations_wordpress_com_32(skiatest::Reporter* reporter, const char* filename) {
3020    SkPath path;
3021    path.setFillType(SkPath::kEvenOdd_FillType);
3022    path.moveTo(47.1666679f, 19651.334f);
3023    path.lineTo(65.8333359f, 19651.332f);
3024    path.lineTo(65.8333359f, 19651.5f);
3025    path.lineTo(47.1666679f, 19651.5f);
3026    path.lineTo(47.1666679f, 19651.334f);
3027    path.close();
3028    SkPath pathB;
3029    pathB.setFillType(SkPath::kWinding_FillType);
3030    pathB.moveTo(47.1666679f, 19651.5f);
3031    pathB.lineTo(47.1666679f, 19651.332f);
3032    pathB.lineTo(65.8333359f, 19651.334f);
3033    pathB.lineTo(65.8333359f, 19651.5f);
3034    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3035}
3036
3037static void skpwww_educationalcraft_com_4(skiatest::Reporter* reporter, const char* filename) {
3038    SkPath path;
3039    path.setFillType(SkPath::kEvenOdd_FillType);
3040    path.moveTo(941, 1494);
3041    path.lineTo(941, 1464);
3042    path.lineTo(985, 1464);
3043    path.lineTo(985, 1494);
3044    path.lineTo(941, 1494);
3045    path.close();
3046    SkPath pathB;
3047    pathB.setFillType(SkPath::kWinding_FillType);
3048    pathB.moveTo(979.211975f, 1480.45496f);
3049    pathB.cubicTo(979.211975f, 1480.45496f, 976.348999f, 1479.68506f, 977.495972f, 1475.59497f);
3050    pathB.cubicTo(977.497009f, 1475.59497f, 981.072021f, 1477.88501f, 979.211975f, 1480.45496f);
3051    pathB.close();
3052    pathB.moveTo(977.854004f, 1484.453f);
3053    pathB.cubicTo(977.854004f, 1484.453f, 975.265991f, 1483.26099f, 976.713989f, 1479.35205f);
3054    pathB.cubicTo(976.713989f, 1479.35303f, 979.84198f, 1482.23499f, 977.854004f, 1484.453f);
3055    pathB.close();
3056    pathB.moveTo(980.226013f, 1476.229f);
3057    pathB.cubicTo(980.226013f, 1476.229f, 977.078003f, 1476.349f, 977.234985f, 1471.97095f);
3058    pathB.cubicTo(977.234985f, 1471.97095f, 980.666992f, 1473.12903f, 980.226013f, 1476.229f);
3059    pathB.close();
3060    pathB.moveTo(984.546021f, 1478.31494f);
3061    pathB.cubicTo(984.546021f, 1478.31494f, 983.187988f, 1481.93396f, 980.026001f, 1481.276f);
3062    pathB.cubicTo(980.026978f, 1481.276f, 979.554993f, 1478.38904f, 984.546021f, 1478.31494f);
3063    pathB.close();
3064    pathB.moveTo(978.989014f, 1484.198f);
3065    pathB.cubicTo(978.989014f, 1484.198f, 979.094971f, 1481.33496f, 983.786011f, 1481.823f);
3066    pathB.cubicTo(983.786011f, 1481.823f, 982.070007f, 1485.49805f, 978.989014f, 1484.198f);
3067    pathB.close();
3068    pathB.moveTo(976.393005f, 1486.86804f);
3069    pathB.cubicTo(976.393005f, 1486.86804f, 976.719971f, 1484.06494f, 981.679016f, 1485.37f);
3070    pathB.cubicTo(981.679016f, 1485.37f, 979.169983f, 1488.40796f, 976.393005f, 1486.86804f);
3071    pathB.close();
3072    pathB.moveTo(969.156982f, 1490.40002f);
3073    pathB.cubicTo(969.156982f, 1490.40002f, 971.478027f, 1488.23596f, 974.869995f, 1491.21399f);
3074    pathB.cubicTo(974.869995f, 1491.21497f, 970.828003f, 1493.026f, 969.156982f, 1490.40002f);
3075    pathB.close();
3076    pathB.moveTo(972.825012f, 1483.93701f);
3077    pathB.cubicTo(972.825012f, 1483.93701f, 973.971985f, 1487.98401f, 971.161987f, 1488.94604f);
3078    pathB.cubicTo(971.161987f, 1488.94495f, 969.278015f, 1486.37097f, 972.825012f, 1483.93701f);
3079    pathB.close();
3080    pathB.moveTo(965.60199f, 1489.98499f);
3081    pathB.cubicTo(965.60199f, 1489.98499f, 964.879028f, 1487.19202f, 969.864014f, 1486.75f);
3082    pathB.cubicTo(969.864014f, 1486.75f, 968.749023f, 1490.672f, 965.60199f, 1489.98499f);
3083    pathB.close();
3084    pathB.moveTo(970.666992f, 1492.81604f);
3085    pathB.cubicTo(970.666992f, 1492.81604f, 967.327026f, 1494.49695f, 964.999023f, 1491.56299f);
3086    pathB.cubicTo(964.999023f, 1491.56299f, 967.304016f, 1489.43896f, 970.666992f, 1492.81604f);
3087    pathB.close();
3088    pathB.moveTo(968.343994f, 1481.53796f);
3089    pathB.cubicTo(971.573975f, 1479.94995f, 971.687988f, 1476.78601f, 971.687988f, 1476.78601f);
3090    pathB.lineTo(971.393982f, 1466.83398f);
3091    pathB.lineTo(954.960999f, 1466.83398f);
3092    pathB.lineTo(954.666016f, 1476.78601f);
3093    pathB.cubicTo(954.666016f, 1476.78601f, 954.780029f, 1479.94995f, 958.008972f, 1481.53796f);
3094    pathB.cubicTo(960.781006f, 1482.90295f, 962.166992f, 1484.77698f, 962.166992f, 1484.77698f);
3095    pathB.cubicTo(962.166992f, 1484.77698f, 962.747986f, 1485.70105f, 963.177979f, 1485.70105f);
3096    pathB.cubicTo(963.606995f, 1485.70105f, 964.185974f, 1484.77698f, 964.185974f, 1484.77698f);
3097    pathB.cubicTo(964.185974f, 1484.77698f, 965.573975f, 1482.90295f, 968.343994f, 1481.53796f);
3098    pathB.close();
3099    pathB.moveTo(963.215027f, 1486.67004f);
3100    pathB.cubicTo(962.744995f, 1486.67004f, 962.106995f, 1485.65405f, 962.106995f, 1485.65405f);
3101    pathB.cubicTo(962.106995f, 1485.65405f, 960.585022f, 1483.59595f, 957.539001f, 1482.09705f);
3102    pathB.cubicTo(953.991028f, 1480.35205f, 953.867004f, 1476.87598f, 953.867004f, 1476.87598f);
3103    pathB.lineTo(954.190002f, 1465.94397f);
3104    pathB.lineTo(972.23999f, 1465.94397f);
3105    pathB.lineTo(972.565002f, 1476.87695f);
3106    pathB.cubicTo(972.565002f, 1476.87695f, 972.440979f, 1480.35303f, 968.891968f, 1482.09802f);
3107    pathB.cubicTo(965.846008f, 1483.59705f, 964.325012f, 1485.65503f, 964.325012f, 1485.65503f);
3108    pathB.cubicTo(964.325012f, 1485.65503f, 963.687012f, 1486.67004f, 963.215027f, 1486.67004f);
3109    pathB.close();
3110    pathB.moveTo(960.68103f, 1489.98499f);
3111    pathB.cubicTo(957.533997f, 1490.672f, 956.417969f, 1486.75f, 956.417969f, 1486.75f);
3112    pathB.cubicTo(961.403015f, 1487.19202f, 960.68103f, 1489.98499f, 960.68103f, 1489.98499f);
3113    pathB.close();
3114    pathB.moveTo(963.143005f, 1489.59802f);
3115    pathB.cubicTo(963.763f, 1489.59802f, 964.265015f, 1490.09998f, 964.265015f, 1490.72095f);
3116    pathB.cubicTo(964.265015f, 1491.34204f, 963.763f, 1491.84399f, 963.143005f, 1491.84399f);
3117    pathB.cubicTo(962.521973f, 1491.84399f, 962.02002f, 1491.34204f, 962.02002f, 1490.72095f);
3118    pathB.cubicTo(962.02002f, 1490.09998f, 962.521973f, 1489.59802f, 963.143005f, 1489.59802f);
3119    pathB.close();
3120    pathB.moveTo(961.283997f, 1491.56299f);
3121    pathB.cubicTo(958.953979f, 1494.49695f, 955.61499f, 1492.81604f, 955.61499f, 1492.81604f);
3122    pathB.cubicTo(958.97699f, 1489.43896f, 961.283997f, 1491.56299f, 961.283997f, 1491.56299f);
3123    pathB.close();
3124    pathB.moveTo(957.127014f, 1490.40002f);
3125    pathB.cubicTo(955.455017f, 1493.026f, 951.414001f, 1491.21399f, 951.414001f, 1491.21399f);
3126    pathB.cubicTo(954.802979f, 1488.23596f, 957.127014f, 1490.40002f, 957.127014f, 1490.40002f);
3127    pathB.close();
3128    pathB.moveTo(949.890991f, 1486.86804f);
3129    pathB.cubicTo(947.112976f, 1488.40796f, 944.604004f, 1485.37f, 944.604004f, 1485.37f);
3130    pathB.cubicTo(949.562012f, 1484.06494f, 949.890991f, 1486.86804f, 949.890991f, 1486.86804f);
3131    pathB.close();
3132    pathB.moveTo(947.070984f, 1480.45496f);
3133    pathB.cubicTo(945.211975f, 1477.88501f, 948.786011f, 1475.59497f, 948.786011f, 1475.59497f);
3134    pathB.cubicTo(949.934021f, 1479.68506f, 947.070984f, 1480.45496f, 947.070984f, 1480.45496f);
3135    pathB.close();
3136    pathB.moveTo(946.054016f, 1476.229f);
3137    pathB.cubicTo(945.61499f, 1473.12903f, 949.046997f, 1471.97095f, 949.046997f, 1471.97095f);
3138    pathB.cubicTo(949.205994f, 1476.349f, 946.054016f, 1476.229f, 946.054016f, 1476.229f);
3139    pathB.close();
3140    pathB.moveTo(948.427002f, 1484.453f);
3141    pathB.cubicTo(946.440002f, 1482.23499f, 949.567993f, 1479.35205f, 949.567993f, 1479.35205f);
3142    pathB.cubicTo(951.015991f, 1483.26099f, 948.427002f, 1484.453f, 948.427002f, 1484.453f);
3143    pathB.close();
3144    pathB.moveTo(947.294006f, 1484.198f);
3145    pathB.cubicTo(944.210999f, 1485.49805f, 942.495972f, 1481.823f, 942.495972f, 1481.823f);
3146    pathB.cubicTo(947.187988f, 1481.33496f, 947.294006f, 1484.198f, 947.294006f, 1484.198f);
3147    pathB.close();
3148    pathB.moveTo(946.255005f, 1481.276f);
3149    pathB.cubicTo(943.094971f, 1481.93396f, 941.736023f, 1478.31494f, 941.736023f, 1478.31494f);
3150    pathB.cubicTo(946.728027f, 1478.38904f, 946.255005f, 1481.276f, 946.255005f, 1481.276f);
3151    pathB.close();
3152    pathB.moveTo(945.312988f, 1478.18005f);
3153    pathB.cubicTo(942.052979f, 1477.80103f, 942.651001f, 1473.87805f, 942.651001f, 1473.87805f);
3154    pathB.cubicTo(946.562988f, 1475.66199f, 945.312988f, 1478.18005f, 945.312988f, 1478.18005f);
3155    pathB.close();
3156    pathB.moveTo(945.382019f, 1474.328f);
3157    pathB.cubicTo(942.924011f, 1472.729f, 944.492004f, 1469.48706f, 944.492004f, 1469.48706f);
3158    pathB.cubicTo(947.388977f, 1471.95703f, 945.382019f, 1474.328f, 945.382019f, 1474.328f);
3159    pathB.close();
3160    pathB.moveTo(946.797974f, 1470.27405f);
3161    pathB.cubicTo(944.664978f, 1467.90198f, 947.083984f, 1465.50598f, 947.083984f, 1465.50598f);
3162    pathB.cubicTo(949.145996f, 1468.82605f, 946.797974f, 1470.27405f, 946.797974f, 1470.27405f);
3163    pathB.close();
3164    pathB.moveTo(947.392029f, 1471.64197f);
3165    pathB.cubicTo(947.624023f, 1468.56299f, 951.361023f, 1468.29199f, 951.361023f, 1468.29199f);
3166    pathB.cubicTo(950.554016f, 1471.98499f, 947.392029f, 1471.64197f, 947.392029f, 1471.64197f);
3167    pathB.close();
3168    pathB.moveTo(948.64801f, 1468.15002f);
3169    pathB.cubicTo(948.638977f, 1465.22095f, 952.265991f, 1464.46399f, 952.265991f, 1464.46399f);
3170    pathB.cubicTo(951.672974f, 1468.53101f, 948.64801f, 1468.15002f, 948.64801f, 1468.15002f);
3171    pathB.close();
3172    pathB.moveTo(951.176025f, 1486.97803f);
3173    pathB.cubicTo(948.963013f, 1484.62f, 951.361023f, 1481.77698f, 951.361023f, 1481.77698f);
3174    pathB.cubicTo(953.734985f, 1485.48596f, 951.176025f, 1486.97803f, 951.176025f, 1486.97803f);
3175    pathB.close();
3176    pathB.moveTo(947.51001f, 1488.53101f);
3177    pathB.cubicTo(947.51001f, 1488.53101f, 951.596985f, 1486.32202f, 953.234009f, 1489.08997f);
3178    pathB.cubicTo(953.234009f, 1489.08997f, 951.158997f, 1491.03601f, 947.51001f, 1488.53101f);
3179    pathB.close();
3180    pathB.moveTo(955.120972f, 1488.94495f);
3181    pathB.cubicTo(952.309021f, 1487.98303f, 953.458984f, 1483.93604f, 953.458984f, 1483.93604f);
3182    pathB.cubicTo(957.004028f, 1486.37097f, 955.120972f, 1488.94495f, 955.120972f, 1488.94495f);
3183    pathB.close();
3184    pathB.moveTo(978.770996f, 1488.53101f);
3185    pathB.cubicTo(975.122986f, 1491.03601f, 973.047974f, 1489.08997f, 973.047974f, 1489.08997f);
3186    pathB.cubicTo(974.684998f, 1486.32202f, 978.770996f, 1488.53101f, 978.770996f, 1488.53101f);
3187    pathB.close();
3188    pathB.moveTo(975.106995f, 1486.97803f);
3189    pathB.cubicTo(975.106995f, 1486.97803f, 972.546997f, 1485.48706f, 974.919983f, 1481.77698f);
3190    pathB.cubicTo(974.919983f, 1481.776f, 977.31897f, 1484.61902f, 975.106995f, 1486.97803f);
3191    pathB.close();
3192    pathB.moveTo(974.016968f, 1464.46399f);
3193    pathB.cubicTo(974.016968f, 1464.46399f, 977.643982f, 1465.22095f, 977.633972f, 1468.15002f);
3194    pathB.cubicTo(977.633972f, 1468.15002f, 974.611023f, 1468.53101f, 974.016968f, 1464.46399f);
3195    pathB.close();
3196    pathB.moveTo(974.919983f, 1468.29199f);
3197    pathB.cubicTo(974.919983f, 1468.29199f, 978.658997f, 1468.56299f, 978.890015f, 1471.64197f);
3198    pathB.cubicTo(978.890015f, 1471.64197f, 975.72699f, 1471.98499f, 974.919983f, 1468.29199f);
3199    pathB.close();
3200    pathB.moveTo(979.197998f, 1465.50598f);
3201    pathB.cubicTo(979.197998f, 1465.50598f, 981.619019f, 1467.90198f, 979.481995f, 1470.27405f);
3202    pathB.cubicTo(979.481995f, 1470.27405f, 977.138f, 1468.82605f, 979.197998f, 1465.50598f);
3203    pathB.close();
3204    pathB.moveTo(980.900024f, 1474.328f);
3205    pathB.cubicTo(980.900024f, 1474.328f, 978.893005f, 1471.95703f, 981.791016f, 1469.48706f);
3206    pathB.cubicTo(981.791016f, 1469.48596f, 983.358032f, 1472.729f, 980.900024f, 1474.328f);
3207    pathB.close();
3208    pathB.moveTo(980.968994f, 1478.18005f);
3209    pathB.cubicTo(980.968994f, 1478.18005f, 979.718018f, 1475.66199f, 983.632019f, 1473.87805f);
3210    pathB.cubicTo(983.632019f, 1473.87805f, 984.229004f, 1477.80103f, 980.968994f, 1478.18005f);
3211    pathB.close();
3212    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3213}
3214
3215static void skpwww_narayana_publishers_com_194(skiatest::Reporter* reporter, const char* filename) {
3216    SkPath path;
3217    path.setFillType(SkPath::kEvenOdd_FillType);
3218    path.moveTo(1083.34314f, 445.65686f);
3219    path.quadTo(1081, 443.313721f, 1081, 440);
3220    path.lineTo(1257, 440);
3221    path.quadTo(1257, 443.313721f, 1254.65686f, 445.65686f);
3222    path.quadTo(1252.31372f, 448, 1249, 448);
3223    path.lineTo(1089, 448);
3224    path.quadTo(1085.68628f, 448, 1083.34314f, 445.65686f);
3225    path.close();
3226    path.moveTo(1083, 441);
3227    path.lineTo(1255, 441);
3228    path.quadTo(1255, 443.071075f, 1253.53552f, 444.535522f);
3229    path.quadTo(1252.07104f, 446, 1250, 446);
3230    path.lineTo(1088, 446);
3231    path.quadTo(1085.92896f, 446, 1084.46448f, 444.535522f);
3232    path.quadTo(1083, 443.071075f, 1083, 441);
3233    path.close();
3234    SkPath pathB;
3235    pathB.setFillType(SkPath::kWinding_FillType);
3236    pathB.moveTo(1081, 440);
3237    pathB.lineTo(1082, 440);
3238    pathB.lineTo(1090.01001f, 448);
3239    pathB.lineTo(1081, 448);
3240    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3241}
3242
3243static void skpwww_cooksnaps_com_17(skiatest::Reporter* reporter, const char* filename) {
3244    SkPath path;
3245    path.setFillType(SkPath::kEvenOdd_FillType);
3246    path.moveTo(170.340179f, 176);
3247    path.lineTo(166, 176);
3248    path.quadTo(161.964188f, 176, 158.299957f, 176.896912f);
3249    path.quadTo(154.678162f, 177.952271f, 151.183014f, 179.9702f);
3250    path.lineTo(150.316986f, 180.4702f);
3251    path.quadTo(146.175812f, 182.861099f, 143.115921f, 186.081696f);
3252    path.quadTo(140.693939f, 188.70134f, 138.99472f, 191.620407f);
3253    path.quadTo(137.316833f, 194.550888f, 136.259338f, 197.957367f);
3254    path.quadTo(135, 202.217865f, 135, 207);
3255    path.lineTo(135, 208);
3256    path.quadTo(135, 212.035751f, 135.896912f, 215.699997f);
3257    path.quadTo(136.952286f, 219.321869f, 138.9702f, 222.816986f);
3258    path.lineTo(139.4702f, 223.683014f);
3259    path.quadTo(141.861099f, 227.824188f, 145.081696f, 230.884079f);
3260    path.quadTo(147.70134f, 233.306061f, 150.620407f, 235.00528f);
3261    path.quadTo(153.550888f, 236.683167f, 156.957367f, 237.740662f);
3262    path.quadTo(161.217865f, 239, 166, 239);
3263    path.lineTo(170.482162f, 239);
3264    path.quadTo(176.307037f, 238.210968f, 181.816986f, 235.0298f);
3265    path.lineTo(182.683014f, 234.5298f);
3266    path.quadTo(182.686462f, 234.527817f, 182.689896f, 234.525818f);
3267    path.quadTo(193.804352f, 228.105652f, 197.126709f, 215.70639f);
3268    path.quadTo(200.450104f, 203.303314f, 194.0298f, 192.183014f);
3269    path.lineTo(193.5298f, 191.316986f);
3270    path.quadTo(187.109497f, 180.196686f, 174.706406f, 176.873276f);
3271    path.quadTo(172.503067f, 176.282898f, 170.340179f, 176);
3272    path.close();
3273    SkPath pathB;
3274    pathB.setFillType(SkPath::kWinding_FillType);
3275    pathB.moveTo(139.4702f, 223.683014f);
3276    pathB.lineTo(138.9702f, 222.816986f);
3277    pathB.quadTo(132.549896f, 211.696686f, 135.873291f, 199.293594f);
3278    pathB.quadTo(139.196686f, 186.890503f, 150.316986f, 180.4702f);
3279    pathB.lineTo(151.183014f, 179.9702f);
3280    pathB.quadTo(162.303314f, 173.549896f, 174.706406f, 176.873276f);
3281    pathB.quadTo(187.109497f, 180.196686f, 193.5298f, 191.316986f);
3282    pathB.lineTo(194.0298f, 192.183014f);
3283    pathB.quadTo(200.450104f, 203.303314f, 197.126709f, 215.70639f);
3284    pathB.quadTo(193.803314f, 228.109497f, 182.683014f, 234.5298f);
3285    pathB.lineTo(181.816986f, 235.0298f);
3286    pathB.quadTo(170.696686f, 241.450104f, 158.293594f, 238.126709f);
3287    pathB.quadTo(145.890503f, 234.803314f, 139.4702f, 223.683014f);
3288    pathB.close();
3289    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3290}
3291
3292static void skpwww_swapspacesystems_com_5(skiatest::Reporter* reporter, const char* filename) {
3293    SkPath path;
3294    path.setFillType(SkPath::kEvenOdd_FillType);
3295    path.moveTo(819.050781f, 5539.72412f);
3296    path.quadTo(819.651672f, 5539.1543f, 820.479858f, 5539.17578f);
3297    path.lineTo(1191.35278f, 5548.8877f);
3298    path.quadTo(1192.18091f, 5548.90918f, 1192.7511f, 5549.50977f);
3299    path.quadTo(1193.32141f, 5550.11133f, 1193.29968f, 5550.93945f);
3300    path.lineTo(1186.57214f, 5807.85107f);
3301    path.quadTo(1186.55054f, 5808.6792f, 1185.94958f, 5809.24951f);
3302    path.quadTo(1185.34863f, 5809.81982f, 1184.52051f, 5809.79834f);
3303    path.lineTo(813.647705f, 5800.08643f);
3304    path.quadTo(812.819519f, 5800.06494f, 812.249268f, 5799.46387f);
3305    path.quadTo(811.679016f, 5798.86279f, 811.700684f, 5798.03467f);
3306    path.lineTo(818.428162f, 5541.12305f);
3307    path.quadTo(818.44989f, 5540.29492f, 819.050781f, 5539.72412f);
3308    path.close();
3309    SkPath pathB;
3310    pathB.setFillType(SkPath::kWinding_FillType);
3311    pathB.moveTo(818.48053f, 5539.12354f);
3312    pathB.lineTo(1193.35205f, 5548.93994f);
3313    pathB.lineTo(1186.5199f, 5809.85059f);
3314    pathB.lineTo(811.648376f, 5800.03418f);
3315    pathB.close();
3316    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3317}
3318
3319static void skpwww_kitcheninspirations_wordpress_com_66(skiatest::Reporter* reporter, const char* filename) {
3320    SkPath path;
3321    path.setFillType(SkPath::kEvenOdd_FillType);
3322    path.moveTo(47.1666679f, 27820.668f);
3323    path.lineTo(60.8333359f, 27820.668f);
3324    path.lineTo(60.8333359f, 27820.498f);
3325    path.lineTo(47.1666679f, 27820.5f);
3326    path.lineTo(47.1666679f, 27820.668f);
3327    path.close();
3328    SkPath pathB;
3329    pathB.setFillType(SkPath::kWinding_FillType);
3330    pathB.moveTo(47.1666679f, 27820.668f);
3331    pathB.lineTo(47.1666679f, 27820.498f);
3332    pathB.lineTo(60.8333359f, 27820.5f);
3333    pathB.lineTo(60.8333359f, 27820.668f);
3334    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3335}
3336
3337static void skpwww_etiqadd_com_2464(skiatest::Reporter* reporter, const char* filename) {
3338    SkPath path;
3339    path.setFillType(SkPath::kEvenOdd_FillType);
3340    path.moveTo(630.378662f, 1293.42896f);
3341    path.quadTo(631.257385f, 1292.55029f, 632.5f, 1292.55029f);
3342    path.quadTo(633.742615f, 1292.55029f, 634.621338f, 1293.42896f);
3343    path.lineTo(639.571045f, 1298.37866f);
3344    path.quadTo(640.449768f, 1299.25732f, 640.449707f, 1300.5f);
3345    path.quadTo(640.449768f, 1301.74268f, 639.571045f, 1302.62134f);
3346    path.lineTo(634.621338f, 1307.57104f);
3347    path.quadTo(633.742615f, 1308.44971f, 632.5f, 1308.44971f);
3348    path.quadTo(631.257385f, 1308.44971f, 630.378662f, 1307.57104f);
3349    path.lineTo(625.428955f, 1302.62134f);
3350    path.quadTo(624.550232f, 1301.74268f, 624.550293f, 1300.5f);
3351    path.quadTo(624.550232f, 1299.25732f, 625.428955f, 1298.37866f);
3352    path.lineTo(630.378662f, 1293.42896f);
3353    path.close();
3354    SkPath pathB;
3355    pathB.setFillType(SkPath::kWinding_FillType);
3356    pathB.moveTo(632.5f, 1291.30762f);
3357    pathB.lineTo(641.692383f, 1300.5f);
3358    pathB.lineTo(632.5f, 1309.69238f);
3359    pathB.lineTo(623.307617f, 1300.5f);
3360    pathB.close();
3361    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3362}
3363
3364static void skpwww_narayana_verlag_de_194(skiatest::Reporter* reporter, const char* filename) {
3365    SkPath path;
3366    path.setFillType(SkPath::kEvenOdd_FillType);
3367    path.moveTo(1083.34314f, 513.65686f);
3368    path.quadTo(1081, 511.313721f, 1081, 508);
3369    path.lineTo(1257, 508);
3370    path.quadTo(1257, 511.313721f, 1254.65686f, 513.65686f);
3371    path.quadTo(1252.31372f, 516, 1249, 516);
3372    path.lineTo(1089, 516);
3373    path.quadTo(1085.68628f, 516, 1083.34314f, 513.65686f);
3374    path.close();
3375    path.moveTo(1083, 509);
3376    path.lineTo(1255, 509);
3377    path.quadTo(1255, 511.071075f, 1253.53552f, 512.535522f);
3378    path.quadTo(1252.07104f, 514, 1250, 514);
3379    path.lineTo(1088, 514);
3380    path.quadTo(1085.92896f, 514, 1084.46448f, 512.535522f);
3381    path.quadTo(1083, 511.071075f, 1083, 509);
3382    path.close();
3383    SkPath pathB;
3384    pathB.setFillType(SkPath::kWinding_FillType);
3385    pathB.moveTo(1081, 508);
3386    pathB.lineTo(1082, 508);
3387    pathB.lineTo(1090.01001f, 516);
3388    pathB.lineTo(1081, 516);
3389    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3390}
3391
3392static void skpwww_americascup_com_108(skiatest::Reporter* reporter, const char* filename) {
3393    SkPath path;
3394    path.setFillType(SkPath::kEvenOdd_FillType);
3395    path.moveTo(999.454102f, 689.17157f);
3396    path.quadTo(1001.172f, 688, 1002.82886f, 688);
3397    path.lineTo(1013.82886f, 688);
3398    path.lineTo(1002.17114f, 713);
3399    path.lineTo(991.171143f, 713);
3400    path.quadTo(989.514282f, 713, 988.889038f, 711.82843f);
3401    path.quadTo(988.263794f, 710.65686f, 989.036377f, 709);
3402    path.lineTo(996.963623f, 692);
3403    path.quadTo(997.736206f, 690.34314f, 999.454102f, 689.17157f);
3404    path.close();
3405    SkPath pathB;
3406    pathB.setFillType(SkPath::kWinding_FillType);
3407    pathB.moveTo(998.828857f, 688);
3408    pathB.lineTo(1013.82886f, 688);
3409    pathB.lineTo(1002.17114f, 713);
3410    pathB.lineTo(987.171143f, 713);
3411    pathB.close();
3412    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3413}
3414
3415static void skpwww_vantageproduction_com_109(skiatest::Reporter* reporter, const char* filename) {
3416    SkPath path;
3417    path.setFillType(SkPath::kEvenOdd_FillType);
3418    path.moveTo(794.514709f, 759.485291f);
3419    path.quadTo(791, 755.970581f, 791, 751);
3420    path.lineTo(1133, 751);
3421    path.quadTo(1133, 755.970581f, 1129.48523f, 759.485291f);
3422    path.quadTo(1125.97058f, 763, 1121, 763);
3423    path.lineTo(803, 763);
3424    path.quadTo(798.029419f, 763, 794.514709f, 759.485291f);
3425    path.close();
3426    path.moveTo(793, 752);
3427    path.lineTo(1131, 752);
3428    path.quadTo(1131, 755.727905f, 1128.36401f, 758.363953f);
3429    path.quadTo(1125.72791f, 761, 1122, 761);
3430    path.lineTo(802, 761);
3431    path.quadTo(798.272095f, 761, 795.636047f, 758.363953f);
3432    path.quadTo(793, 755.727905f, 793, 752);
3433    path.close();
3434    SkPath pathB;
3435    pathB.setFillType(SkPath::kWinding_FillType);
3436    pathB.moveTo(791, 751);
3437    pathB.lineTo(792, 751);
3438    pathB.lineTo(804.01001f, 763);
3439    pathB.lineTo(791, 763);
3440    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3441}
3442
3443static void skpwww_aceinfographics_com_106(skiatest::Reporter* reporter, const char* filename) {
3444    SkPath path;
3445    path.setFillType(SkPath::kEvenOdd_FillType);
3446    path.moveTo(166.878677f, 7638.87891f);
3447    path.quadTo(166, 7639.75732f, 166, 7641);
3448    path.lineTo(166, 11577);
3449    path.quadTo(166, 11578.2422f, 166.878677f, 11579.1211f);
3450    path.quadTo(167.388f, 11579.6309f, 168.019989f, 11579.8447f);
3451    path.lineTo(168.019974f, 11576.2979f);
3452    path.quadTo(168, 11576.1533f, 168, 11576);
3453    path.lineTo(168, 7642);
3454    path.lineTo(168.000015f, 7641.99316f);
3455    path.lineTo(168, 7640);
3456    path.lineTo(166.878677f, 7638.87891f);
3457    path.close();
3458    SkPath pathB;
3459    pathB.setFillType(SkPath::kWinding_FillType);
3460    pathB.moveTo(166, 7638);
3461    pathB.lineTo(168.020004f, 7635.97998f);
3462    pathB.lineTo(168, 11578);
3463    pathB.lineTo(166, 11580);
3464    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3465}
3466
3467static void skpwww_tcmevents_org_13(skiatest::Reporter* reporter, const char* filename) {
3468    SkPath path;
3469    path.setFillType(SkPath::kEvenOdd_FillType);
3470    path.moveTo(465.951904f, 547.960144f);
3471    path.quadTo(465.66571f, 546.867371f, 465.404938f, 546);
3472    path.lineTo(465.504089f, 546);
3473    path.quadTo(465.670349f, 546.601257f, 465.84668f, 547.288391f);
3474    path.quadTo(467.274506f, 552.852356f, 468.506836f, 560.718567f);
3475    path.quadTo(467.336121f, 553.24585f, 465.951904f, 547.960144f);
3476    path.close();
3477    path.moveTo(470.591064f, 574.024353f);
3478    path.quadTo(474.844055f, 601.176025f, 471.728271f, 620.364502f);
3479    path.quadTo(470.567017f, 627.515991f, 468.635742f, 632);
3480    path.lineTo(469.106812f, 632);
3481    path.quadTo(470.791504f, 627.638672f, 471.833496f, 621.036255f);
3482    path.quadTo(474.905701f, 601.569519f, 470.591064f, 574.024353f);
3483    path.close();
3484    SkPath pathB;
3485    pathB.setFillType(SkPath::kWinding_FillType);
3486    pathB.moveTo(322.992462f, 541.475708f);
3487    pathB.lineTo(465.531616f, 541.724426f);
3488    pathB.lineTo(468.507751f, 560.724426f);
3489    pathB.lineTo(325.968597f, 560.475708f);
3490    pathB.close();
3491    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3492}
3493
3494static void skpwww_paseoitaigara_com_br_56(skiatest::Reporter* reporter, const char* filename) {
3495    SkPath path;
3496    path.setFillType(SkPath::kEvenOdd_FillType);
3497    path.moveTo(633.147217f, 1247);
3498    path.lineTo(718, 1162.14722f);
3499    path.lineTo(802.852783f, 1247);
3500    path.lineTo(718, 1331.85278f);
3501    path.lineTo(633.147217f, 1247);
3502    path.close();
3503    SkPath pathB;
3504    pathB.setFillType(SkPath::kWinding_FillType);
3505    pathB.moveTo(635.268494f, 1244.87866f);
3506    pathB.lineTo(715.878662f, 1164.26855f);
3507    pathB.quadTo(716.757385f, 1163.38989f, 718, 1163.38989f);
3508    pathB.quadTo(719.242615f, 1163.38989f, 720.121338f, 1164.26855f);
3509    pathB.lineTo(800.731506f, 1244.87866f);
3510    pathB.quadTo(801.610168f, 1245.75732f, 801.610168f, 1247);
3511    pathB.quadTo(801.610229f, 1248.24268f, 800.731445f, 1249.12134f);
3512    pathB.lineTo(720.121338f, 1329.73145f);
3513    pathB.quadTo(719.242676f, 1330.61011f, 718, 1330.61011f);
3514    pathB.quadTo(716.757385f, 1330.61011f, 715.878723f, 1329.73145f);
3515    pathB.lineTo(635.268555f, 1249.12134f);
3516    pathB.quadTo(634.389832f, 1248.24268f, 634.389832f, 1247);
3517    pathB.quadTo(634.389832f, 1245.75732f, 635.268494f, 1244.87866f);
3518    pathB.close();
3519    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3520}
3521
3522static void skpwww_mortgagemarketguide_com_109(skiatest::Reporter* reporter, const char* filename) {
3523    SkPath path;
3524    path.setFillType(SkPath::kEvenOdd_FillType);
3525    path.moveTo(816.514709f, 781.485291f);
3526    path.quadTo(813, 777.970581f, 813, 773);
3527    path.lineTo(1133, 773);
3528    path.quadTo(1133, 777.970581f, 1129.48523f, 781.485291f);
3529    path.quadTo(1125.97058f, 785, 1121, 785);
3530    path.lineTo(825, 785);
3531    path.quadTo(820.029419f, 785, 816.514709f, 781.485291f);
3532    path.close();
3533    path.moveTo(815, 774);
3534    path.lineTo(1131, 774);
3535    path.quadTo(1131, 777.727905f, 1128.36401f, 780.363953f);
3536    path.quadTo(1125.72791f, 783, 1122, 783);
3537    path.lineTo(824, 783);
3538    path.quadTo(820.272095f, 783, 817.636047f, 780.363953f);
3539    path.quadTo(815, 777.727905f, 815, 774);
3540    path.close();
3541    SkPath pathB;
3542    pathB.setFillType(SkPath::kWinding_FillType);
3543    pathB.moveTo(813, 773);
3544    pathB.lineTo(814, 773);
3545    pathB.lineTo(826.01001f, 785);
3546    pathB.lineTo(813, 785);
3547    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3548}
3549
3550static void (*firstTest)(skiatest::Reporter* , const char* filename) = 0;
3551
3552static struct TestDesc tests[] = {
3553    TEST(skpwww_wartepop_blogspot_com_br_6),
3554    TEST(skpwww_wartepop_blogspot_com_br_6a),
3555    TEST(skpwww_cooksnaps_com_32a),
3556    TEST(skpwww_argus_presse_fr_41),
3557    TEST(skpwww_cooksnaps_com_17),
3558    TEST(skpwww_cooksnaps_com_32),
3559    TEST(skpwww_kitcheninspirations_wordpress_com_66),
3560    TEST(skpwww_tcmevents_org_13),
3561    TEST(skpwww_narayana_publishers_com_194),
3562    TEST(skpwww_swapspacesystems_com_5),
3563    TEST(skpwww_vantageproduction_com_109),
3564    TEST(skpwww_americascup_com_108),
3565    TEST(skpwww_narayana_verlag_de_194),
3566    TEST(skpwww_etiqadd_com_2464),
3567    TEST(skpwww_paseoitaigara_com_br_56),
3568    TEST(skpwww_mortgagemarketguide_com_109),
3569    TEST(skpwww_aceinfographics_com_106),
3570    TEST(skpwww_educationalcraft_com_4),
3571    TEST(skpwww_kitcheninspirations_wordpress_com_32),
3572    TEST(skpwww_artblart_com_8),
3573    TEST(skpwww_docgelo_com_66),
3574    TEST(skpwww_uniquefx_net_442),
3575    TEST(skpwww_defense_studies_blogspot_com_64),
3576    TEST(skpwww_kenlevine_blogspot_com_28),
3577    TEST(skpwww_fashionscandal_com_94),
3578    TEST(skpwww_thaienews_blogspot_com_36),
3579    TEST(skpwww_galaxystwo_com_4),
3580    TEST(skpwww_catingueiraonline_com_352),
3581    TEST(skpwww_evolvehq_com_210),
3582    TEST(skpwww_odia_com_br_26),
3583    TEST(skpwww_lokado_de_173),
3584    TEST(skpwww_seopack_blogspot_com_2153),
3585    TEST(skpwww_partsdata_de_53),
3586    TEST(skpwww_simplysaru_com_40),
3587    TEST(skpwww_jessicaslens_wordpress_com_222),
3588    TEST(skpwww_kpopexplorer_net_22),
3589    TEST(skpwww_tunero_de_24),
3590    TEST(skpwww_karnivool_com_au_11),
3591    TEST(skpwww_pindosiya_com_99),
3592    TEST(skpwww_contextualnewsfeeds_com_346),
3593    TEST(skpwww_helha_be_109),
3594    TEST(skpwww_phototransferapp_com_24),
3595    TEST(skpwww_phototransferapp_com_24x),
3596    TEST(skpwww_gruposejaumdivulgador_com_br_4),
3597    TEST(skpwww_hubbyscook_com_22),
3598    TEST(skpwww_maturesupertube_com_21),
3599    TEST(skpwww_getgold_jp_731),
3600    TEST(skpwww_trashness_com_36),
3601    TEST(skpwww_exystence_net_61),
3602    TEST(skpwww_320kbps_net_2231),
3603    TEST(skpwww_heartiste_wordpress_com_86),
3604    TEST(skpwww_hairjobsearch_com_31),
3605    TEST(skpwww_alucinados_net_101),
3606    TEST(skpnamecheap_com_405),
3607    TEST(skpelpais_com_18),
3608    TEST(skpwww_cityads_ru_249),
3609    TEST(skpwww_alrakoba_net_62),
3610    TEST(skpwww_dealnews_com_315),
3611    TEST(skpwww_inmotionhosting_com_9),
3612    TEST(skpskpicture14),
3613    TEST(skpskpicture15),
3614    TEST(skpwww_meb_gov_tr_6),
3615    TEST(skpwww_sciality_com_101),
3616    TEST(skpwww_booking_com_68),
3617    TEST(skpwww_despegar_com_mx_272),
3618    TEST(skpwww_lavoixdunord_fr_11),
3619    TEST(skppptv_com_62),
3620    TEST(skppchappy_com_au102),
3621    TEST(skpsciality_com161),
3622    TEST(skpi_gino_com16),
3623    TEST(skpnaoxrane_ru23),
3624    TEST(skptcmevents_org23),
3625    TEST(skpredbullskatearcade_es16),
3626    TEST(skpfinanzasdigital_com9),
3627    TEST(skpgithub_io_26),
3628    TEST(skpgithub_io_25),
3629    TEST(skpwww_meb_gov_tr_5),
3630    TEST(skpwww_sciality_com_100),
3631    TEST(skpwww_joomla_org_23),
3632    TEST(skpwww_macrumors_com_131),
3633    TEST(skpwww_briian_com_34),
3634    TEST(skpwww_leadpages_net_84),
3635    TEST(skpwww_fj_p_com_22),
3636    TEST(skppartainasdemo250_org56),
3637    TEST(skpsd_graphic_net104),
3638    TEST(skpbreakmystyle_com10),
3639    TEST(skpnational_com_au81),
3640    TEST(skprentacheat_com30),
3641    TEST(skptracksflow_com9),
3642    TEST(skpautobutler_dk29),
3643    TEST(skponlinecollege_org144),
3644    TEST(skphostloco_com11),
3645    TEST(skpsergeychunkevich_com8),
3646    TEST(skpmlk_com326),
3647    TEST(skpcyclist_friends_gr52),
3648    TEST(skpfrauen_magazin_com83),
3649    TEST(skpthesuburbanite_com213),
3650    TEST(skpsudoestenegocios_com186),
3651    TEST(skpmtrk_uz27),
3652    TEST(skpilkoora_com37),
3653    TEST(skpmm4everfriends_com43),
3654    TEST(skpflite_com41),
3655    TEST(skpcheeseandburger_com225),
3656    TEST(skpeverytechpro_blogspot_com100),
3657};
3658
3659static const size_t testCount = SK_ARRAY_COUNT(tests);
3660
3661static bool runReverse = false;
3662static void (*stopTest)(skiatest::Reporter* , const char* filename) = 0;
3663
3664DEF_TEST(PathOpsSkp, reporter) {
3665#if DEBUG_SHOW_TEST_NAME
3666    strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH);
3667#endif
3668    RunTestSet(reporter, tests, testCount, firstTest, stopTest, runReverse);
3669}
3670