blob: a5c2f5f0a2cfb7f54c6d72fc8e81bebfc8e74fd5 [file] [log] [blame]
Yuqian Li3154a532017-09-06 13:33:30 -04001/*
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#include "PathOpsTestCommon.h"
9
10class PathTest_Private {
11public:
12 PathTest_Private(SkPath* path)
13 : fPath(path) {}
14
15 void setPt(int index, SkScalar x, SkScalar y) {
16 fPath->setPt(index, x, y);
17 }
18
19 SkPath* fPath;
20};
21
22static void path_edit(const SkPoint& from, const SkPoint& to, SkPath* path) {
23 PathTest_Private testPath(path);
24 for (int index = 0; index < path->countPoints(); ++index) {
25 if (SkDPoint::ApproximatelyEqual(path->getPoint(index), from)) {
26 testPath.setPt(index, to.fX, to.fY);
27 return;
28 }
29 }
30}
31
32static void cubicOp1d(skiatest::Reporter* reporter, const char* filename) {
33 SkPath path, pathB;
34 path.setFillType(SkPath::kWinding_FillType);
35 path.moveTo(0,1);
36 path.cubicTo(0,2, 1,0, 1,0);
37 path.close();
38 pathB.setFillType(SkPath::kWinding_FillType);
39 pathB.moveTo(0,1);
40 pathB.cubicTo(0,1, 1,0, 2,0);
41 pathB.close();
42 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
43}
44
45static void cubicOp2d(skiatest::Reporter* reporter, const char* filename) {
46 SkPath path, pathB;
47 path.setFillType(SkPath::kWinding_FillType);
48 path.moveTo(0,2);
49 path.cubicTo(0,1, 1,0, 1,0);
50 path.close();
51 pathB.setFillType(SkPath::kWinding_FillType);
52 pathB.moveTo(0,1);
53 pathB.cubicTo(0,1, 2,0, 1,0);
54 pathB.close();
55 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
56}
57
58static void cubicOp3d(skiatest::Reporter* reporter, const char* filename) {
59 SkPath path, pathB;
60 path.setFillType(SkPath::kWinding_FillType);
61 path.moveTo(0,1);
62 path.cubicTo(2,3, 1,0, 1,0);
63 path.close();
64 pathB.setFillType(SkPath::kWinding_FillType);
65 pathB.moveTo(0,1);
66 pathB.cubicTo(0,1, 1,0, 3,2);
67 pathB.close();
68 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
69}
70
71static void cubicOp5d(skiatest::Reporter* reporter, const char* filename) {
72 SkPath path, pathB;
73 path.setFillType(SkPath::kWinding_FillType);
74 path.moveTo(0,1);
75 path.cubicTo(0,2, 1,0, 2,0);
76 path.close();
77 pathB.setFillType(SkPath::kWinding_FillType);
78 pathB.moveTo(0,1);
79 pathB.cubicTo(0,2, 1,0, 2,0);
80 pathB.close();
81 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
82}
83
84static void cubicOp6d(skiatest::Reporter* reporter, const char* filename) {
85 SkPath path, pathB;
86 path.setFillType(SkPath::kWinding_FillType);
87 path.moveTo(0,1);
88 path.cubicTo(0,6, 1,0, 3,0);
89 path.close();
90 pathB.setFillType(SkPath::kWinding_FillType);
91 pathB.moveTo(0,1);
92 pathB.cubicTo(0,3, 1,0, 6,0);
93 pathB.close();
94 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
95}
96
97static void cubicOp7d(skiatest::Reporter* reporter, const char* filename) {
98 SkPath path, pathB;
99 path.setFillType(SkPath::kWinding_FillType);
100 path.moveTo(0,1);
101 path.cubicTo(3,4, 1,0, 3,0);
102 path.close();
103 pathB.setFillType(SkPath::kWinding_FillType);
104 pathB.moveTo(0,1);
105 pathB.cubicTo(0,3, 1,0, 4,3);
106 pathB.close();
107 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
108}
109
110static void cubicOp8d(skiatest::Reporter* reporter, const char* filename) {
111 SkPath path, pathB;
112 path.setFillType(SkPath::kWinding_FillType);
113 path.moveTo(0,1);
114 path.cubicTo(0,5, 1,0, 4,0);
115 path.close();
116 pathB.setFillType(SkPath::kWinding_FillType);
117 pathB.moveTo(0,1);
118 pathB.cubicTo(0,4, 1,0, 5,0);
119 pathB.close();
120 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
121}
122
123static void cubicOp9d(skiatest::Reporter* reporter, const char* filename) {
124 SkPath path, pathB;
125 path.setFillType(SkPath::kWinding_FillType);
126 path.moveTo(0,1);
127 path.cubicTo(1,6, 1,0, 2,1);
128 path.close();
129 pathB.setFillType(SkPath::kWinding_FillType);
130 pathB.moveTo(0,1);
131 pathB.cubicTo(1,2, 1,0, 6,1);
132 pathB.close();
133 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
134}
135
136static void quadOp9d(skiatest::Reporter* reporter, const char* filename) {
137 SkPath path, pathB;
138 path.setFillType(SkPath::kWinding_FillType);
139 path.moveTo(0,1);
140 path.quadTo(1,6, 1.5f,1);
141 path.quadTo(1.5f,0.5f, 2,1);
142 path.close();
143 pathB.setFillType(SkPath::kWinding_FillType);
144 pathB.moveTo(0,1);
145 pathB.quadTo(1,2, 1.4f,1);
146 pathB.quadTo(3,0.4f, 6,1);
147 pathB.close();
148 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
149}
150
151static void lineOp9d(skiatest::Reporter* reporter, const char* filename) {
152 SkPath path, pathB;
153 path.setFillType(SkPath::kWinding_FillType);
154 path.moveTo(0,1);
155 path.lineTo(1,6);
156 path.lineTo(1.5f,1);
157 path.lineTo(1.8f,0.8f);
158 path.lineTo(2,1);
159 path.close();
160 pathB.setFillType(SkPath::kWinding_FillType);
161 pathB.moveTo(0,1);
162 pathB.lineTo(1,2);
163 pathB.lineTo(1.4f,1);
164 pathB.lineTo(3,0.4f);
165 pathB.lineTo(6,1);
166 pathB.close();
167 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
168}
169
170static void cubicOp1i(skiatest::Reporter* reporter, const char* filename) {
171 SkPath path, pathB;
172 path.setFillType(SkPath::kWinding_FillType);
173 path.moveTo(0,1);
174 path.cubicTo(1,2, 1,0, 2,1);
175 path.close();
176 pathB.setFillType(SkPath::kWinding_FillType);
177 pathB.moveTo(0,1);
178 pathB.cubicTo(1,2, 1,0, 2,1);
179 pathB.close();
180 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
181}
182
183static void cubicOp10d(skiatest::Reporter* reporter, const char* filename) {
184 SkPath path, pathB;
185 path.setFillType(SkPath::kWinding_FillType);
186 path.moveTo(0,1);
187 path.cubicTo(1,3, 1,0, 4,1);
188 path.close();
189 pathB.setFillType(SkPath::kWinding_FillType);
190 pathB.moveTo(0,1);
191 pathB.cubicTo(1,4, 1,0, 3,1);
192 pathB.close();
193 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
194}
195
196static void cubicOp11d(skiatest::Reporter* reporter, const char* filename) {
197 SkPath path, pathB;
198 path.setFillType(SkPath::kWinding_FillType);
199 path.moveTo(0,1);
200 path.cubicTo(3,4, 1,0, 5,1);
201 path.close();
202 pathB.setFillType(SkPath::kWinding_FillType);
203 pathB.moveTo(0,1);
204 pathB.cubicTo(1,5, 1,0, 4,3);
205 pathB.close();
206 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
207}
208
209static void cubicOp12d(skiatest::Reporter* reporter, const char* filename) {
210 SkPath path, pathB;
211 path.setFillType(SkPath::kWinding_FillType);
212 path.moveTo(0,1);
213 path.cubicTo(1,6, 1,0, 1,0);
214 path.close();
215 pathB.setFillType(SkPath::kWinding_FillType);
216 pathB.moveTo(0,1);
217 pathB.cubicTo(0,1, 1,0, 6,1);
218 pathB.close();
219 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
220}
221
222static void cubicOp13d(skiatest::Reporter* reporter, const char* filename) {
223 SkPath path, pathB;
224 path.setFillType(SkPath::kWinding_FillType);
225 path.moveTo(0,1);
226 path.cubicTo(4,5, 1,0, 5,3);
227 path.close();
228 pathB.setFillType(SkPath::kWinding_FillType);
229 pathB.moveTo(0,1);
230 pathB.cubicTo(3,5, 1,0, 5,4);
231 pathB.close();
232 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
233}
234
235static void cubicOp14d(skiatest::Reporter* reporter, const char* filename) {
236 SkPath path, pathB;
237 path.setFillType(SkPath::kWinding_FillType);
238 path.moveTo(0,1);
239 path.cubicTo(0,2, 2,0, 2,1);
240 path.close();
241 pathB.setFillType(SkPath::kWinding_FillType);
242 pathB.moveTo(0,2);
243 pathB.cubicTo(1,2, 1,0, 2,0);
244 pathB.close();
245 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
246}
247
248static void cubicOp15d(skiatest::Reporter* reporter, const char* filename) {
249 SkPath path, pathB;
250 path.setFillType(SkPath::kWinding_FillType);
251 path.moveTo(0,1);
252 path.cubicTo(3,6, 2,0, 2,1);
253 path.close();
254 pathB.setFillType(SkPath::kWinding_FillType);
255 pathB.moveTo(0,2);
256 pathB.cubicTo(1,2, 1,0, 6,3);
257 pathB.close();
258 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
259}
260
261static void cubicOp16d(skiatest::Reporter* reporter, const char* filename) {
262 SkPath path, pathB;
263 path.setFillType(SkPath::kWinding_FillType);
264 path.moveTo(0,2);
265 path.cubicTo(0,1, 3,0, 1,0);
266 path.close();
267 pathB.setFillType(SkPath::kWinding_FillType);
268 pathB.moveTo(0,3);
269 pathB.cubicTo(0,1, 2,0, 1,0);
270 pathB.close();
271 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
272}
273
274static void cubicOp17d(skiatest::Reporter* reporter, const char* filename) {
275 SkPath path, pathB;
276 path.setFillType(SkPath::kWinding_FillType);
277 path.moveTo(0,2);
278 path.cubicTo(0,2, 4,0, 2,1);
279 path.close();
280 pathB.setFillType(SkPath::kWinding_FillType);
281 pathB.moveTo(0,4);
282 pathB.cubicTo(1,2, 2,0, 2,0);
283 pathB.close();
284 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
285}
286
287static void cubicOp18d(skiatest::Reporter* reporter, const char* filename) {
288 SkPath path, pathB;
289 path.setFillType(SkPath::kWinding_FillType);
290 path.moveTo(0,1);
291 path.cubicTo(3,5, 2,0, 2,1);
292 path.close();
293 pathB.setFillType(SkPath::kWinding_FillType);
294 pathB.moveTo(0,2);
295 pathB.cubicTo(1,2, 1,0, 5,3);
296 pathB.close();
297 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
298}
299
300static void cubicOp19i(skiatest::Reporter* reporter, const char* filename) {
301 SkPath path, pathB;
302 path.setFillType(SkPath::kWinding_FillType);
303 path.moveTo(0,2);
304 path.cubicTo(0,1, 2,1, 6,2);
305 path.close();
306 pathB.setFillType(SkPath::kWinding_FillType);
307 pathB.moveTo(1,2);
308 pathB.cubicTo(2,6, 2,0, 1,0);
309 pathB.close();
310 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
311}
312
313static void cubicOp20d(skiatest::Reporter* reporter, const char* filename) {
314 SkPath path, pathB;
315 path.setFillType(SkPath::kWinding_FillType);
316 path.moveTo(0,1);
317 path.cubicTo(0,1, 6,0, 2,1);
318 path.close();
319 pathB.setFillType(SkPath::kWinding_FillType);
320 pathB.moveTo(0,6);
321 pathB.cubicTo(1,2, 1,0, 1,0);
322 pathB.close();
323 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
324}
325
326static void cubicOp21d(skiatest::Reporter* reporter, const char* filename) {
327 SkPath path, pathB;
328 path.setFillType(SkPath::kWinding_FillType);
329 path.moveTo(0,1);
330 path.cubicTo(0,1, 2,1, 6,5);
331 path.close();
332 pathB.setFillType(SkPath::kWinding_FillType);
333 pathB.moveTo(1,2);
334 pathB.cubicTo(5,6, 1,0, 1,0);
335 pathB.close();
336 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
337}
338
339static void cubicOp22d(skiatest::Reporter* reporter, const char* filename) {
340 SkPath path, pathB;
341 path.setFillType(SkPath::kWinding_FillType);
342 path.moveTo(0,1);
343 path.cubicTo(2,3, 3,0, 2,1);
344 path.close();
345 pathB.setFillType(SkPath::kWinding_FillType);
346 pathB.moveTo(0,3);
347 pathB.cubicTo(1,2, 1,0, 3,2);
348 pathB.close();
349 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
350}
351
352static void cubicOp23d(skiatest::Reporter* reporter, const char* filename) {
353 SkPath path, pathB;
354 path.setFillType(SkPath::kWinding_FillType);
355 path.moveTo(0,1);
356 path.cubicTo(1,2, 4,0, 2,1);
357 path.close();
358 pathB.setFillType(SkPath::kWinding_FillType);
359 pathB.moveTo(0,4);
360 pathB.cubicTo(1,2, 1,0, 2,1);
361 pathB.close();
362 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
363}
364
365static void cubicOp24d(skiatest::Reporter* reporter, const char* filename) {
366 SkPath path, pathB;
367 path.setFillType(SkPath::kWinding_FillType);
368 path.moveTo(0,1);
369 path.cubicTo(1,2, 2,0, 3,2);
370 path.close();
371 pathB.setFillType(SkPath::kWinding_FillType);
372 pathB.moveTo(0,2);
373 pathB.cubicTo(2,3, 1,0, 2,1);
374 pathB.close();
375 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
376}
377
378static void testIntersect1(skiatest::Reporter* reporter, const char* filename) {
379 SkPath one, two;
380 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
381 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
382 testPathOp(reporter, one, two, kIntersect_SkPathOp, filename);
383}
384
385static void testUnion1(skiatest::Reporter* reporter, const char* filename) {
386 SkPath one, two;
387 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
388 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
389 testPathOp(reporter, one, two, kUnion_SkPathOp, filename);
390}
391
392static void testDiff1(skiatest::Reporter* reporter, const char* filename) {
393 SkPath one, two;
394 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
395 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
396 testPathOp(reporter, one, two, kDifference_SkPathOp, filename);
397}
398
399static void testXor1(skiatest::Reporter* reporter, const char* filename) {
400 SkPath one, two;
401 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
402 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
403 testPathOp(reporter, one, two, kXOR_SkPathOp, filename);
404}
405
406static void testIntersect2(skiatest::Reporter* reporter, const char* filename) {
407 SkPath one, two;
408 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
409 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
410 testPathOp(reporter, one, two, kIntersect_SkPathOp, filename);
411}
412
413static void testUnion2(skiatest::Reporter* reporter, const char* filename) {
414 SkPath one, two;
415 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
416 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
417 testPathOp(reporter, one, two, kUnion_SkPathOp, filename);
418}
419
420static void testDiff2(skiatest::Reporter* reporter, const char* filename) {
421 SkPath one, two;
422 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
423 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
424 testPathOp(reporter, one, two, kDifference_SkPathOp, filename);
425}
426
427static void testXor2(skiatest::Reporter* reporter, const char* filename) {
428 SkPath one, two;
429 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
430 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
431 testPathOp(reporter, one, two, kXOR_SkPathOp, filename);
432}
433
434static void testOp1d(skiatest::Reporter* reporter, const char* filename) {
435 SkPath path, pathB;
436 path.setFillType(SkPath::kWinding_FillType);
437 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
438 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
439 pathB.setFillType(SkPath::kWinding_FillType);
440 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
441 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
442 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
443}
444
445static void testOp2d(skiatest::Reporter* reporter, const char* filename) {
446 SkPath path, pathB;
447 path.setFillType(SkPath::kWinding_FillType);
448 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
449 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
450 pathB.setFillType(SkPath::kEvenOdd_FillType);
451 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
452 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
453 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
454}
455
456static void testOp3d(skiatest::Reporter* reporter, const char* filename) {
457 SkPath path, pathB;
458 path.setFillType(SkPath::kWinding_FillType);
459 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
460 path.addRect(1, 1, 2, 2, SkPath::kCW_Direction);
461 pathB.setFillType(SkPath::kWinding_FillType);
462 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
463 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
464 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
465}
466
467static void testOp1u(skiatest::Reporter* reporter, const char* filename) {
468 SkPath path, pathB;
469 path.setFillType(SkPath::kWinding_FillType);
470 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
471 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
472 pathB.setFillType(SkPath::kWinding_FillType);
473 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
474 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
475 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
476}
477
478static void testOp4d(skiatest::Reporter* reporter, const char* filename) {
479 SkPath path, pathB;
480 path.setFillType(SkPath::kWinding_FillType);
481 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
482 path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
483 pathB.setFillType(SkPath::kWinding_FillType);
484 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
485 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
486 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
487}
488
489static void testOp5d(skiatest::Reporter* reporter, const char* filename) {
490 SkPath path, pathB;
491 path.setFillType(SkPath::kEvenOdd_FillType);
492 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
493 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
494 pathB.setFillType(SkPath::kEvenOdd_FillType);
495 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
496 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
497 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
498}
499
500static void testOp6d(skiatest::Reporter* reporter, const char* filename) {
501 SkPath path, pathB;
502 path.setFillType(SkPath::kEvenOdd_FillType);
503 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
504 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
505 pathB.setFillType(SkPath::kWinding_FillType);
506 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
507 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
508 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
509}
510
511static void testOp7d(skiatest::Reporter* reporter, const char* filename) {
512 SkPath path, pathB;
513 path.setFillType(SkPath::kEvenOdd_FillType);
514 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
515 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
516 pathB.setFillType(SkPath::kEvenOdd_FillType);
517 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
518 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
519 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
520}
521
522static void testOp2u(skiatest::Reporter* reporter, const char* filename) {
523 SkPath path, pathB;
524 path.setFillType(SkPath::kEvenOdd_FillType);
525 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
526 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
527 pathB.setFillType(SkPath::kWinding_FillType);
528 pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
529 pathB.addRect(1, 1, 2, 2, SkPath::kCW_Direction);
530 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
531}
532
533static void testOp8d(skiatest::Reporter* reporter, const char* filename) {
534 SkPath path, pathB;
535 path.addRect(0, 0, 640, 480);
536 pathB.moveTo(577330, 1971.72f);
537 pathB.cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f);
538 pathB.close();
539 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
540}
541static void cubicOp25i(skiatest::Reporter* reporter, const char* filename) {
542 SkPath path, pathB;
543 path.setFillType(SkPath::kWinding_FillType);
544 path.moveTo(0,1);
545 path.cubicTo(2,4, 5,0, 3,2);
546 path.close();
547 pathB.setFillType(SkPath::kWinding_FillType);
548 pathB.moveTo(0,5);
549 pathB.cubicTo(2,3, 1,0, 4,2);
550 pathB.close();
551 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
552}
553
554static void cubicOp26d(skiatest::Reporter* reporter, const char* filename) {
555 SkPath path, pathB;
556 path.setFillType(SkPath::kWinding_FillType);
557 path.moveTo(0,1);
558 path.cubicTo(3,4, 4,0, 3,2);
559 path.close();
560 pathB.setFillType(SkPath::kWinding_FillType);
561 pathB.moveTo(0,4);
562 pathB.cubicTo(2,3, 1,0, 4,3);
563 pathB.close();
564 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
565}
566
567static void cubicOp27d(skiatest::Reporter* reporter, const char* filename) {
568 SkPath path, pathB;
569 path.setFillType(SkPath::kWinding_FillType);
570 path.moveTo(0,1);
571 path.cubicTo(3,6, 1,0, 5,2);
572 path.close();
573 pathB.setFillType(SkPath::kWinding_FillType);
574 pathB.moveTo(0,1);
575 pathB.cubicTo(2,5, 1,0, 6,3);
576 pathB.close();
577 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
578}
579
580static void cubicOp28u(skiatest::Reporter* reporter, const char* filename) {
581 SkPath path, pathB;
582 path.setFillType(SkPath::kWinding_FillType);
583 path.moveTo(0,1);
584 path.cubicTo(1,4, 6,0, 3,2);
585 path.close();
586 pathB.setFillType(SkPath::kWinding_FillType);
587 pathB.moveTo(0,6);
588 pathB.cubicTo(2,3, 1,0, 4,1);
589 pathB.close();
590 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
591}
592
593static void cubicOp29d(skiatest::Reporter* reporter, const char* filename) {
594 SkPath path, pathB;
595 path.setFillType(SkPath::kWinding_FillType);
596 path.moveTo(0,1);
597 path.cubicTo(2,5, 6,0, 4,2);
598 path.close();
599 pathB.setFillType(SkPath::kWinding_FillType);
600 pathB.moveTo(0,6);
601 pathB.cubicTo(2,4, 1,0, 5,2);
602 pathB.close();
603 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
604}
605
606static void cubicOp30d(skiatest::Reporter* reporter, const char* filename) {
607 SkPath path, pathB;
608 path.setFillType(SkPath::kWinding_FillType);
609 path.moveTo(0,1);
610 path.cubicTo(2,5, 6,0, 5,3);
611 path.close();
612 pathB.setFillType(SkPath::kWinding_FillType);
613 pathB.moveTo(0,6);
614 pathB.cubicTo(3,5, 1,0, 5,2);
615 pathB.close();
616 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
617}
618
619static void cubicOp31d(skiatest::Reporter* reporter, const char* filename) {
620 SkPath path, pathB;
621 path.setFillType(SkPath::kWinding_FillType);
622 path.moveTo(0,2);
623 path.cubicTo(0,3, 2,1, 4,0);
624 path.close();
625 pathB.setFillType(SkPath::kWinding_FillType);
626 pathB.moveTo(1,2);
627 pathB.cubicTo(0,4, 2,0, 3,0);
628 pathB.close();
629 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
630}
631
632static void cubicOp31u(skiatest::Reporter* reporter, const char* filename) {
633 SkPath path, pathB;
634 path.setFillType(SkPath::kWinding_FillType);
635 path.moveTo(0,2);
636 path.cubicTo(0,3, 2,1, 4,0);
637 path.close();
638 pathB.setFillType(SkPath::kWinding_FillType);
639 pathB.moveTo(1,2);
640 pathB.cubicTo(0,4, 2,0, 3,0);
641 pathB.close();
642 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
643}
644
645static void cubicOp31x(skiatest::Reporter* reporter, const char* filename) {
646 SkPath path, pathB;
647 path.setFillType(SkPath::kWinding_FillType);
648 path.moveTo(0,2);
649 path.cubicTo(0,3, 2,1, 4,0);
650 path.close();
651 pathB.setFillType(SkPath::kWinding_FillType);
652 pathB.moveTo(1,2);
653 pathB.cubicTo(0,4, 2,0, 3,0);
654 pathB.close();
655 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
656}
657
658static void cubicOp32d(skiatest::Reporter* reporter, const char* filename) {
659 SkPath path, pathB;
660 path.setFillType(SkPath::kWinding_FillType);
661 path.moveTo(0,1);
662 path.cubicTo(1,2, 6,0, 3,1);
663 path.close();
664 pathB.setFillType(SkPath::kWinding_FillType);
665 pathB.moveTo(0,6);
666 pathB.cubicTo(1,3, 1,0, 2,1);
667 pathB.close();
668 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
669}
670
671static void cubicOp33i(skiatest::Reporter* reporter, const char* filename) {
672 SkPath path, pathB;
673 path.setFillType(SkPath::kWinding_FillType);
674 path.moveTo(0,1);
675 path.cubicTo(1,2, 6,0, 3,1);
676 path.close();
677 pathB.setFillType(SkPath::kWinding_FillType);
678 pathB.moveTo(0,6);
679 pathB.cubicTo(1,3, 1,0, 2,1);
680 pathB.close();
681 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
682}
683
684static void cubicOp34d(skiatest::Reporter* reporter, const char* filename) {
685 SkPath path, pathB;
686 path.setFillType(SkPath::kWinding_FillType);
687 path.moveTo(0,1);
688 path.cubicTo(3,5, 2,1, 3,1);
689 path.close();
690 pathB.setFillType(SkPath::kWinding_FillType);
691 pathB.moveTo(1,2);
692 pathB.cubicTo(1,3, 1,0, 5,3);
693 pathB.close();
694 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
695}
696
697static void cubicOp35d(skiatest::Reporter* reporter, const char* filename) {
698 SkPath path, pathB;
699 path.setFillType(SkPath::kWinding_FillType);
700 path.moveTo(0,1);
701 path.cubicTo(1,5, 2,1, 4,0);
702 path.close();
703 pathB.setFillType(SkPath::kWinding_FillType);
704 pathB.moveTo(1,2);
705 pathB.cubicTo(0,4, 1,0, 5,1);
706 pathB.close();
707 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
708}
709
710static void cubicOp36u(skiatest::Reporter* reporter, const char* filename) {
711 SkPath path, pathB;
712 path.setFillType(SkPath::kWinding_FillType);
713 path.moveTo(0,1);
714 path.cubicTo(1,6, 2,0, 5,1);
715 path.close();
716 pathB.setFillType(SkPath::kWinding_FillType);
717 pathB.moveTo(0,2);
718 pathB.cubicTo(1,5, 1,0, 6,1);
719 pathB.close();
720 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
721}
722
723static void cubicOp37d(skiatest::Reporter* reporter, const char* filename) {
724 SkPath path, pathB;
725 path.setFillType(SkPath::kWinding_FillType);
726 path.moveTo(0,1);
727 path.cubicTo(2,6, 6,1, 4,3);
728 path.close();
729 pathB.setFillType(SkPath::kWinding_FillType);
730 pathB.moveTo(1,6);
731 pathB.cubicTo(3,4, 1,0, 6,2);
732 pathB.close();
733 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
734}
735
736static void cubicOp38d(skiatest::Reporter* reporter, const char* filename) {
737 SkPath path, pathB;
738 path.setFillType(SkPath::kWinding_FillType);
739 path.moveTo(0,1);
740 path.cubicTo(0,6, 3,2, 4,1);
741 path.close();
742 pathB.setFillType(SkPath::kWinding_FillType);
743 pathB.moveTo(2,3);
744 pathB.cubicTo(1,4, 1,0, 6,0);
745 pathB.close();
746 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
747}
748
749static void cubicOp39d(skiatest::Reporter* reporter, const char* filename) {
750 SkPath path, pathB;
751 path.setFillType(SkPath::kWinding_FillType);
752 path.moveTo(0,1);
753 path.cubicTo(2,3, 5,1, 4,3);
754 path.close();
755 pathB.setFillType(SkPath::kWinding_FillType);
756 pathB.moveTo(1,5);
757 pathB.cubicTo(3,4, 1,0, 3,2);
758 pathB.close();
759 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
760}
761
762static void cubicOp40d(skiatest::Reporter* reporter, const char* filename) {
763 SkPath path, pathB;
764 path.setFillType(SkPath::kWinding_FillType);
765 path.moveTo(0,1);
766 path.cubicTo(1,5, 3,2, 4,2);
767 path.close();
768 pathB.setFillType(SkPath::kWinding_FillType);
769 pathB.moveTo(2,3);
770 pathB.cubicTo(2,4, 1,0, 5,1);
771 pathB.close();
772 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
773}
774
775static void cubicOp41i(skiatest::Reporter* reporter, const char* filename) {
776 SkPath path, pathB;
777 path.setFillType(SkPath::kWinding_FillType);
778 path.moveTo(0,1);
779 path.cubicTo(2,6, 4,3, 6,4);
780 path.close();
781 pathB.setFillType(SkPath::kWinding_FillType);
782 pathB.moveTo(3,4);
783 pathB.cubicTo(4,6, 1,0, 6,2);
784 pathB.close();
785 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
786}
787
788static void cubicOp42d(skiatest::Reporter* reporter, const char* filename) {
789 SkPath path, pathB;
790 path.setFillType(SkPath::kWinding_FillType);
791 path.moveTo(0,1);
792 path.cubicTo(1,2, 6,5, 5,4);
793 path.close();
794 pathB.setFillType(SkPath::kWinding_FillType);
795 pathB.moveTo(5,6);
796 pathB.cubicTo(4,5, 1,0, 2,1);
797 pathB.close();
798 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
799}
800
801static void cubicOp43d(skiatest::Reporter* reporter, const char* filename) {
802 SkPath path, pathB;
803 path.setFillType(SkPath::kWinding_FillType);
804 path.moveTo(0,2);
805 path.cubicTo(1,2, 4,0, 3,1);
806 path.close();
807 pathB.setFillType(SkPath::kWinding_FillType);
808 pathB.moveTo(0,4);
809 pathB.cubicTo(1,3, 2,0, 2,1);
810 pathB.close();
811 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
812}
813
814static void cubicOp44d(skiatest::Reporter* reporter, const char* filename) {
815 SkPath path, pathB;
816 path.setFillType(SkPath::kWinding_FillType);
817 path.moveTo(0,2);
818 path.cubicTo(3,6, 4,0, 3,2);
819 path.close();
820 pathB.setFillType(SkPath::kWinding_FillType);
821 pathB.moveTo(0,4);
822 pathB.cubicTo(2,3, 2,0, 6,3);
823 pathB.close();
824 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
825}
826
827static void cubicOp45d(skiatest::Reporter* reporter, const char* filename) {
828 SkPath path, pathB;
829 path.setFillType(SkPath::kWinding_FillType);
830 path.moveTo(0,2);
831 path.cubicTo(2,4, 4,0, 3,2);
832 path.close();
833 pathB.setFillType(SkPath::kWinding_FillType);
834 pathB.moveTo(0,4);
835 pathB.cubicTo(2,3, 2,0, 4,2);
836 pathB.close();
837 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
838}
839
840static void cubicOp46d(skiatest::Reporter* reporter, const char* filename) {
841 SkPath path, pathB;
842 path.setFillType(SkPath::kWinding_FillType);
843 path.moveTo(0,2);
844 path.cubicTo(3,5, 5,0, 4,2);
845 path.close();
846 pathB.setFillType(SkPath::kWinding_FillType);
847 pathB.moveTo(0,5);
848 pathB.cubicTo(2,4, 2,0, 5,3);
849 pathB.close();
850 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
851}
852
853static void cubicOp47d(skiatest::Reporter* reporter, const char* filename) {
854 SkPath path, pathB;
855 path.setFillType(SkPath::kWinding_FillType);
856 path.moveTo(0,1);
857 path.cubicTo(1,6, 6,2, 5,4);
858 path.close();
859 pathB.setFillType(SkPath::kWinding_FillType);
860 pathB.moveTo(2,6);
861 pathB.cubicTo(4,5, 1,0, 6,1);
862 pathB.close();
863 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
864}
865
866static void cubicOp48d(skiatest::Reporter* reporter, const char* filename) {
867 SkPath path, pathB;
868 path.setFillType(SkPath::kWinding_FillType);
869 path.moveTo(0,2);
870 path.cubicTo(2,3, 5,1, 3,2);
871 path.close();
872 pathB.setFillType(SkPath::kWinding_FillType);
873 pathB.moveTo(1,5);
874 pathB.cubicTo(2,3, 2,0, 3,2);
875 pathB.close();
876 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
877}
878
879static void cubicOp49d(skiatest::Reporter* reporter, const char* filename) {
880 SkPath path, pathB;
881 path.setFillType(SkPath::kWinding_FillType);
882 path.moveTo(0,2);
883 path.cubicTo(1,5, 3,2, 4,1);
884 path.close();
885 pathB.setFillType(SkPath::kWinding_FillType);
886 pathB.moveTo(2,3);
887 pathB.cubicTo(1,4, 2,0, 5,1);
888 pathB.close();
889 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
890}
891
892static void cubicOp50d(skiatest::Reporter* reporter, const char* filename) {
893 SkPath path, pathB;
894 path.setFillType(SkPath::kWinding_FillType);
895 path.moveTo(0,3);
896 path.cubicTo(1,6, 5,0, 5,1);
897 path.close();
898 pathB.setFillType(SkPath::kWinding_FillType);
899 pathB.moveTo(0,5);
900 pathB.cubicTo(1,5, 3,0, 6,1);
901 pathB.close();
902 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
903}
904
905static void cubicOp51d(skiatest::Reporter* reporter, const char* filename) {
906 SkPath path, pathB;
907 path.setFillType(SkPath::kWinding_FillType);
908 path.moveTo(0,3);
909 path.cubicTo(1,2, 4,1, 6,0);
910 path.close();
911 pathB.setFillType(SkPath::kWinding_FillType);
912 pathB.moveTo(1,4);
913 pathB.cubicTo(0,6, 3,0, 2,1);
914 pathB.close();
915 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
916}
917
918static void cubicOp52d(skiatest::Reporter* reporter, const char* filename) {
919 SkPath path, pathB;
920 path.setFillType(SkPath::kWinding_FillType);
921 path.moveTo(0,2);
922 path.cubicTo(1,2, 5,4, 4,3);
923 path.close();
924 pathB.setFillType(SkPath::kWinding_FillType);
925 pathB.moveTo(4,5);
926 pathB.cubicTo(3,4, 2,0, 2,1);
927 pathB.close();
928 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
929}
930
931static void cubicOp53d(skiatest::Reporter* reporter, const char* filename) {
932 SkPath path, pathB;
933 path.setFillType(SkPath::kWinding_FillType);
934 path.moveTo(0,3);
935 path.cubicTo(1,2, 5,3, 2,1);
936 path.close();
937 pathB.setFillType(SkPath::kWinding_FillType);
938 pathB.moveTo(3,5);
939 pathB.cubicTo(1,2, 3,0, 2,1);
940 pathB.close();
941 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
942}
943
944static void cubicOp54d(skiatest::Reporter* reporter, const char* filename) {
945 SkPath path, pathB;
946 path.setFillType(SkPath::kWinding_FillType);
947 path.moveTo(0,4);
948 path.cubicTo(1,3, 5,4, 4,2);
949 path.close();
950 pathB.setFillType(SkPath::kWinding_FillType);
951 pathB.moveTo(4,5);
952 pathB.cubicTo(2,4, 4,0, 3,1);
953 pathB.close();
954 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
955}
956
957static void cubicOp55d(skiatest::Reporter* reporter, const char* filename) {
958 SkPath path, pathB;
959 path.setFillType(SkPath::kWinding_FillType);
960 path.moveTo(0,5);
961 path.cubicTo(1,3, 3,2, 5,0);
962 path.close();
963 pathB.setFillType(SkPath::kWinding_FillType);
964 pathB.moveTo(2,3);
965 pathB.cubicTo(0,5, 5,0, 3,1);
966 pathB.close();
967 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
968}
969
970static void cubicOp56d(skiatest::Reporter* reporter, const char* filename) {
971 SkPath path, pathB;
972 path.setFillType(SkPath::kWinding_FillType);
973 path.moveTo(0,1);
974 path.cubicTo(2,6, 5,0, 2,1);
975 path.close();
976 pathB.setFillType(SkPath::kWinding_FillType);
977 pathB.moveTo(0,5);
978 pathB.cubicTo(1,2, 1,0, 6,2);
979 pathB.close();
980 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
981}
982
983static void cubicOp57d(skiatest::Reporter* reporter, const char* filename) {
984 SkPath path, pathB;
985 path.setFillType(SkPath::kWinding_FillType);
986 path.moveTo(0,5);
987 path.cubicTo(0,5, 5,4, 6,4);
988 path.close();
989 pathB.setFillType(SkPath::kWinding_FillType);
990 pathB.moveTo(4,5);
991 pathB.cubicTo(4,6, 5,0, 5,0);
992 pathB.close();
993 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
994}
995
996static void cubicOp58d(skiatest::Reporter* reporter, const char* filename) {
997 SkPath path, pathB;
998 path.setFillType(SkPath::kWinding_FillType);
999 path.moveTo(0,5);
1000 path.cubicTo(3,4, 6,5, 5,3);
1001 path.close();
1002 pathB.setFillType(SkPath::kWinding_FillType);
1003 pathB.moveTo(5,6);
1004 pathB.cubicTo(3,5, 5,0, 4,3);
1005 pathB.close();
1006 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1007}
1008
1009static void cubicOp59d(skiatest::Reporter* reporter, const char* filename) {
1010 SkPath path, pathB;
1011 path.setFillType(SkPath::kWinding_FillType);
1012 path.moveTo(0,1);
1013 path.cubicTo(5,6, 4,0, 4,1);
1014 path.close();
1015 pathB.setFillType(SkPath::kWinding_FillType);
1016 pathB.moveTo(0,4);
1017 pathB.cubicTo(1,4, 1,0, 6,5);
1018 pathB.close();
1019 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1020}
1021
1022static void cubicOp60d(skiatest::Reporter* reporter, const char* filename) {
1023 SkPath path, pathB;
1024 path.setFillType(SkPath::kWinding_FillType);
1025 path.moveTo(0,2);
1026 path.cubicTo(4,6, 6,0, 5,2);
1027 path.close();
1028 pathB.setFillType(SkPath::kWinding_FillType);
1029 pathB.moveTo(0,6);
1030 pathB.cubicTo(2,5, 2,0, 6,4);
1031 pathB.close();
1032 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1033}
1034
1035static void cubicOp61d(skiatest::Reporter* reporter, const char* filename) {
1036 SkPath path, pathB;
1037 path.setFillType(SkPath::kWinding_FillType);
1038 path.moveTo(1,2);
1039 path.cubicTo(0,5, 3,2, 6,1);
1040 path.close();
1041 pathB.setFillType(SkPath::kWinding_FillType);
1042 pathB.moveTo(2,3);
1043 pathB.cubicTo(1,6, 2,1, 5,0);
1044 pathB.close();
1045 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1046}
1047
1048static void cubicOp62d(skiatest::Reporter* reporter, const char* filename) {
1049 SkPath path, pathB;
1050 path.setFillType(SkPath::kWinding_FillType);
1051 path.moveTo(1,3);
1052 path.cubicTo(5,6, 5,3, 5,4);
1053 path.close();
1054 pathB.setFillType(SkPath::kWinding_FillType);
1055 pathB.moveTo(3,5);
1056 pathB.cubicTo(4,5, 3,1, 6,5);
1057 pathB.close();
1058 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1059}
1060
1061static void cubicOp63d(skiatest::Reporter* reporter, const char* filename) {
1062 SkPath path, pathB;
1063 path.setFillType(SkPath::kWinding_FillType);
1064 path.moveTo(2,3);
1065 path.cubicTo(0,4, 3,2, 5,3);
1066 path.close();
1067 pathB.setFillType(SkPath::kWinding_FillType);
1068 pathB.moveTo(2,3);
1069 pathB.cubicTo(3,5, 3,2, 4,0);
1070 pathB.close();
1071 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1072}
1073
1074static void cubicOp64d(skiatest::Reporter* reporter, const char* filename) {
1075 SkPath path, pathB;
1076 path.moveTo(0,1);
1077 path.cubicTo(0,1, 1,0, 3,0);
1078 path.lineTo(0,1);
1079 path.close();
1080 pathB.moveTo(0,1);
1081 pathB.cubicTo(0,3, 1,0, 1,0);
1082 pathB.lineTo(0,1);
1083 pathB.close();
1084 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1085}
1086
1087static void cubicOp65d(skiatest::Reporter* reporter, const char* filename) {
1088 SkPath path, pathB;
1089 path.moveTo(0,1);
1090 path.cubicTo(1,5, 1,0, 1,0);
1091 path.lineTo(0,1);
1092 path.close();
1093 pathB.moveTo(0,1);
1094 pathB.cubicTo(0,1, 1,0, 5,1);
1095 pathB.lineTo(0,1);
1096 pathB.close();
1097 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1098}
1099
1100static void rectOp1d(skiatest::Reporter* reporter, const char* filename) {
1101 SkPath path, pathB;
1102 path.moveTo(0,1);
1103 path.cubicTo(0,1, 1,0, 3,0);
1104 path.lineTo(0,1);
1105 path.close();
1106 pathB.moveTo(0,1);
1107 pathB.cubicTo(0,3, 1,0, 1,0);
1108 pathB.lineTo(0,1);
1109 pathB.close();
1110 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1111}
1112
1113static void cubicOp66u(skiatest::Reporter* reporter, const char* filename) {
1114 SkPath path, pathB;
1115 path.setFillType(SkPath::kWinding_FillType);
1116 path.moveTo(0,1);
1117 path.cubicTo(2,6, 4,2, 5,3);
1118 path.close();
1119 pathB.setFillType(SkPath::kWinding_FillType);
1120 pathB.moveTo(2,4);
1121 pathB.cubicTo(3,5, 1,0, 6,2);
1122 pathB.close();
1123 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1124}
1125
1126static void cubicOp67u(skiatest::Reporter* reporter, const char* filename) {
1127 SkPath path, pathB;
1128 path.moveTo(3,5);
1129 path.cubicTo(1,6, 5,0, 3,1);
1130 path.lineTo(3,5);
1131 path.close();
1132 pathB.moveTo(0,5);
1133 pathB.cubicTo(1,3, 5,3, 6,1);
1134 pathB.lineTo(0,5);
1135 pathB.close();
1136 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1137}
1138
1139static void cubicOp68u(skiatest::Reporter* reporter, const char* filename) {
1140 SkPath path, pathB;
1141 path.moveTo(0,5);
1142 path.cubicTo(4,5, 4,1, 5,0);
1143 path.close();
1144 pathB.moveTo(1,4);
1145 pathB.cubicTo(0,5, 5,0, 5,4);
1146 pathB.close();
1147 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1148}
1149
1150static void cubicOp69d(skiatest::Reporter* reporter, const char* filename) {
1151 SkPath path, pathB;
1152 path.moveTo(1,3);
1153 path.cubicTo(0,1, 3,1, 2,0);
1154 path.close();
1155 pathB.moveTo(1,3);
1156 pathB.cubicTo(0,2, 3,1, 1,0);
1157 pathB.close();
1158 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1159}
1160
1161SkPathOp ops[] = {
1162 kUnion_SkPathOp,
1163 kXOR_SkPathOp,
1164 kReverseDifference_SkPathOp,
1165 kXOR_SkPathOp,
1166 kReverseDifference_SkPathOp,
1167};
1168
1169static void rRect1(skiatest::Reporter* reporter, const char* filename) {
1170 SkScalar xA = 0.65f;
1171 SkScalar xB = 10.65f;
1172 SkScalar xC = 20.65f;
1173 SkScalar xD = 30.65f;
1174 SkScalar xE = 40.65f;
1175 SkScalar xF = 50.65f;
1176
1177 SkScalar yA = 0.65f;
1178 SkScalar yB = 10.65f;
1179 SkScalar yC = 20.65f;
1180 SkScalar yD = 30.65f;
1181 SkScalar yE = 40.65f;
1182 SkScalar yF = 50.65f;
1183 SkPath paths[5];
1184 SkRect rects[5];
1185 rects[0].set(xB, yB, xE, yE);
1186 paths[0].addRoundRect(rects[0], SkIntToScalar(5), SkIntToScalar(5)); // red
1187 rects[1].set(xA, yA, xD, yD);
1188 paths[1].addRoundRect(rects[1], SkIntToScalar(5), SkIntToScalar(5)); // green
1189 rects[2].set(xC, yA, xF, yD);
1190 paths[2].addRoundRect(rects[2], SkIntToScalar(5), SkIntToScalar(5)); // blue
1191 rects[3].set(xA, yC, xD, yF);
1192 paths[3].addRoundRect(rects[3], SkIntToScalar(5), SkIntToScalar(5)); // yellow
1193 rects[4].set(xC, yC, xF, yF);
1194 paths[4].addRoundRect(rects[4], SkIntToScalar(5), SkIntToScalar(5)); // cyan
1195 SkPath path;
1196 path.setFillType(SkPath::kInverseEvenOdd_FillType);
1197 for (int index = 0; index < 5; ++index) {
1198 testPathOp(reporter, path, paths[index], ops[index], filename);
1199 REPORTER_ASSERT(reporter, Op(path, paths[index], ops[index], &path));
1200 }
1201}
1202
1203static void skp1(skiatest::Reporter* reporter, const char* filename) {
1204 SkPath path;
1205 path.setFillType(SkPath::kEvenOdd_FillType);
1206 path.moveTo(189,7);
1207 path.cubicTo(189,5.34314585f, 190.34314f,4, 192,4);
1208 path.lineTo(243,4);
1209 path.cubicTo(244.65686f,4, 246,5.34314585f, 246,7);
1210 path.lineTo(246,21);
1211 path.cubicTo(246,22.6568546f, 244.65686f,24, 243,24);
1212 path.lineTo(192,24);
1213 path.cubicTo(190.34314f,24, 189,22.6568546f, 189,21);
1214 path.lineTo(189,7);
1215 path.close();
1216 path.moveTo(191,8);
1217 path.cubicTo(191,6.89543009f, 191.895432f,6, 193,6);
1218 path.lineTo(242,6);
1219 path.cubicTo(243.104568f,6, 244,6.89543009f, 244,8);
1220 path.lineTo(244,20);
1221 path.cubicTo(244,21.1045704f, 243.104568f,22, 242,22);
1222 path.lineTo(193,22);
1223 path.cubicTo(191.895432f,22, 191,21.1045704f, 191,20);
1224 path.lineTo(191,8);
1225 path.close();
1226 SkPath pathB;
1227 pathB.setFillType(SkPath::kWinding_FillType);
1228 pathB.moveTo(189,4);
1229 pathB.lineTo(199,14);
1230 pathB.lineTo(236,14);
1231 pathB.lineTo(246,4);
1232 pathB.lineTo(189,4);
1233 pathB.close();
1234 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1235}
1236
1237static void skp2(skiatest::Reporter* reporter, const char* filename) {
1238 SkPath path;
1239 path.setFillType(SkPath::kEvenOdd_FillType);
1240 path.moveTo(253.000000f, 11757.0000f);
1241 path.lineTo(253.000000f, 222.000000f);
1242 path.lineTo(823.000000f, 222.000000f);
1243 path.lineTo(823.000000f, 11757.0000f);
1244 path.lineTo(253.000000f, 11757.0000f);
1245 path.close();
1246 SkPath pathB;
1247 pathB.setFillType(SkPath::kWinding_FillType);
1248 pathB.moveTo(258.000000f, 1028.00000f);
1249 pathB.lineTo(258.000000f, 1027.00000f);
1250 pathB.lineTo(823.000000f, 1027.00000f);
1251 pathB.lineTo(823.000000f, 1028.00000f);
1252 pathB.lineTo(258.000000f, 1028.00000f);
1253 pathB.close();
1254 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1255}
1256
1257static void skp3(skiatest::Reporter* reporter, const char* filename) {
1258 SkPath path;
1259 path.setFillType(SkPath::kEvenOdd_FillType);
1260 path.moveTo(717.000000f, 507.000000f);
1261 path.lineTo(717.000000f, 425.000000f);
1262 path.lineTo(973.000000f, 425.000000f);
1263 path.lineTo(973.000000f, 507.000000f);
1264 path.quadTo(973.000000f, 508.242645f, 972.121582f, 509.121613f);
1265 path.quadTo(971.242615f, 510.000000f, 970.000000f, 510.000000f);
1266 path.lineTo(720.000000f, 510.000000f);
1267 path.quadTo(718.757385f, 510.000000f, 717.878418f, 509.121613f);
1268 path.quadTo(717.000000f, 508.242645f, 717.000000f, 507.000000f);
1269 path.close();
1270 path.moveTo(719.000000f, 426.000000f);
1271 path.lineTo(971.000000f, 426.000000f);
1272 path.lineTo(971.000000f, 506.000000f);
1273 path.cubicTo(971.000000f, 507.104584f, 970.104553f, 508.000000f, 969.000000f, 508.000000f);
1274 path.lineTo(721.000000f, 508.000000f);
1275 path.cubicTo(719.895447f, 508.000000f, 719.000000f, 507.104584f, 719.000000f, 506.000000f);
1276 path.lineTo(719.000000f, 426.000000f);
1277 path.close();
1278 SkPath pathB;
1279 pathB.setFillType(SkPath::kWinding_FillType);
1280 pathB.moveTo(717.000000f, 510.000000f);
1281 pathB.lineTo(760.000000f, 467.000000f);
1282 pathB.lineTo(930.000000f, 467.000000f);
1283 pathB.lineTo(973.000000f, 510.000000f);
1284 pathB.lineTo(717.000000f, 510.000000f);
1285 pathB.close();
1286 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1287}
1288
1289static void skp4(skiatest::Reporter* reporter, const char* filename) {
1290 SkPath path;
1291 path.setFillType(SkPath::kEvenOdd_FillType);
1292 path.moveTo(230.756805f, 591.756775f);
1293 path.quadTo(232.514725f, 590.000000f, 235.000000f, 590.000000f);
1294 path.lineTo(300.000000f, 590.000000f);
1295 path.quadTo(302.485291f, 590.000000f, 304.243195f, 591.756775f);
1296 path.quadTo(306.000000f, 593.514709f, 306.000000f, 596.000000f);
1297 path.lineTo(306.000000f, 617.000000f);
1298 path.lineTo(229.000000f, 617.000000f);
1299 path.lineTo(229.000000f, 596.000000f);
1300 path.quadTo(229.000000f, 593.514709f, 230.756805f, 591.756775f);
1301 path.close();
1302 path.moveTo(231.000000f, 597.000000f);
1303 path.cubicTo(231.000000f, 594.238586f, 233.238571f, 592.000000f, 236.000000f, 592.000000f);
1304 path.lineTo(299.000000f, 592.000000f);
1305 path.cubicTo(301.761414f, 592.000000f, 304.000000f, 594.238586f, 304.000000f, 597.000000f);
1306 path.lineTo(304.000000f, 616.000000f);
1307 path.lineTo(231.000000f, 616.000000f);
1308 path.lineTo(231.000000f, 597.000000f);
1309 path.close();
1310 SkPath pathB;
1311 pathB.setFillType(SkPath::kWinding_FillType);
1312 pathB.moveTo(306.000000f, 590.000000f);
1313 pathB.lineTo(292.000000f, 604.000000f);
1314 pathB.lineTo(305.000000f, 617.000000f);
1315 pathB.lineTo(306.000000f, 617.000000f);
1316 pathB.lineTo(306.000000f, 590.000000f);
1317 pathB.close();
1318 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1319}
1320
1321static void skp5(skiatest::Reporter* reporter, const char* filename) {
1322 SkPath path;
1323 path.setFillType(SkPath::kEvenOdd_FillType);
1324 path.moveTo(18.0000000f, 226.000000f);
1325 path.quadTo(14.6862917f, 226.000000f, 12.3423996f, 228.342407f);
1326 path.quadTo(10.0000000f, 230.686295f, 10.0000000f, 234.000000f);
1327 path.lineTo(10.0000000f, 253.000000f);
1328 path.lineTo(1247.00000f, 253.000000f);
1329 path.lineTo(1247.00000f, 234.000000f);
1330 path.quadTo(1247.00000f, 230.686295f, 1244.65759f, 228.342407f);
1331 path.quadTo(1242.31372f, 226.000000f, 1239.00000f, 226.000000f);
1332 path.lineTo(18.0000000f, 226.000000f);
1333 path.close();
1334 SkPath pathB;
1335 pathB.setFillType(SkPath::kInverseWinding_FillType);
1336 pathB.moveTo(18.0000000f, 226.000000f);
1337 pathB.lineTo(1239.00000f, 226.000000f);
1338 pathB.cubicTo(1243.41833f, 226.000000f, 1247.00000f, 229.581726f, 1247.00000f, 234.000000f);
1339 pathB.lineTo(1247.00000f, 252.000000f);
1340 pathB.lineTo(10.0000000f, 252.000000f);
1341 pathB.lineTo(10.0000000f, 234.000000f);
1342 pathB.cubicTo(10.0000000f, 229.581726f, 13.5817204f, 226.000000f, 18.0000000f, 226.000000f);
1343 pathB.close();
1344 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1345}
1346
1347static void cubicOp70d(skiatest::Reporter* reporter, const char* filename) {
1348 SkPath path, pathB;
1349 path.setFillType(SkPath::kWinding_FillType);
1350 path.moveTo(0,1);
1351 path.cubicTo(0,5, 4,0, 5,0);
1352 path.close();
1353 pathB.setFillType(SkPath::kWinding_FillType);
1354 pathB.moveTo(0,4);
1355 pathB.cubicTo(0,5, 1,0, 5,0);
1356 pathB.close();
1357 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1358}
1359
1360static void cubicOp71d(skiatest::Reporter* reporter, const char* filename) {
1361 SkPath path, pathB;
1362 path.setFillType(SkPath::kWinding_FillType);
1363 path.moveTo(0,1);
1364 path.cubicTo(0,5, 4,1, 6,4);
1365 path.close();
1366 pathB.setFillType(SkPath::kWinding_FillType);
1367 pathB.moveTo(1,4);
1368 pathB.cubicTo(4,6, 1,0, 5,0);
1369 pathB.close();
1370 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1371}
1372
1373static void cubicOp72i(skiatest::Reporter* reporter, const char* filename) {
1374 SkPath path, pathB;
1375 path.setFillType(SkPath::kWinding_FillType);
1376 path.moveTo(0,1);
1377 path.cubicTo(0,5, 5,2, 5,4);
1378 path.close();
1379 pathB.setFillType(SkPath::kWinding_FillType);
1380 pathB.moveTo(2,5);
1381 pathB.cubicTo(4,5, 1,0, 5,0);
1382 pathB.close();
1383 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1384}
1385
1386static void cubicOp73d(skiatest::Reporter* reporter, const char* filename) {
1387 SkPath path, pathB;
1388 path.setFillType(SkPath::kWinding_FillType);
1389 path.moveTo(0,1);
1390 path.cubicTo(3,4, 4,0, 6,4);
1391 path.lineTo(0,1);
1392 path.close();
1393 pathB.setFillType(SkPath::kWinding_FillType);
1394 pathB.moveTo(0,4);
1395 pathB.cubicTo(4,6, 1,0, 4,3);
1396 pathB.lineTo(0,4);
1397 pathB.close();
1398 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1399}
1400
1401static void cubicOp74d(skiatest::Reporter* reporter, const char* filename) {
1402 SkPath path, pathB;
1403 path.setFillType(SkPath::kWinding_FillType);
1404 path.moveTo(0,1);
1405 path.cubicTo(1,5, 5,1, 5,1);
1406 path.lineTo(0,1);
1407 path.close();
1408 pathB.setFillType(SkPath::kWinding_FillType);
1409 pathB.moveTo(1,5);
1410 pathB.cubicTo(1,5, 1,0, 5,1);
1411 pathB.lineTo(1,5);
1412 pathB.close();
1413 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1414}
1415
1416static void cubicOp75d(skiatest::Reporter* reporter, const char* filename) {
1417 SkPath path, pathB;
1418 path.setFillType(SkPath::kWinding_FillType);
1419 path.moveTo(0,1);
1420 path.cubicTo(0,4, 5,1, 6,4);
1421 path.lineTo(0,1);
1422 path.close();
1423 pathB.setFillType(SkPath::kWinding_FillType);
1424 pathB.moveTo(1,5);
1425 pathB.cubicTo(4,6, 1,0, 4,0);
1426 pathB.lineTo(1,5);
1427 pathB.close();
1428 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1429}
1430
1431static void cubicOp76u(skiatest::Reporter* reporter, const char* filename) {
1432 SkPath path, pathB;
1433 path.setFillType(SkPath::kWinding_FillType);
1434 path.moveTo(0,1);
1435 path.cubicTo(0,2, 2,0, 5,3);
1436 path.close();
1437 pathB.setFillType(SkPath::kWinding_FillType);
1438 pathB.moveTo(0,2);
1439 pathB.cubicTo(3,5, 1,0, 2,0);
1440 pathB.close();
1441 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1442}
1443
1444static void cubicOp77i(skiatest::Reporter* reporter, const char* filename) {
1445 SkPath path, pathB;
1446 path.setFillType(SkPath::kEvenOdd_FillType);
1447 path.moveTo(0,1);
1448 path.cubicTo(1,3, 2,0, 3,2);
1449 path.lineTo(0,1);
1450 path.close();
1451 pathB.setFillType(SkPath::kEvenOdd_FillType);
1452 pathB.moveTo(0,2);
1453 pathB.cubicTo(2,3, 1,0, 3,1);
1454 pathB.lineTo(0,2);
1455 pathB.close();
1456 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1457}
1458
1459static void cubicOp78u(skiatest::Reporter* reporter, const char* filename) {
1460 SkPath path, pathB;
1461 path.setFillType(SkPath::kEvenOdd_FillType);
1462 path.moveTo(1,6);
1463 path.cubicTo(1,6, 5,0, 6,1);
1464 path.lineTo(1,6);
1465 path.close();
1466 pathB.setFillType(SkPath::kEvenOdd_FillType);
1467 pathB.moveTo(0,5);
1468 pathB.cubicTo(1,6, 6,1, 6,1);
1469 pathB.lineTo(0,5);
1470 pathB.close();
1471 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1472}
1473
1474static void cubicOp79u(skiatest::Reporter* reporter, const char* filename) {
1475 SkPath path, pathB;
1476 path.setFillType(SkPath::kWinding_FillType);
1477 path.moveTo(0,1);
1478 path.cubicTo(1,3, 1,0, 6,4);
1479 path.close();
1480 pathB.setFillType(SkPath::kWinding_FillType);
1481 pathB.moveTo(0,1);
1482 pathB.cubicTo(4,6, 1,0, 3,1);
1483 pathB.close();
1484 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1485}
1486
1487static void cubicOp80i(skiatest::Reporter* reporter, const char* filename) {
1488 SkPath path, pathB;
1489 path.setFillType(SkPath::kWinding_FillType);
1490 path.moveTo(0,1);
1491 path.cubicTo(2,3, 2,1, 4,3);
1492 path.lineTo(0,1);
1493 path.close();
1494 pathB.setFillType(SkPath::kWinding_FillType);
1495 pathB.moveTo(1,2);
1496 pathB.cubicTo(3,4, 1,0, 3,2);
1497 pathB.lineTo(1,2);
1498 pathB.close();
1499 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1500}
1501
1502static void cubicOp81d(skiatest::Reporter* reporter, const char* filename) {
1503 SkPath path, pathB;
1504 path.setFillType(SkPath::kWinding_FillType);
1505 path.moveTo(0,1);
1506 path.cubicTo(4,6, 4,3, 5,4);
1507 path.close();
1508 pathB.setFillType(SkPath::kWinding_FillType);
1509 pathB.moveTo(3,4);
1510 pathB.cubicTo(4,5, 1,0, 6,4);
1511 pathB.close();
1512 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1513}
1514
1515static void cubicOp82i(skiatest::Reporter* reporter, const char* filename) {
1516 SkPath path, pathB;
1517 path.setFillType(SkPath::kEvenOdd_FillType);
1518 path.moveTo(0,1);
1519 path.cubicTo(2,3, 5,2, 3,0);
1520 path.lineTo(0,1);
1521 path.close();
1522 pathB.setFillType(SkPath::kWinding_FillType);
1523 pathB.moveTo(2,5);
1524 pathB.cubicTo(0,3, 1,0, 3,2);
1525 pathB.lineTo(2,5);
1526 pathB.close();
1527 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1528}
1529
1530static void cubicOp83i(skiatest::Reporter* reporter, const char* filename) {
1531 SkPath path, pathB;
1532 path.setFillType(SkPath::kWinding_FillType);
1533 path.moveTo(0,1);
1534 path.cubicTo(0,3, 2,1, 4,1);
1535 path.lineTo(0,1);
1536 path.close();
1537 pathB.setFillType(SkPath::kWinding_FillType);
1538 pathB.moveTo(1,2);
1539 pathB.cubicTo(1,4, 1,0, 3,0);
1540 pathB.lineTo(1,2);
1541 pathB.close();
1542 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1543}
1544
1545static void cubicOp84d(skiatest::Reporter* reporter, const char* filename) {
1546 SkPath path, pathB;
1547 path.setFillType(SkPath::kWinding_FillType);
1548 path.moveTo(0,4);
1549 path.cubicTo(2,3, 6,3, 3,2);
1550 path.close();
1551 pathB.setFillType(SkPath::kWinding_FillType);
1552 pathB.moveTo(3,6);
1553 pathB.cubicTo(2,3, 4,0, 3,2);
1554 pathB.close();
1555 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1556}
1557
1558static void skpClip1(skiatest::Reporter* reporter, const char* filename) {
1559 SkPath path;
1560 path.setFillType(SkPath::kEvenOdd_FillType);
1561 path.moveTo(1126.17114f, 877.171204f);
1562 path.quadTo(1127.34314f, 876.000000f, 1129.00000f, 876.000000f);
1563 path.lineTo(1243.00000f, 876.000000f);
1564 path.quadTo(1244.65686f, 876.000000f, 1245.82886f, 877.171204f);
1565 path.quadTo(1247.00000f, 878.343140f, 1247.00000f, 880.000000f);
1566 path.lineTo(1247.00000f, 907.000000f);
1567 path.lineTo(1246.00000f, 907.000000f);
1568 path.lineTo(1246.00000f, 880.000000f);
1569 path.cubicTo(1246.00000f, 878.343140f, 1244.65686f, 877.000000f, 1243.00000f, 877.000000f);
1570 path.lineTo(1129.00000f, 877.000000f);
1571 path.cubicTo(1127.34314f, 877.000000f, 1126.00000f, 878.343140f, 1126.00000f, 880.000000f);
1572 path.lineTo(1126.00000f, 907.000000f);
1573 path.lineTo(1125.00000f, 907.000000f);
1574 path.lineTo(1125.00000f, 880.000000f);
1575 path.quadTo(1125.00000f, 878.343140f, 1126.17114f, 877.171204f);
1576 path.close();
1577 SkPath pathB;
1578 pathB.setFillType(SkPath::kWinding_FillType);
1579 pathB.moveTo(1247.00000f, 876.000000f);
1580 pathB.lineTo(1231.00000f, 892.000000f);
1581 pathB.lineTo(1246.00000f, 907.000000f);
1582 pathB.lineTo(1247.00000f, 907.000000f);
1583 pathB.lineTo(1247.00000f, 876.000000f);
1584 pathB.close();
1585 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1586}
1587
1588static void skpClip2(skiatest::Reporter* reporter, const char* filename) {
1589 SkPath path;
1590 path.setFillType(SkPath::kEvenOdd_FillType);
1591 path.moveTo(134.000000f, 11414.0000f);
1592 path.cubicTo(131.990234f, 11414.0000f, 130.326660f, 11415.4824f, 130.042755f, 11417.4131f);
1593 path.cubicTo(130.233124f, 11418.3193f, 131.037079f, 11419.0000f, 132.000000f, 11419.0000f);
1594 path.lineTo(806.000000f, 11419.0000f);
1595 path.cubicTo(806.962891f, 11419.0000f, 807.766907f, 11418.3193f, 807.957275f, 11417.4131f);
1596 path.cubicTo(807.673401f, 11415.4824f, 806.009766f, 11414.0000f, 804.000000f, 11414.0000f);
1597 path.lineTo(134.000000f, 11414.0000f);
1598 path.close();
1599 SkPath pathB;
1600 pathB.setFillType(SkPath::kInverseWinding_FillType);
1601 pathB.moveTo(132.000000f, 11415.0000f);
1602 pathB.lineTo(806.000000f, 11415.0000f);
1603 pathB.cubicTo(807.104553f, 11415.0000f, 808.000000f, 11415.4473f, 808.000000f, 11416.0000f);
1604 pathB.lineTo(808.000000f, 11417.0000f);
1605 pathB.cubicTo(808.000000f, 11418.1045f, 807.104553f, 11419.0000f, 806.000000f, 11419.0000f);
1606 pathB.lineTo(132.000000f, 11419.0000f);
1607 pathB.cubicTo(130.895432f, 11419.0000f, 130.000000f, 11418.1045f, 130.000000f, 11417.0000f);
1608 pathB.lineTo(130.000000f, 11416.0000f);
1609 pathB.cubicTo(130.000000f, 11415.4473f, 130.895432f, 11415.0000f, 132.000000f, 11415.0000f);
1610 pathB.close();
1611 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1612}
1613
1614static void skp96prezzi1(skiatest::Reporter* reporter, const char* filename) {
1615 SkPath path;
1616 path.setFillType(SkPath::kEvenOdd_FillType);
1617 path.moveTo(157.464005f, 670.463989f);
1618 path.quadTo(158.928925f, 669.000000f, 161.000000f, 669.000000f);
1619 path.lineTo(248.000000f, 669.000000f);
1620 path.quadTo(250.071075f, 669.000000f, 251.535995f, 670.463989f);
1621 path.quadTo(253.000000f, 671.928955f, 253.000000f, 674.000000f);
1622 path.lineTo(253.000000f, 706.000000f);
1623 path.lineTo(251.000000f, 706.000000f);
1624 path.lineTo(251.000000f, 675.000000f);
1625 path.cubicTo(251.000000f, 672.790833f, 249.209137f, 671.000000f, 247.000000f, 671.000000f);
1626 path.lineTo(162.000000f, 671.000000f);
1627 path.cubicTo(159.790863f, 671.000000f, 158.000000f, 672.790833f, 158.000000f, 675.000000f);
1628 path.lineTo(158.000000f, 706.000000f);
1629 path.lineTo(156.000000f, 706.000000f);
1630 path.lineTo(156.000000f, 674.000000f);
1631 path.quadTo(156.000000f, 671.928955f, 157.464005f, 670.463989f);
1632 path.close();
1633 SkPath pathB;
1634 pathB.setFillType(SkPath::kWinding_FillType);
1635 pathB.moveTo(156.000000f, 669.000000f);
1636 pathB.lineTo(178.500000f, 691.500000f);
1637 pathB.lineTo(230.500000f, 691.500000f);
1638 pathB.lineTo(253.000000f, 669.000000f);
1639 pathB.lineTo(156.000000f, 669.000000f);
1640 pathB.close();
1641 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1642}
1643
1644static void skpancestry_com1(skiatest::Reporter* reporter, const char* filename) {
1645 SkPath path;
1646 path.setFillType(SkPath::kEvenOdd_FillType);
1647 path.moveTo(161.000000f, 925.000000f);
1648 path.cubicTo(159.874390f, 925.000000f, 158.835663f, 925.371948f, 158.000000f, 925.999634f);
1649 path.lineTo(158.000000f, 926.000000f);
1650 path.lineTo(1108.00000f, 926.000000f);
1651 path.lineTo(1108.00000f, 925.999634f);
1652 path.cubicTo(1107.16443f, 925.371948f, 1106.12561f, 925.000000f, 1105.00000f, 925.000000f);
1653 path.lineTo(161.000000f, 925.000000f);
1654 path.close();
1655 SkPath pathB;
1656 pathB.setFillType(SkPath::kEvenOdd_FillType);
1657 pathB.moveTo(161.000000f, 926.000000f);
1658 pathB.lineTo(1105.00000f, 926.000000f);
1659 pathB.cubicTo(1107.20911f, 926.000000f, 1109.00000f, 927.790833f, 1109.00000f, 930.000000f);
1660 pathB.lineTo(1109.00000f, 956.000000f);
1661 pathB.cubicTo(1109.00000f, 958.209167f, 1107.20911f, 960.000000f, 1105.00000f, 960.000000f);
1662 pathB.lineTo(161.000000f, 960.000000f);
1663 pathB.cubicTo(158.790863f, 960.000000f, 157.000000f, 958.209167f, 157.000000f, 956.000000f);
1664 pathB.lineTo(157.000000f, 930.000000f);
1665 pathB.cubicTo(157.000000f, 927.790833f, 158.790863f, 926.000000f, 161.000000f, 926.000000f);
1666 pathB.close();
1667 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1668}
1669
1670static void skpeldorado_com_ua1(skiatest::Reporter* reporter, const char* filename) {
1671 SkPath path;
1672 path.setFillType(SkPath::kEvenOdd_FillType);
1673 path.moveTo(286.695129f, 291.000000f);
1674 path.lineTo(229.304855f, 561.000000f);
1675 path.lineTo(979.304871f, 561.000000f);
1676 path.lineTo(1036.69507f, 291.000000f);
1677 path.lineTo(286.695129f, 291.000000f);
1678 path.close();
1679 SkPath pathB;
1680 pathB.setFillType(SkPath::kWinding_FillType);
1681 pathB.moveTo(1006.69513f, 291.000000f);
1682 pathB.cubicTo(1023.26367f, 291.000000f, 1033.84021f, 304.431458f, 1030.31836f, 321.000000f);
1683 pathB.lineTo(985.681519f, 531.000000f);
1684 pathB.cubicTo(982.159790f, 547.568542f, 965.873413f, 561.000000f, 949.304871f, 561.000000f);
1685 pathB.lineTo(259.304871f, 561.000000f);
1686 pathB.cubicTo(242.736313f, 561.000000f, 232.159805f, 547.568542f, 235.681549f, 531.000000f);
1687 pathB.lineTo(280.318420f, 321.000000f);
1688 pathB.cubicTo(283.840179f, 304.431458f, 300.126587f, 291.000000f, 316.695129f, 291.000000f);
1689 pathB.lineTo(1006.69513f, 291.000000f);
1690 pathB.close();
1691 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1692}
1693
1694static void skpbyte_com1(skiatest::Reporter* reporter, const char* filename) {
1695 SkPath path;
1696 path.setFillType(SkPath::kEvenOdd_FillType);
1697 path.moveTo(968.000000f, 14.0000000f);
1698 path.cubicTo(965.238586f, 14.0000000f, 963.000000f, 16.2385769f, 963.000000f, 19.0000000f);
1699 path.lineTo(963.000000f, 32.0000000f);
1700 path.cubicTo(963.000000f, 34.7614250f, 965.238586f, 37.0000000f, 968.000000f, 37.0000000f);
1701 path.lineTo(1034.00000f, 37.0000000f);
1702 path.cubicTo(1036.76147f, 37.0000000f, 1039.00000f, 34.7614250f, 1039.00000f, 32.0000000f);
1703 path.lineTo(1039.00000f, 19.0000000f);
1704 path.cubicTo(1039.00000f, 16.2385769f, 1036.76147f, 14.0000000f, 1034.00000f, 14.0000000f);
1705 path.lineTo(968.000000f, 14.0000000f);
1706 path.close();
1707 SkPath pathB;
1708 pathB.setFillType(SkPath::kInverseWinding_FillType);
1709 pathB.moveTo(968.000000f, 14.0000000f);
1710 pathB.lineTo(1034.00000f, 14.0000000f);
1711 pathB.cubicTo(1036.76147f, 14.0000000f, 1039.00000f, 16.2385750f, 1039.00000f, 19.0000000f);
1712 pathB.lineTo(1039.00000f, 32.0000000f);
1713 pathB.cubicTo(1039.00000f, 34.2091408f, 1036.76147f, 36.0000000f, 1034.00000f, 36.0000000f);
1714 pathB.lineTo(968.000000f, 36.0000000f);
1715 pathB.cubicTo(965.238586f, 36.0000000f, 963.000000f, 34.2091408f, 963.000000f, 32.0000000f);
1716 pathB.lineTo(963.000000f, 19.0000000f);
1717 pathB.cubicTo(963.000000f, 16.2385750f, 965.238586f, 14.0000000f, 968.000000f, 14.0000000f);
1718 pathB.close();
1719 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1720}
1721
1722static void skphealth_com76(skiatest::Reporter* reporter, const char* filename) {
1723 SkPath path;
1724 path.setFillType(SkPath::kEvenOdd_FillType);
1725 path.moveTo(708.099182f, 7.09919119f);
1726 path.lineTo(708.099182f, 7.09920025f);
1727 path.quadTo(704.000000f, 11.2010098f, 704.000000f, 17.0000000f);
1728 path.lineTo(704.000000f, 33.0000000f);
1729 path.lineTo(705.000000f, 33.0000000f);
1730 path.lineTo(705.000000f, 17.0000000f);
1731 path.cubicTo(705.000000f, 13.4101496f, 706.455078f, 10.1601505f, 708.807617f, 7.80761385f);
1732 path.lineTo(708.099182f, 7.09919119f);
1733 path.close();
1734 SkPath pathB;
1735 pathB.setFillType(SkPath::kWinding_FillType);
1736 pathB.moveTo(704.000000f, 3.00000000f);
1737 pathB.lineTo(704.000000f, 33.0000000f);
1738 pathB.lineTo(705.000000f, 33.0000000f);
1739 pathB.lineTo(719.500000f, 3.00000000f);
1740 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1741}
1742
1743static void skpahrefs_com88(skiatest::Reporter* reporter, const char* filename) {
1744 SkPath path;
1745 path.setFillType(SkPath::kEvenOdd_FillType);
1746 path.moveTo(1099.82886f, 7.17117119f);
1747 path.lineTo(1099.12134f, 7.87867832f);
1748 path.cubicTo(1099.66418f, 8.42157173f, 1100.00000f, 9.17157173f, 1100.00000f, 10.0000000f);
1749 path.lineTo(1100.00000f, 28.0000000f);
1750 path.cubicTo(1100.00000f, 29.6568546f, 1098.65686f, 31.0000000f, 1097.00000f, 31.0000000f);
1751 path.lineTo(1088.00000f, 31.0000000f);
1752 path.lineTo(1088.00000f, 32.0000000f);
1753 path.lineTo(1097.00000f, 32.0000000f);
1754 path.quadTo(1098.65686f, 32.0000000f, 1099.82886f, 30.8288002f);
1755 path.quadTo(1101.00000f, 29.6568546f, 1101.00000f, 28.0000000f);
1756 path.lineTo(1101.00000f, 10.0000000f);
1757 path.quadTo(1101.00000f, 8.34314537f, 1099.82886f, 7.17119980f);
1758 path.lineTo(1099.82886f, 7.17117119f);
1759 path.close();
1760 SkPath pathB;
1761 pathB.setFillType(SkPath::kWinding_FillType);
1762 pathB.moveTo(1101.00000f, 6.00000000f);
1763 pathB.lineTo(1088.00000f, 6.00000000f);
1764 pathB.lineTo(1088.00000f, 19.0000000f);
1765 pathB.lineTo(1101.00000f, 32.0000000f);
1766 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1767}
1768
1769static void skpahrefs_com29(skiatest::Reporter* reporter, const char* filename) {
1770 SkPath path;
1771 path.setFillType(SkPath::kEvenOdd_FillType);
1772 path.moveTo(1037.17114f, 7.17119980f);
1773 path.quadTo(1038.34314f, 6.00000000f, 1040.00000f, 6.00000000f);
1774 path.lineTo(1074.00000f, 6.00000000f);
1775 path.lineTo(1074.00000f, 32.0000000f);
1776 path.lineTo(1040.00000f, 32.0000000f);
1777 path.quadTo(1038.34314f, 32.0000000f, 1037.17114f, 30.8288002f);
1778 path.quadTo(1036.00000f, 29.6568546f, 1036.00000f, 28.0000000f);
1779 path.lineTo(1036.00000f, 10.0000000f);
1780 path.quadTo(1036.00000f, 8.34314537f, 1037.17114f, 7.17119980f);
1781 path.close();
1782 path.moveTo(1037.00000f, 10.0000000f);
1783 path.cubicTo(1037.00000f, 8.34314537f, 1038.34314f, 7.00000000f, 1040.00000f, 7.00000000f);
1784 path.lineTo(1073.00000f, 7.00000000f);
1785 path.lineTo(1073.00000f, 31.0000000f);
1786 path.lineTo(1040.00000f, 31.0000000f);
1787 path.cubicTo(1038.34314f, 31.0000000f, 1037.00000f, 29.6568546f, 1037.00000f, 28.0000000f);
1788 path.lineTo(1037.00000f, 10.0000000f);
1789 path.close();
1790 SkPath pathB;
1791 pathB.setFillType(SkPath::kWinding_FillType);
1792 pathB.moveTo(1036.00000f, 32.0000000f);
1793 pathB.lineTo(1049.00000f, 19.0000000f);
1794 pathB.lineTo(1073.00000f, 31.0000000f);
1795 pathB.lineTo(1074.00000f, 32.0000000f);
1796 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1797}
1798
1799static void cubicOp85d(skiatest::Reporter* reporter, const char* filename) {
1800 SkPath path;
1801 path.setFillType(SkPath::kWinding_FillType);
1802 path.moveTo(0,1);
1803 path.cubicTo(1,6, 1,0, 6,2);
1804 path.close();
1805 SkPath pathB;
1806 pathB.setFillType(SkPath::kWinding_FillType);
1807 pathB.moveTo(0,1);
1808 pathB.cubicTo(2,6, 1,0, 6,1);
1809 pathB.close();
1810 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1811}
1812
1813static void skpkkiste_to98(skiatest::Reporter* reporter, const char* filename) {
1814 SkPath path;
1815 path.setFillType(SkPath::kEvenOdd_FillType);
1816 path.moveTo(96, 122);
1817 path.cubicTo(94.6192932f, 122, 93.3692932f, 122.559647f, 92.4644699f, 123.46447f);
1818 path.lineTo(94.1715698f, 125.17157f);
1819 path.cubicTo(94.8954315f, 124.447708f, 95.8954315f, 124, 97, 124);
1820 path.lineTo(257, 124);
1821 path.cubicTo(258.104553f, 124, 259.104584f, 124.447708f, 259.82843f, 125.17157f);
1822 path.lineTo(261.535522f, 123.46447f);
1823 path.cubicTo(260.630707f, 122.559647f, 259.380707f, 122, 258, 122);
1824 path.lineTo(96, 122);
1825 path.close();
1826 SkPath pathB;
1827 pathB.setFillType(SkPath::kWinding_FillType);
1828 pathB.moveTo(258, 122);
1829 pathB.cubicTo(260.761414f, 122, 263, 124.238579f, 263, 127);
1830 pathB.lineTo(263, 284);
1831 pathB.cubicTo(263, 286.761414f, 260.761414f, 289, 258, 289);
1832 pathB.lineTo(96, 289);
1833 pathB.cubicTo(93.2385788f, 289, 91, 286.761414f, 91, 284);
1834 pathB.lineTo(91, 127);
1835 pathB.cubicTo(91, 124.238579f, 93.2385788f, 122, 96, 122);
1836 pathB.lineTo(258, 122);
1837 pathB.close();
1838 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1839}
1840
1841static void issue1417(skiatest::Reporter* reporter, const char* filename) {
1842 SkPath path1;
1843 path1.moveTo(122.58908843994140625f, 82.2836456298828125f);
1844 path1.quadTo(129.8215789794921875f, 80, 138, 80);
1845 path1.quadTo(147.15692138671875f, 80, 155.1280364990234375f, 82.86279296875f);
1846 path1.lineTo(161.1764678955078125f, 100);
1847 path1.lineTo(161.1764678955078125f, 100);
1848 path1.lineTo(115.29412078857421875f, 100);
1849 path1.lineTo(115.29412078857421875f, 100);
1850 path1.lineTo(122.58908843994140625f, 82.2836456298828125f);
1851 path1.lineTo(122.58908843994140625f, 82.2836456298828125f);
1852 path1.close();
1853 path1.moveTo(98.68194580078125f, 140.343841552734375f);
1854 path1.lineTo(115.29412078857421875f, 100);
1855 path1.lineTo(115.29412078857421875f, 100);
1856 path1.lineTo(97.9337615966796875f, 100);
1857 path1.lineTo(97.9337615966796875f, 100);
1858 path1.quadTo(88, 112.94264984130859375f, 88, 130);
1859 path1.quadTo(88, 131.544830322265625f, 88.08148956298828125f, 133.0560302734375f);
1860 path1.lineTo(98.68194580078125f, 140.343841552734375f);
1861 path1.lineTo(98.68194580078125f, 140.343841552734375f);
1862 path1.close();
1863 path1.moveTo(136.969696044921875f, 166.6666717529296875f);
1864 path1.lineTo(98.68194580078125f, 140.343841552734375f);
1865 path1.lineTo(98.68194580078125f, 140.343841552734375f);
1866 path1.lineTo(93.45894622802734375f, 153.02825927734375f);
1867 path1.lineTo(93.45894622802734375f, 153.02825927734375f);
1868 path1.quadTo(96.94116973876953125f, 159.65185546875f, 102.64466094970703125f, 165.3553466796875f);
1869 path1.quadTo(110.7924652099609375f, 173.503143310546875f, 120.8179779052734375f, 177.1177825927734375f);
1870 path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1871 path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1872 path1.close();
1873 path1.moveTo(175.8309783935546875f, 141.5211334228515625f);
1874 path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1875 path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1876 path1.lineTo(153.15728759765625f, 177.7956390380859375f);
1877 path1.lineTo(153.15728759765625f, 177.7956390380859375f);
1878 path1.quadTo(164.392425537109375f, 174.318267822265625f, 173.3553466796875f, 165.3553466796875f);
1879 path1.quadTo(177.805816650390625f, 160.9048614501953125f, 180.90380859375f, 155.8941650390625f);
1880 path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1881 path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1882 path1.close();
1883 path1.moveTo(175.8309783935546875f, 141.5211334228515625f);
1884 path1.lineTo(187.8782806396484375f, 133.7258148193359375f);
1885 path1.lineTo(187.8782806396484375f, 133.7258148193359375f);
1886 path1.quadTo(188, 131.8880615234375f, 188, 130);
1887 path1.quadTo(188, 112.942657470703125f, 178.0662384033203125f, 100);
1888 path1.lineTo(161.1764678955078125f, 100);
1889 path1.lineTo(161.1764678955078125f, 100);
1890 path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1891 path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1892 path1.close();
1893
1894 SkPath path2;
1895 path2.moveTo(174.117645263671875f, 100);
1896 path2.lineTo(161.1764678955078125f, 100);
1897 path2.lineTo(161.1764678955078125f, 100);
1898 path2.lineTo(155.1280364990234375f, 82.86279296875f);
1899 path2.lineTo(155.1280364990234375f, 82.86279296875f);
1900 path2.quadTo(153.14971923828125f, 82.15229034423828125f, 151.098419189453125f, 81.618133544921875f);
1901 path2.lineTo(143.5294189453125f, 100);
1902 path2.lineTo(143.5294189453125f, 100);
1903 path2.lineTo(161.1764678955078125f, 100);
1904 path2.lineTo(161.1764678955078125f, 100);
1905 path2.lineTo(168.23529052734375f, 120);
1906 path2.lineTo(168.23529052734375f, 120);
1907 path2.lineTo(181.1764678955078125f, 120);
1908 path2.lineTo(181.1764678955078125f, 120);
1909 path2.lineTo(186.3661956787109375f, 134.7042236328125f);
1910 path2.lineTo(186.3661956787109375f, 134.7042236328125f);
1911 path2.lineTo(187.8782806396484375f, 133.7258148193359375f);
1912 path2.lineTo(187.8782806396484375f, 133.7258148193359375f);
1913 path2.quadTo(188, 131.8880615234375f, 188, 130);
1914 path2.quadTo(188, 124.80947113037109375f, 187.080169677734375f, 120);
1915 path2.lineTo(181.1764678955078125f, 120);
1916 path2.lineTo(181.1764678955078125f, 120);
1917 path2.lineTo(174.117645263671875f, 100);
1918 path2.lineTo(174.117645263671875f, 100);
1919 path2.close();
1920 path2.moveTo(88.91983795166015625f, 120);
1921 path2.lineTo(107.0588226318359375f, 120);
1922 path2.lineTo(107.0588226318359375f, 120);
1923 path2.lineTo(98.68194580078125f, 140.343841552734375f);
1924 path2.lineTo(98.68194580078125f, 140.343841552734375f);
1925 path2.lineTo(88.08148956298828125f, 133.0560302734375f);
1926 path2.lineTo(88.08148956298828125f, 133.0560302734375f);
1927 path2.quadTo(88, 131.544830322265625f, 88, 130);
1928 path2.quadTo(88, 124.80951690673828125f, 88.91983795166015625f, 120);
1929 path2.close();
1930 path2.moveTo(96.67621612548828125f, 145.21490478515625f);
1931 path2.lineTo(98.68194580078125f, 140.343841552734375f);
1932 path2.lineTo(98.68194580078125f, 140.343841552734375f);
1933 path2.lineTo(120.68767547607421875f, 155.4727783203125f);
1934 path2.lineTo(120.68767547607421875f, 155.4727783203125f);
1935 path2.lineTo(118.68194580078125f, 160.343841552734375f);
1936 path2.lineTo(118.68194580078125f, 160.343841552734375f);
1937 path2.lineTo(96.67621612548828125f, 145.21490478515625f);
1938 path2.lineTo(96.67621612548828125f, 145.21490478515625f);
1939 path2.close();
1940 path2.moveTo(113.232177734375f, 173.5789947509765625f);
1941 path2.quadTo(116.8802642822265625f, 175.69805908203125f, 120.8179779052734375f, 177.1177825927734375f);
1942 path2.lineTo(132.2864990234375f, 169.6969757080078125f);
1943 path2.lineTo(132.2864990234375f, 169.6969757080078125f);
1944 path2.lineTo(118.68194580078125f, 160.343841552734375f);
1945 path2.lineTo(118.68194580078125f, 160.343841552734375f);
1946 path2.lineTo(113.232177734375f, 173.5789947509765625f);
1947 path2.lineTo(113.232177734375f, 173.5789947509765625f);
1948 path2.close();
1949 // FIXME : difficult data, circle back later
1950 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename);
1951}
1952
1953static void issue1418(skiatest::Reporter* reporter, const char* filename) {
1954 SkPath path1;
1955 path1.moveTo(0, 0);
1956 path1.lineTo(1, 0);
1957 path1.lineTo(1, 0);
1958 path1.lineTo(1, 1);
1959 path1.lineTo(1, 1);
1960 path1.lineTo(0, 1);
1961 path1.lineTo(0, 1);
1962 path1.lineTo(0, 0);
1963 path1.lineTo(0, 0);
1964 path1.close();
1965
1966 SkPath path2;
1967 path2.moveTo(0.64644664525985717773f, -0.35355341434478759766f);
1968 path2.quadTo(0.79289329051971435547f, -0.50000005960464477539f, 1.0000001192092895508f, -0.50000005960464477539f);
1969 path2.quadTo(1.2071068286895751953f, -0.50000005960464477539f, 1.3535535335540771484f, -0.35355341434478759766f);
1970 path2.quadTo(1.5000001192092895508f, -0.20710679888725280762f, 1.5000001192092895508f, 0);
1971 path2.quadTo(1.5000001192092895508f, 0.20710679888725280762f, 1.3535535335540771484f, 0.35355341434478759766f);
1972 path2.quadTo(1.2071068286895751953f, 0.50000005960464477539f, 1.0000001192092895508f, 0.50000005960464477539f);
1973 path2.quadTo(0.79289329051971435547f, 0.50000005960464477539f, 0.64644664525985717773f, 0.35355341434478759766f);
1974 path2.quadTo(0.50000005960464477539f, 0.20710679888725280762f, 0.50000005960464477539f, 0);
1975 path2.quadTo(0.50000005960464477539f, -0.20710679888725280762f, 0.64644664525985717773f, -0.35355341434478759766f);
1976 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename);
1977}
1978
1979static void cubicOp85i(skiatest::Reporter* reporter, const char* filename) {
1980 SkPath path, pathB;
1981 path.setFillType(SkPath::kWinding_FillType);
1982 path.moveTo(3, 4);
1983 path.cubicTo(1, 5, 4, 3, 6, 4);
1984 path.close();
1985 pathB.setFillType(SkPath::kWinding_FillType);
1986 pathB.moveTo(3, 4);
1987 pathB.cubicTo(4, 6, 4, 3, 5, 1);
1988 pathB.close();
1989 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1990}
1991
1992static void issue1418b(skiatest::Reporter* reporter, const char* filename) {
1993 SkPath path1;
1994 path1.moveTo(0, 0);
1995 path1.lineTo(1, 0);
1996 path1.lineTo(1, 1);
1997 path1.lineTo(0, 1);
1998 path1.lineTo(0, 0);
1999 path1.close();
2000 path1.setFillType(SkPath::kWinding_FillType);
2001 SkPath path2;
2002 path2.moveTo(0.646446645f, -0.353553414f);
2003 path2.quadTo(0.792893291f, -0.50000006f, 1.00000012f, -0.50000006f);
2004 path2.quadTo(1.20710683f, -0.50000006f, 1.35355353f, -0.353553414f);
2005 path2.quadTo(1.50000012f, -0.207106799f, 1.50000012f, 0);
2006 path2.quadTo(1.50000012f, 0.207106799f, 1.35355353f, 0.353553414f);
2007 path2.quadTo(1.20710683f, 0.50000006f, 1.00000012f, 0.50000006f);
2008 path2.quadTo(0.792893291f, 0.50000006f, 0.646446645f, 0.353553414f);
2009 path2.quadTo(0.50000006f, 0.207106799f, 0.50000006f, 0);
2010 path2.quadTo(0.50000006f, -0.207106799f, 0.646446645f, -0.353553414f);
2011 path2.close();
2012 path2.moveTo(1.00000012f, 0.50000006f);
2013 path2.lineTo(1.00000012f, 1.00000012f);
2014 path2.lineTo(0.50000006f, 1.00000012f);
2015 path2.quadTo(0.50000006f, 0.792893291f, 0.646446645f, 0.646446645f);
2016 path2.quadTo(0.792893291f, 0.50000006f, 1.00000012f, 0.50000006f);
2017 path2.close();
2018 path2.setFillType(SkPath::kEvenOdd_FillType);
2019 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename);
2020}
2021
2022static void rectOp1i(skiatest::Reporter* reporter, const char* filename) {
2023 SkPath path, pathB;
2024 path.setFillType(SkPath::kWinding_FillType);
2025 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
2026 path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
2027 pathB.setFillType(SkPath::kWinding_FillType);
2028 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
2029 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
2030 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2031}
2032
2033static void rectOp2i(skiatest::Reporter* reporter, const char* filename) {
2034 SkPath path, pathB;
2035 path.setFillType(SkPath::kEvenOdd_FillType);
2036 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
2037 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
2038 pathB.setFillType(SkPath::kWinding_FillType);
2039 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
2040 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
2041 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2042}
2043
2044static void rectOp3x(skiatest::Reporter* reporter, const char* filename) {
2045 SkPath path, pathB;
2046 path.setFillType(SkPath::kEvenOdd_FillType);
2047 path.moveTo(0, 0);
2048 path.lineTo(3, 0);
2049 path.lineTo(3, 3);
2050 path.lineTo(0, 3);
2051 path.close();
2052 path.moveTo(2, 2);
2053 path.lineTo(3, 2);
2054 path.lineTo(3, 3);
2055 path.lineTo(2, 3);
2056 path.close();
2057 pathB.setFillType(SkPath::kWinding_FillType);
2058 pathB.moveTo(1, 1);
2059 pathB.lineTo(3, 1);
2060 pathB.lineTo(3, 3);
2061 pathB.lineTo(1, 3);
2062 pathB.close();
2063 pathB.moveTo(2, 2);
2064 pathB.lineTo(3, 2);
2065 pathB.lineTo(3, 3);
2066 pathB.lineTo(2, 3);
2067 pathB.close();
2068 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
2069}
2070
2071static void issue1435(skiatest::Reporter* reporter, const char* filename) {
2072 SkPath path1;
2073 path1.moveTo(160, 60);
2074 path1.lineTo(220, 230);
2075 path1.lineTo(60, 120);
2076 path1.lineTo(260, 120);
2077 path1.lineTo(90, 230);
2078 path1.lineTo(160, 60);
2079 path1.close();
2080 path1.setFillType(SkPath::kEvenOdd_FillType);
2081
2082 SkPath path2;
2083 path2.moveTo(142.589081f, 102.283646f);
2084 path2.quadTo(149.821579f, 100, 158, 100);
2085 path2.quadTo(167.156921f, 100, 175.128036f, 102.862793f);
2086 path2.lineTo(181.176468f, 120);
2087 path2.lineTo(135.294128f, 120);
2088 path2.lineTo(142.589081f, 102.283646f);
2089 path2.close();
2090 path2.moveTo(118.681946f, 160.343842f);
2091 path2.lineTo(135.294128f, 120);
2092 path2.lineTo(117.933762f, 120);
2093 path2.quadTo(108, 132.942657f, 108, 150);
2094 path2.quadTo(108, 151.54483f, 108.08149f, 153.05603f);
2095 path2.lineTo(118.681946f, 160.343842f);
2096 path2.close();
2097 path2.moveTo(156.969696f, 186.666672f);
2098 path2.lineTo(118.681946f, 160.343842f);
2099 path2.lineTo(113.458946f, 173.028259f);
2100 path2.quadTo(116.94117f, 179.651855f, 122.644661f, 185.355347f);
2101 path2.quadTo(130.792465f, 193.503143f, 140.817978f, 197.117783f);
2102 path2.lineTo(156.969696f, 186.666672f);
2103 path2.close();
2104 path2.moveTo(195.830978f, 161.521133f);
2105 path2.lineTo(156.969696f, 186.666672f);
2106 path2.lineTo(173.157288f, 197.795639f);
2107 path2.quadTo(184.392426f, 194.318268f, 193.355347f, 185.355347f);
2108 path2.quadTo(197.805817f, 180.904861f, 200.903809f, 175.894165f);
2109 path2.lineTo(195.830978f, 161.521133f);
2110 path2.close();
2111 path2.moveTo(195.830978f, 161.521133f);
2112 path2.lineTo(207.878281f, 153.725815f);
2113 path2.quadTo(208, 151.888062f, 208, 150);
2114 path2.quadTo(208, 132.942657f, 198.066238f, 120);
2115 path2.lineTo(181.176468f, 120);
2116 path2.lineTo(195.830978f, 161.521133f);
2117 path2.close();
2118 path2.setFillType(SkPath::kEvenOdd_FillType);
2119 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename);
2120}
2121
2122static void skpkkiste_to716(skiatest::Reporter* reporter, const char* filename) {
2123 SkPath path;
2124 path.setFillType(SkPath::kEvenOdd_FillType);
2125 path.moveTo(1173, 284);
2126 path.cubicTo(1173, 285.125824f, 1173.37207f, 286.164734f, 1174, 287.000488f);
2127 path.lineTo(1174, 123.999496f);
2128 path.cubicTo(1173.37207f, 124.835243f, 1173, 125.874168f, 1173, 127);
2129 path.lineTo(1173, 284);
2130 path.close();
2131 SkPath pathB;
2132 pathB.setFillType(SkPath::kWinding_FillType);
2133 pathB.moveTo(1340, 122);
2134 pathB.cubicTo(1342.76147f, 122, 1345, 124.238579f, 1345, 127);
2135 pathB.lineTo(1345, 284);
2136 pathB.cubicTo(1345, 286.761414f, 1342.76147f, 289, 1340, 289);
2137 pathB.lineTo(1178, 289);
2138 pathB.cubicTo(1175.23853f, 289, 1173, 286.761414f, 1173, 284);
2139 pathB.lineTo(1173, 127);
2140 pathB.cubicTo(1173, 124.238579f, 1175.23853f, 122, 1178, 122);
2141 pathB.lineTo(1340, 122);
2142 pathB.close();
2143 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2144}
2145
2146static void loopEdge1(skiatest::Reporter* reporter, const char* filename) {
2147 SkPath path;
2148 path.setFillType(SkPath::kEvenOdd_FillType);
2149 path.moveTo(0,0);
2150 path.lineTo(3,0);
2151 path.lineTo(3,2);
2152 path.lineTo(1,2);
2153 path.lineTo(1,1);
2154 path.lineTo(2,1);
2155 path.lineTo(2,3);
2156 path.lineTo(0,3);
2157 path.close();
2158 SkPath pathB;
2159 pathB.setFillType(SkPath::kEvenOdd_FillType);
2160 pathB.moveTo(1,2);
2161 pathB.lineTo(2,2);
2162 pathB.lineTo(2,4);
2163 pathB.lineTo(1,4);
2164 pathB.close();
2165 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2166}
2167
2168static void loopEdge2(skiatest::Reporter* reporter, const char* filename) {
2169 SkPath path;
2170 path.setFillType(SkPath::kEvenOdd_FillType);
2171 path.moveTo(0,0);
2172 path.lineTo(3,0);
2173 path.lineTo(3,2);
2174 path.lineTo(1,2);
2175 path.lineTo(1,1);
2176 path.lineTo(2,1);
2177 path.lineTo(2,3);
2178 path.lineTo(0,3);
2179 path.close();
2180 SkPath pathB;
2181 pathB.setFillType(SkPath::kEvenOdd_FillType);
2182 pathB.moveTo(1 - 1e-6f,2);
2183 pathB.lineTo(2 - 1e-6f,2);
2184 pathB.lineTo(2 - 1e-6f,4);
2185 pathB.lineTo(1 - 1e-6f,4);
2186 pathB.close();
2187 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2188}
2189
2190static void cubicOp86i(skiatest::Reporter* reporter, const char* filename) {
2191 SkPath path, pathB;
2192 path.setFillType(SkPath::kWinding_FillType);
2193 path.moveTo(0, 4);
2194 path.cubicTo(3, 4, 6, 2, 5, 2);
2195 path.close();
2196 pathB.setFillType(SkPath::kEvenOdd_FillType);
2197 pathB.moveTo(2, 6);
2198 pathB.cubicTo(2, 5, 4, 0, 4, 3);
2199 pathB.close();
2200 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2201}
2202
2203static void cubicOp87u(skiatest::Reporter* reporter, const char* filename) {
2204 SkPath path, pathB;
2205 path.setFillType(SkPath::kWinding_FillType);
2206 path.moveTo(0,1);
2207 path.cubicTo(0,2, 2,0, 6,4);
2208 path.close();
2209 pathB.setFillType(SkPath::kWinding_FillType);
2210 pathB.moveTo(0,2);
2211 pathB.cubicTo(4,6, 1,0, 2,0);
2212 pathB.close();
2213 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2214}
2215
2216static void cubicOp88u(skiatest::Reporter* reporter, const char* filename) {
2217 SkPath path, pathB;
2218 path.setFillType(SkPath::kWinding_FillType);
2219 path.moveTo(0,1);
2220 path.cubicTo(2,5, 5,0, 6,4);
2221 path.close();
2222 pathB.setFillType(SkPath::kWinding_FillType);
2223 pathB.moveTo(0,5);
2224 pathB.cubicTo(4,6, 1,0, 5,2);
2225 pathB.close();
2226 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2227}
2228
2229static void cubicOp89u(skiatest::Reporter* reporter, const char* filename) {
2230 SkPath path, pathB;
2231 path.setFillType(SkPath::kWinding_FillType);
2232 path.moveTo(0, 3);
2233 path.cubicTo(1, 6, 5, 0, 6, 3);
2234 path.close();
2235 pathB.setFillType(SkPath::kWinding_FillType);
2236 pathB.moveTo(0, 5);
2237 pathB.cubicTo(3, 6, 3, 0, 6, 1);
2238 pathB.close();
2239 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2240}
2241
2242static void cubicOp90u(skiatest::Reporter* reporter, const char* filename) {
2243 SkPath path, pathB;
2244 path.setFillType(SkPath::kEvenOdd_FillType);
2245 path.moveTo(0, 5);
2246 path.cubicTo(1, 2, 5, 2, 4, 1);
2247 path.close();
2248 pathB.setFillType(SkPath::kEvenOdd_FillType);
2249 pathB.moveTo(2, 5);
2250 pathB.cubicTo(1, 4, 5, 0, 2, 1);
2251 pathB.close();
2252 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2253}
2254
2255static void cubicOp91u(skiatest::Reporter* reporter, const char* filename) {
2256 SkPath path, pathB;
2257 path.setFillType(SkPath::kWinding_FillType);
2258 path.moveTo(1, 6);
2259 path.cubicTo(0, 3, 6, 3, 5, 0);
2260 path.close();
2261 pathB.setFillType(SkPath::kWinding_FillType);
2262 pathB.moveTo(3, 6);
2263 pathB.cubicTo(0, 5, 6, 1, 3, 0);
2264 pathB.close();
2265 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2266}
2267
2268static void skpaaalgarve_org53(skiatest::Reporter* reporter, const char* filename) {
2269 SkPath path;
2270 path.setFillType(SkPath::kEvenOdd_FillType);
2271 path.moveTo(-1.24344979e-014f, 348);
2272 path.lineTo(258, 348);
2273 path.lineTo(258, 322);
2274 path.quadTo(258, 317.857849f, 255.072006f, 314.928009f);
2275 path.quadTo(252.142136f, 312, 248, 312);
2276 path.lineTo(1.77635684e-015f, 312);
2277 path.lineTo(-1.24344979e-014f, 348);
2278 path.close();
2279 SkPath pathB;
2280 pathB.setFillType(SkPath::kWinding_FillType);
2281 pathB.moveTo(0, 312);
2282 pathB.lineTo(258, 312);
2283 pathB.lineTo(258, 348);
2284 pathB.lineTo(0, 348);
2285 pathB.close();
2286 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2287}
2288
2289static void skpabcspark_ca103(skiatest::Reporter* reporter, const char* filename) {
2290 SkPath path;
2291 path.setFillType(SkPath::kEvenOdd_FillType);
2292 path.moveTo(1.99840144e-015f, 494);
2293 path.lineTo(97, 494);
2294 path.quadTo(100.313705f, 494, 102.6576f, 491.657593f);
2295 path.quadTo(105, 489.313721f, 105, 486);
2296 path.lineTo(105, 425);
2297 path.quadTo(105, 421.686279f, 102.6576f, 419.342407f);
2298 path.quadTo(100.313705f, 417, 97, 417);
2299 path.lineTo(2.22044605e-016f, 417);
2300 path.lineTo(1.99840144e-015f, 494);
2301 path.close();
2302 SkPath pathB;
2303 pathB.setFillType(SkPath::kWinding_FillType);
2304 pathB.moveTo(0, 417);
2305 pathB.lineTo(105, 417);
2306 pathB.lineTo(105, 494);
2307 pathB.lineTo(0, 494);
2308 pathB.close();
2309 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2310}
2311
2312static void skpacesoftech_com47(skiatest::Reporter* reporter, const char* filename) {
2313 SkPath path;
2314 path.setFillType(SkPath::kEvenOdd_FillType);
2315 path.moveTo(670.537415f, 285);
2316 path.lineTo(670.387451f, 285);
2317 path.lineTo(596.315186f, 314.850708f);
2318 path.lineTo(626.19696f, 389);
2319 path.lineTo(626.346863f, 389);
2320 path.lineTo(700.419189f, 359.149261f);
2321 path.lineTo(670.537415f, 285);
2322 path.close();
2323 SkPath pathB;
2324 pathB.setFillType(SkPath::kWinding_FillType);
2325 pathB.moveTo(663.318542f, 374.100616f);
2326 pathB.quadTo(647.950989f, 380.293671f, 632.705322f, 373.806305f);
2327 pathB.quadTo(617.459595f, 367.318909f, 611.266541f, 351.951355f);
2328 pathB.quadTo(605.073486f, 336.58374f, 611.560913f, 321.338074f);
2329 pathB.quadTo(618.048279f, 306.092407f, 633.415833f, 299.899353f);
2330 pathB.quadTo(648.783447f, 293.706299f, 664.029114f, 300.193665f);
2331 pathB.quadTo(679.27478f, 306.68103f, 685.467834f, 322.048645f);
2332 pathB.quadTo(691.660889f, 337.416199f, 685.173523f, 352.661896f);
2333 pathB.quadTo(678.686157f, 367.907562f, 663.318542f, 374.100616f);
2334 pathB.close();
2335 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2336}
2337
2338static void skpact_com43(skiatest::Reporter* reporter, const char* filename) {
2339 SkPath path;
2340 path.setFillType(SkPath::kEvenOdd_FillType);
2341 path.moveTo(1.45716772e-016f, 924.336121f);
2342 path.lineTo(-1.11022302e-016f, 920);
2343 path.lineTo(6, 920);
2344 path.lineTo(6, 926);
2345 path.lineTo(1.66389287f, 926);
2346 path.quadTo(1.18842196f, 925.674561f, 0.756800175f, 925.243225f);
2347 path.quadTo(0.325406998f, 924.811523f, 1.45716772e-016f, 924.336121f);
2348 path.close();
2349 path.moveTo(1, 921);
2350 path.lineTo(5, 921);
2351 path.lineTo(5, 925);
2352 path.cubicTo(2.79086018f, 925, 1, 923.209167f, 1, 921);
2353 path.close();
2354 SkPath pathB;
2355 pathB.setFillType(SkPath::kWinding_FillType);
2356 pathB.moveTo(-1, 920);
2357 pathB.lineTo(0, 920);
2358 pathB.lineTo(3, 927);
2359 pathB.lineTo(-1, 927);
2360 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2361}
2362
2363static void skpadbox_lt8(skiatest::Reporter* reporter, const char* filename) {
2364 SkPath path;
2365 path.setFillType(SkPath::kEvenOdd_FillType);
2366 path.moveTo(320.097229f, 628.573669f);
2367 path.lineTo(610.227173f, 85.7786865f);
2368 path.lineTo(946.652588f, 265.601807f);
2369 path.lineTo(656.522644f, 808.39679f);
2370 path.lineTo(320.097229f, 628.573669f);
2371 path.close();
2372 SkPath pathB;
2373 pathB.setFillType(SkPath::kInverseWinding_FillType);
2374 pathB.moveTo(333.866608f, 623.496155f);
2375 pathB.lineTo(613.368042f, 100.585754f);
2376 pathB.cubicTo(613.685303f, 99.9921265f, 614.423767f, 99.7681885f, 615.017395f, 100.085449f);
2377 pathB.lineTo(932.633057f, 269.854553f);
2378 pathB.cubicTo(933.226685f, 270.171875f, 933.450623f, 270.910278f, 933.133301f, 271.503906f);
2379 pathB.lineTo(653.631897f, 794.414307f);
2380 pathB.cubicTo(653.314636f, 795.007935f, 652.576172f, 795.231934f, 651.982544f, 794.914612f);
2381 pathB.lineTo(334.366943f, 625.145508f);
2382 pathB.cubicTo(333.773315f, 624.828247f, 333.549286f, 624.089783f, 333.866608f, 623.496155f);
2383 pathB.close();
2384 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2385}
2386
2387static void skpadindex_de4(skiatest::Reporter* reporter, const char* filename) {
2388 SkPath path;
2389 path.setFillType(SkPath::kEvenOdd_FillType);
2390 path.moveTo(0, 926);
2391 path.lineTo(0, 0);
2392 path.lineTo(1280, 0);
2393 path.lineTo(1280, 926);
2394 path.lineTo(0, 926);
2395 path.close();
2396 SkPath pathB;
2397 pathB.setFillType(SkPath::kWinding_FillType);
2398 pathB.moveTo(0, 312);
2399 pathB.lineTo(8.20486257e-015f, 178);
2400 pathB.lineTo(49, 178);
2401 pathB.lineTo(49, 312);
2402 pathB.close();
2403 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2404}
2405
2406static void skpadithya_putr4_blogspot_com551(skiatest::Reporter* reporter, const char* filename) {
2407 SkPath path;
2408 path.setFillType(SkPath::kEvenOdd_FillType);
2409 path.moveTo(205.605804f, 142.334625f);
2410 path.lineTo(254.665359f, 85.6058044f);
2411 path.lineTo(311.394196f, 134.665359f);
2412 path.lineTo(262.334625f, 191.39418f);
2413 path.lineTo(205.605804f, 142.334625f);
2414 path.close();
2415 SkPath pathB;
2416 pathB.setFillType(SkPath::kWinding_FillType);
2417 pathB.moveTo(283.407959f, 110.462646f);
2418 pathB.cubicTo(298.864319f, 123.829437f, 300.558258f, 147.195221f, 287.191467f, 162.651581f);
2419 pathB.lineTo(286.537354f, 163.407959f);
2420 pathB.cubicTo(273.170563f, 178.864334f, 249.804779f, 180.558258f, 234.348419f, 167.191467f);
2421 pathB.lineTo(233.592026f, 166.537338f);
2422 pathB.cubicTo(218.135666f, 153.170547f, 216.441727f, 129.804779f, 229.808517f, 114.348412f);
2423 pathB.lineTo(230.462646f, 113.592026f);
2424 pathB.cubicTo(243.829437f, 98.1356659f, 267.195221f, 96.4417267f, 282.651581f, 109.808517f);
2425 pathB.lineTo(283.407959f, 110.462646f);
2426 pathB.close();
2427 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2428}
2429
2430static void skpadspert_de11(skiatest::Reporter* reporter, const char* filename) {
2431 SkPath path;
2432 path.setFillType(SkPath::kEvenOdd_FillType);
2433 path.moveTo(-4.4408921e-016f, 682.5f);
2434 path.lineTo(30.5f, 682.5f);
2435 path.cubicTo(32.709137f, 682.5f, 34.5f, 680.709167f, 34.5f, 678.5f);
2436 path.lineTo(34.5f, 486.5f);
2437 path.cubicTo(34.5f, 484.290863f, 32.709137f, 482.5f, 30.5f, 482.5f);
2438 path.lineTo(0, 482.5f);
2439 path.lineTo(-4.4408921e-016f, 682.5f);
2440 path.close();
2441 SkPath pathB;
2442 pathB.setFillType(SkPath::kWinding_FillType);
2443 pathB.moveTo(0, 482);
2444 pathB.lineTo(35, 482);
2445 pathB.lineTo(35, 683);
2446 pathB.lineTo(0, 683);
2447 pathB.close();
2448 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2449}
2450
2451static void skpaiaigames_com870(skiatest::Reporter* reporter, const char* filename) {
2452 SkPath path;
2453 path.setFillType(SkPath::kEvenOdd_FillType);
2454 path.moveTo(324.071075f, 845.071045f);
2455 path.cubicTo(324.405151f, 844.737f, 324.715668f, 844.379395f, 325, 844.000977f);
2456 path.lineTo(325, 842.127197f);
2457 path.cubicTo(324.571411f, 842.956238f, 324.017761f, 843.710144f, 323.363953f, 844.363953f);
2458 path.lineTo(324.071075f, 845.071045f);
2459 path.close();
2460 path.moveTo(323.363953f, 714.636047f);
2461 path.lineTo(324.071075f, 713.928955f);
2462 path.cubicTo(324.405151f, 714.263f, 324.715668f, 714.620605f, 325, 714.999023f);
2463 path.lineTo(325, 716.872803f);
2464 path.cubicTo(324.571411f, 716.043762f, 324.017761f, 715.289856f, 323.363953f, 714.636047f);
2465 path.close();
2466 SkPath pathB;
2467 pathB.setFillType(SkPath::kWinding_FillType);
2468 pathB.moveTo(317, 711);
2469 pathB.cubicTo(322.522858f, 711, 327, 715.477173f, 327, 721);
2470 pathB.lineTo(327, 838);
2471 pathB.cubicTo(327, 843.522827f, 322.522858f, 848, 317, 848);
2472 pathB.lineTo(155, 848);
2473 pathB.cubicTo(149.477158f, 848, 145, 843.522827f, 145, 838);
2474 pathB.lineTo(145, 721);
2475 pathB.cubicTo(145, 715.477173f, 149.477158f, 711, 155, 711);
2476 pathB.lineTo(317, 711);
2477 pathB.close();
2478 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2479}
2480
2481static void cubicOp92i(skiatest::Reporter* reporter, const char* filename) {
2482 SkPath path, pathB;
2483 path.setFillType(SkPath::kWinding_FillType);
2484 path.moveTo(0, 1);
2485 path.cubicTo(2, 6, 4, 1, 5, 4);
2486 path.close();
2487 pathB.setFillType(SkPath::kWinding_FillType);
2488 pathB.moveTo(1, 4);
2489 pathB.cubicTo(4, 5, 1, 0, 6, 2);
2490 pathB.close();
2491 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2492}
2493
2494static void cubicOp93d(skiatest::Reporter* reporter, const char* filename) {
2495 SkPath path, pathB;
2496 path.setFillType(SkPath::kWinding_FillType);
2497 path.moveTo(0, 1);
2498 path.cubicTo(1, 6, 4, 1, 4, 3);
2499 path.close();
2500 pathB.setFillType(SkPath::kWinding_FillType);
2501 pathB.moveTo(1, 4);
2502 pathB.cubicTo(3, 4, 1, 0, 6, 1);
2503 pathB.close();
2504 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2505}
2506
2507static void cubicOp94u(skiatest::Reporter* reporter, const char* filename) {
2508 SkPath path, pathB;
2509 path.setFillType(SkPath::kEvenOdd_FillType);
2510 path.moveTo(0, 3);
2511 path.cubicTo(2, 3, 5, 0, 5, 3);
2512 path.close();
2513 pathB.setFillType(SkPath::kEvenOdd_FillType);
2514 pathB.moveTo(0, 5);
2515 pathB.cubicTo(3, 5, 3, 0, 3, 2);
2516 pathB.close();
2517 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2518}
2519
2520static void skpadbox_lt15(skiatest::Reporter* reporter, const char* filename) {
2521 SkPath path;
2522 path.setFillType(SkPath::kEvenOdd_FillType);
2523 path.moveTo(333.292084f, 624.570984f);
2524 path.lineTo(614.229797f, 98.9735107f);
2525 path.lineTo(933.457764f, 269.604431f);
2526 path.lineTo(652.52002f, 795.201904f);
2527 path.lineTo(333.292084f, 624.570984f);
2528 path.close();
2529 SkPath pathB;
2530 pathB.setFillType(SkPath::kWinding_FillType);
2531 pathB.moveTo(613.368042f, 100.585754f);
2532 pathB.cubicTo(613.685303f, 99.9921265f, 614.423767f, 99.7681885f, 615.017395f, 100.085449f);
2533 pathB.lineTo(932.633057f, 269.854553f);
2534 pathB.cubicTo(933.226685f, 270.171875f, 933.450623f, 270.910278f, 933.133301f, 271.503906f);
2535 pathB.lineTo(653.631897f, 794.414307f);
2536 pathB.cubicTo(653.314636f, 795.007935f, 652.576172f, 795.231934f, 651.982544f, 794.914612f);
2537 pathB.lineTo(334.366943f, 625.145508f);
2538 pathB.cubicTo(333.773315f, 624.828247f, 333.549286f, 624.089783f, 333.866608f, 623.496155f);
2539 pathB.lineTo(613.368042f, 100.585754f);
2540 pathB.close();
2541 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2542}
2543
2544static void skpadoption_org196(skiatest::Reporter* reporter, const char* filename) {
2545 SkPath path;
2546 path.setFillType(SkPath::kEvenOdd_FillType);
2547 path.moveTo(802, 367);
2548 path.lineTo(802, 324);
2549 path.lineTo(956, 324);
2550 path.lineTo(956, 371);
2551 path.quadTo(956, 373.071075f, 954.536011f, 374.536011f);
2552 path.quadTo(953.071045f, 376, 951, 376);
2553 path.lineTo(811, 376);
2554 path.cubicTo(806.029419f, 376, 802, 371.970551f, 802, 367);
2555 path.close();
2556 SkPath pathB;
2557 pathB.setFillType(SkPath::kInverseWinding_FillType);
2558 pathB.moveTo(803, 326);
2559 pathB.lineTo(955, 326);
2560 pathB.lineTo(955, 370);
2561 pathB.cubicTo(955, 372.761414f, 952.761414f, 375, 950, 375);
2562 pathB.lineTo(808, 375);
2563 pathB.cubicTo(805.238586f, 375, 803, 372.761414f, 803, 370);
2564 pathB.lineTo(803, 326);
2565 pathB.close();
2566 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2567}
2568
2569static void skpadspert_net23(skiatest::Reporter* reporter, const char* filename) {
2570 SkPath path;
2571 path.setFillType(SkPath::kEvenOdd_FillType);
2572 path.moveTo(-2.220446e-018f, 483.5f);
2573 path.lineTo(0, 482.5f);
2574 path.lineTo(30.5f, 482.5f);
2575 path.cubicTo(32.709137f, 482.5f, 34.5f, 484.290863f, 34.5f, 486.5f);
2576 path.lineTo(34.5f, 678.5f);
2577 path.cubicTo(34.5f, 680.709167f, 32.709137f, 682.5f, 30.5f, 682.5f);
2578 path.lineTo(-4.4408921e-016f, 682.5f);
2579 path.lineTo(-4.41868766e-016f, 681.5f);
2580 path.lineTo(30.5f, 681.5f);
2581 path.cubicTo(32.1568565f, 681.5f, 33.5f, 680.15686f, 33.5f, 678.5f);
2582 path.lineTo(33.5f, 486.5f);
2583 path.cubicTo(33.5f, 484.84314f, 32.1568565f, 483.5f, 30.5f, 483.5f);
2584 path.lineTo(-2.220446e-018f, 483.5f);
2585 path.close();
2586 SkPath pathB;
2587 pathB.setFillType(SkPath::kWinding_FillType);
2588 pathB.moveTo(0, 482);
2589 pathB.lineTo(35, 482);
2590 pathB.lineTo(35, 683);
2591 pathB.lineTo(0, 683);
2592 pathB.close();
2593 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2594}
2595
2596static void skpadventistmission_org572(skiatest::Reporter* reporter, const char* filename) {
2597 SkPath path;
2598 path.setFillType(SkPath::kEvenOdd_FillType);
2599 path.moveTo(1182.00037f, 926);
2600 path.cubicTo(1181.08813f, 924.785583f, 1179.63586f, 924, 1178, 924);
2601 path.lineTo(938, 924);
2602 path.cubicTo(936.364197f, 924, 934.911865f, 924.785583f, 933.999634f, 926);
2603 path.lineTo(1182.00037f, 926);
2604 path.close();
2605 SkPath pathB;
2606 pathB.setFillType(SkPath::kWinding_FillType);
2607 pathB.moveTo(934, 924);
2608 pathB.lineTo(1182, 924);
2609 pathB.lineTo(1182, 926);
2610 pathB.lineTo(934, 926);
2611 pathB.close();
2612 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2613}
2614
2615static void skpagentxsites_com55(skiatest::Reporter* reporter, const char* filename) {
2616 SkPath path;
2617 path.setFillType(SkPath::kEvenOdd_FillType);
2618 path.moveTo(925, 27);
2619 path.cubicTo(924.447693f, 27, 924, 27.4477158f, 924, 28);
2620 path.lineTo(924, 55);
2621 path.cubicTo(924, 55.5522842f, 924.447693f, 56, 925, 56);
2622 path.lineTo(1103, 56);
2623 path.cubicTo(1103.55225f, 56, 1104, 55.5522842f, 1104, 55);
2624 path.lineTo(1104, 28);
2625 path.cubicTo(1104, 27.4477158f, 1103.55225f, 27, 1103, 27);
2626 path.lineTo(925, 27);
2627 path.close();
2628 SkPath pathB;
2629 pathB.setFillType(SkPath::kWinding_FillType);
2630 pathB.moveTo(1103, 27);
2631 pathB.cubicTo(1104.10461f, 27, 1105, 27.8954315f, 1105, 29);
2632 pathB.lineTo(1105, 54);
2633 pathB.cubicTo(1105, 55.1045685f, 1104.10461f, 56, 1103, 56);
2634 pathB.lineTo(926, 56);
2635 pathB.cubicTo(924.895447f, 56, 924, 55.1045685f, 924, 54);
2636 pathB.lineTo(924, 29);
2637 pathB.cubicTo(924, 27.8954315f, 924.895447f, 27, 926, 27);
2638 pathB.lineTo(1103, 27);
2639 pathB.close();
2640 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2641}
2642
2643static void skpbakosoft_com10(skiatest::Reporter* reporter, const char* filename) {
2644 SkPath path;
2645 path.setFillType(SkPath::kEvenOdd_FillType);
2646 path.moveTo(190, 170);
2647 path.cubicTo(178.9543f, 170, 170, 178.9543f, 170, 190);
2648 path.cubicTo(170, 201.0457f, 178.9543f, 210, 190, 210);
2649 path.lineTo(370, 210);
2650 path.cubicTo(381.045685f, 210, 390, 201.0457f, 390, 190);
2651 path.cubicTo(390, 178.9543f, 381.045685f, 170, 370, 170);
2652 path.lineTo(190, 170);
2653 path.close();
2654 SkPath pathB;
2655 pathB.setFillType(SkPath::kWinding_FillType);
2656 pathB.moveTo(210, 190);
2657 pathB.quadTo(210, 198.284271f, 204.142136f, 204.142136f);
2658 pathB.quadTo(198.284271f, 210, 190, 210);
2659 pathB.quadTo(181.715729f, 210, 175.857864f, 204.142136f);
2660 pathB.quadTo(170, 198.284271f, 170, 190);
2661 pathB.quadTo(170, 181.715729f, 175.857864f, 175.857864f);
2662 pathB.quadTo(181.715729f, 170, 190, 170);
2663 pathB.quadTo(198.284271f, 170, 204.142136f, 175.857864f);
2664 pathB.quadTo(210, 181.715729f, 210, 190);
2665 pathB.close();
2666 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2667}
2668
2669static void skpbambootheme_com12(skiatest::Reporter* reporter, const char* filename) {
2670 SkPath path;
2671 path.setFillType(SkPath::kEvenOdd_FillType);
2672 path.moveTo(47.8780937f, 58);
2673 path.lineTo(0, 58);
2674 path.lineTo(-8.65973959e-015f, 96.9914017f);
2675 path.quadTo(20.0654926f, 96.6451874f, 34.3553391f, 82.3553391f);
2676 path.quadTo(44.9466133f, 71.764061f, 47.8780937f, 58);
2677 path.close();
2678 SkPath pathB;
2679 pathB.setFillType(SkPath::kEvenOdd_FillType);
2680 pathB.moveTo(-1, -3);
2681 pathB.lineTo(-1, -3);
2682 pathB.cubicTo(26.6142502f, -3, 49, 19.3857498f, 49, 47);
2683 pathB.lineTo(49, 47);
2684 pathB.cubicTo(49, 74.6142502f, 26.6142502f, 97, -1, 97);
2685 pathB.lineTo(-1, 97);
2686 pathB.cubicTo(-28.6142502f, 97, -51, 74.6142502f, -51, 47);
2687 pathB.lineTo(-51, 47);
2688 pathB.cubicTo(-51, 19.3857498f, -28.6142502f, -3, -1, -3);
2689 pathB.close();
2690 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2691}
2692
2693static void skpakmmos_ru100(skiatest::Reporter* reporter, const char* filename) {
2694 SkPath path;
2695 path.setFillType(SkPath::kEvenOdd_FillType);
2696 path.moveTo(693.000488f, 926);
2697 path.cubicTo(692.164734f, 925.37207f, 691.125793f, 925, 690, 925);
2698 path.lineTo(578, 925);
2699 path.cubicTo(576.874207f, 925, 575.835266f, 925.37207f, 574.999512f, 926);
2700 path.lineTo(693.000488f, 926);
2701 path.close();
2702 SkPath pathB;
2703 pathB.setFillType(SkPath::kWinding_FillType);
2704 pathB.moveTo(575, 925);
2705 pathB.lineTo(693, 925);
2706 pathB.lineTo(693, 926);
2707 pathB.lineTo(575, 926);
2708 pathB.close();
2709 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2710}
2711
2712static void skpcarpetplanet_ru22(skiatest::Reporter* reporter, const char* filename) {
2713 SkPath path;
2714 path.setFillType(SkPath::kEvenOdd_FillType);
2715 path.moveTo(195, 785);
2716 path.cubicTo(124.307556f, 785, 67, 841.859863f, 67, 912);
2717 path.lineTo(67, 913);
2718 path.cubicTo(67, 917.388916f, 67.2243805f, 921.725769f, 67.662384f, 926);
2719 path.lineTo(322, 926);
2720 path.lineTo(322, 896.048035f);
2721 path.cubicTo(314.09201f, 833.437622f, 260.247131f, 785, 195, 785);
2722 path.close();
2723 SkPath pathB;
2724 pathB.setFillType(SkPath::kWinding_FillType);
2725 pathB.moveTo(195, 785);
2726 pathB.cubicTo(265.140167f, 785, 322, 842.307556f, 322, 913);
2727 pathB.cubicTo(322, 983.692444f, 265.140167f, 1041, 195, 1041);
2728 pathB.lineTo(194, 1041);
2729 pathB.cubicTo(123.85984f, 1041, 67, 983.692444f, 67, 913);
2730 pathB.cubicTo(67, 842.307556f, 123.85984f, 785, 194, 785);
2731 pathB.lineTo(195, 785);
2732 pathB.close();
2733 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2734}
2735
2736static void skpcarrot_is24(skiatest::Reporter* reporter, const char* filename) {
2737 SkPath path;
2738 path.setFillType(SkPath::kEvenOdd_FillType);
2739 path.moveTo(945, 597);
2740 path.quadTo(913.93396f, 597, 891.96698f, 618.96698f);
2741 path.quadTo(870, 640.93396f, 870, 672);
2742 path.quadTo(870, 703.06604f, 891.96698f, 725.03302f);
2743 path.quadTo(913.93396f, 747, 945, 747);
2744 path.quadTo(976.06604f, 747, 998.03302f, 725.03302f);
2745 path.quadTo(1020, 703.06604f, 1020, 672);
2746 path.quadTo(1020, 640.93396f, 998.03302f, 618.96698f);
2747 path.quadTo(976.06604f, 597, 945, 597);
2748 path.close();
2749 SkPath pathB;
2750 pathB.setFillType(SkPath::kWinding_FillType);
2751 pathB.moveTo(945.080994f, 597.161987f);
2752 pathB.cubicTo(903.659973f, 597.161987f, 870.080994f, 630.73999f, 870.080994f, 672.161987f);
2753 pathB.cubicTo(870.080994f, 676.096008f, 870.387024f, 679.957031f, 870.971008f, 683.726013f);
2754 pathB.cubicTo(876.53302f, 719.656006f, 907.593994f, 747.161987f, 945.080994f, 747.161987f);
2755 pathB.cubicTo(982.567993f, 747.161987f, 1013.62903f, 719.656006f, 1019.19104f, 683.726013f);
2756 pathB.cubicTo(1019.77502f, 679.955017f, 1020.08099f, 676.094971f, 1020.08099f, 672.161987f);
2757 pathB.cubicTo(1020.08002f, 630.73999f, 986.502014f, 597.161987f, 945.080994f, 597.161987f);
2758 pathB.close();
2759 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2760}
2761
2762static void skpbangalorenest_com4(skiatest::Reporter* reporter, const char* filename) {
2763 SkPath path;
2764 path.setFillType(SkPath::kEvenOdd_FillType);
2765 path.moveTo(0, 926);
2766 path.lineTo(0, 0);
2767 path.lineTo(1265, 0);
2768 path.lineTo(1265, 926);
2769 path.lineTo(0, 926);
2770 path.close();
2771 SkPath pathB;
2772 pathB.setFillType(SkPath::kWinding_FillType);
2773 pathB.moveTo(0, 290);
2774 pathB.lineTo(-2.64514972e-014f, 146);
2775 pathB.lineTo(30, 146);
2776 pathB.lineTo(30, 290);
2777 pathB.close();
2778 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2779}
2780
2781static void skpbenzoteh_ru152(skiatest::Reporter* reporter, const char* filename) {
2782 SkPath path;
2783 path.setFillType(SkPath::kEvenOdd_FillType);
2784 path.moveTo(883, 23);
2785 path.lineTo(883, 0);
2786 path.lineTo(1122.5f, 0);
2787 path.lineTo(1122.5f, 25.2136822f);
2788 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2789 path.quadTo(1120.07104f, 28, 1118, 28);
2790 path.lineTo(888, 28);
2791 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2792 path.quadTo(883, 25.0710678f, 883, 23);
2793 path.close();
2794 SkPath pathB;
2795 pathB.setFillType(SkPath::kWinding_FillType);
2796 pathB.moveTo(883, 0);
2797 pathB.lineTo(1123, 0);
2798 pathB.lineTo(1123, 23);
2799 pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2800 pathB.quadTo(1120.07104f, 28, 1118, 28);
2801 pathB.lineTo(888, 28);
2802 pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2803 pathB.quadTo(883, 25.0710678f, 883, 23);
2804 pathB.close();
2805 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2806}
2807
2808static void skpbestred_ru37(skiatest::Reporter* reporter, const char* filename) {
2809 SkPath path;
2810 path.setFillType(SkPath::kEvenOdd_FillType);
2811 path.moveTo(883, 23);
2812 path.lineTo(883, 0);
2813 path.lineTo(1122.5f, 0);
2814 path.lineTo(1122.5f, 25.2136822f);
2815 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2816 path.quadTo(1120.07104f, 28, 1118, 28);
2817 path.lineTo(888, 28);
2818 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2819 path.quadTo(883, 25.0710678f, 883, 23);
2820 path.close();
2821 SkPath pathB;
2822 pathB.setFillType(SkPath::kWinding_FillType);
2823 pathB.moveTo(883, 0);
2824 pathB.lineTo(1123, 0);
2825 pathB.lineTo(1123, 23);
2826 pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2827 pathB.quadTo(1120.07104f, 28, 1118, 28);
2828 pathB.lineTo(888, 28);
2829 pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2830 pathB.quadTo(883, 25.0710678f, 883, 23);
2831 pathB.close();
2832 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2833}
2834
2835static void skpbingoentertainment_net189(skiatest::Reporter* reporter, const char* filename) {
2836 SkPath path;
2837 path.setFillType(SkPath::kEvenOdd_FillType);
2838 path.moveTo(896, 745.38678f);
2839 path.lineTo(896, 873.38678f);
2840 path.lineTo(922.567993f, 876.683716f);
2841 path.lineTo(922.567993f, 748.683716f);
2842 path.lineTo(896, 745.38678f);
2843 path.close();
2844 SkPath pathB;
2845 pathB.setFillType(SkPath::kWinding_FillType);
2846 pathB.moveTo(899.200928f, 745.783997f);
2847 pathB.cubicTo(897.119385f, 745.525696f, 895.432007f, 752.031982f, 895.432007f, 760.316284f);
2848 pathB.lineTo(895.432007f, 858.316284f);
2849 pathB.cubicTo(895.432007f, 866.600586f, 897.119385f, 873.525696f, 899.200928f, 873.783997f);
2850 pathB.lineTo(918.799133f, 876.216003f);
2851 pathB.cubicTo(920.880615f, 876.474304f, 922.567993f, 869.968018f, 922.567993f, 861.683716f);
2852 pathB.lineTo(922.567993f, 763.683716f);
2853 pathB.cubicTo(922.567993f, 755.399414f, 920.880615f, 748.474304f, 918.799133f, 748.216003f);
2854 pathB.lineTo(899.200928f, 745.783997f);
2855 pathB.close();
2856 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2857}
2858
2859static void skpcarrefour_ro62(skiatest::Reporter* reporter, const char* filename) {
2860 SkPath path;
2861 path.setFillType(SkPath::kEvenOdd_FillType);
2862 path.moveTo(1104, 453);
2863 path.lineTo(399, 453);
2864 path.lineTo(399, 657);
2865 path.cubicTo(399, 661.970581f, 403.029449f, 666, 408, 666);
2866 path.lineTo(1095, 666);
2867 path.cubicTo(1099.97058f, 666, 1104, 661.970581f, 1104, 657);
2868 path.lineTo(1104, 453);
2869 path.close();
2870 SkPath pathB;
2871 pathB.setFillType(SkPath::kInverseWinding_FillType);
2872 pathB.moveTo(400, 453);
2873 pathB.lineTo(1103, 453);
2874 pathB.lineTo(1103, 666);
2875 pathB.lineTo(406, 666);
2876 pathB.cubicTo(402.686279f, 666, 400, 663.313721f, 400, 660);
2877 pathB.lineTo(400, 453);
2878 pathB.close();
2879 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2880}
2881
2882static void skpcaffelavazzait_com_ua21(skiatest::Reporter* reporter, const char* filename) {
2883 SkPath path;
2884 path.setFillType(SkPath::kEvenOdd_FillType);
2885 path.moveTo(883, 23);
2886 path.lineTo(883, 0);
2887 path.lineTo(1122.5f, 0);
2888 path.lineTo(1122.5f, 25.2136822f);
2889 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2890 path.quadTo(1120.07104f, 28, 1118, 28);
2891 path.lineTo(888, 28);
2892 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2893 path.quadTo(883, 25.0710678f, 883, 23);
2894 path.close();
2895 SkPath pathB;
2896 pathB.setFillType(SkPath::kWinding_FillType);
2897 pathB.moveTo(883, 0);
2898 pathB.lineTo(1123, 0);
2899 pathB.lineTo(1123, 23);
2900 pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2901 pathB.quadTo(1120.07104f, 28, 1118, 28);
2902 pathB.lineTo(888, 28);
2903 pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2904 pathB.quadTo(883, 25.0710678f, 883, 23);
2905 pathB.close();
2906 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2907}
2908
2909static void skpcamcorder_kz21(skiatest::Reporter* reporter, const char* filename) {
2910 SkPath path;
2911 path.setFillType(SkPath::kEvenOdd_FillType);
2912 path.moveTo(883, 23);
2913 path.lineTo(883, 0);
2914 path.lineTo(1122.5f, 0);
2915 path.lineTo(1122.5f, 25.2136822f);
2916 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2917 path.quadTo(1120.07104f, 28, 1118, 28);
2918 path.lineTo(888, 28);
2919 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2920 path.quadTo(883, 25.0710678f, 883, 23);
2921 path.close();
2922 SkPath pathB;
2923 pathB.setFillType(SkPath::kWinding_FillType);
2924 pathB.moveTo(883, 0);
2925 pathB.lineTo(1123, 0);
2926 pathB.lineTo(1123, 23);
2927 pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2928 pathB.quadTo(1120.07104f, 28, 1118, 28);
2929 pathB.lineTo(888, 28);
2930 pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2931 pathB.quadTo(883, 25.0710678f, 883, 23);
2932 pathB.close();
2933 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2934}
2935
2936static void skpcavablar_net563(skiatest::Reporter* reporter, const char* filename) {
2937 SkPath path;
2938 path.setFillType(SkPath::kEvenOdd_FillType);
2939 path.moveTo(160.000488f, 918);
2940 path.cubicTo(159.164749f, 917.37207f, 158.125824f, 917, 157, 917);
2941 path.lineTo(94, 917);
2942 path.cubicTo(92.874176f, 917, 91.8352661f, 917.37207f, 90.9995193f, 918);
2943 path.lineTo(160.000488f, 918);
2944 path.close();
2945 SkPath pathB;
2946 pathB.setFillType(SkPath::kWinding_FillType);
2947 pathB.moveTo(91, 917);
2948 pathB.lineTo(160, 917);
2949 pathB.lineTo(160, 918);
2950 pathB.lineTo(91, 918);
2951 pathB.close();
2952 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2953}
2954
2955static void skpinsomnia_gr72(skiatest::Reporter* reporter, const char* filename) {
2956 SkPath path;
2957 path.setFillType(SkPath::kEvenOdd_FillType);
2958 path.moveTo(1138, 231);
2959 path.lineTo(1137, 243.625748f);
2960 path.lineTo(1137, 926);
2961 path.lineTo(1139, 926);
2962 path.lineTo(1139, 231);
2963 path.lineTo(1138, 231);
2964 path.close();
2965 SkPath pathB;
2966 pathB.setFillType(SkPath::kWinding_FillType);
2967 pathB.moveTo(1139, 231);
2968 pathB.lineTo(1138, 231);
2969 pathB.lineTo(633, 6101);
2970 pathB.lineTo(1139, 6607);
2971 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2972}
2973
2974static void cubicOp95u(skiatest::Reporter* reporter, const char* filename) {
2975 SkPath path, pathB;
2976 path.setFillType(SkPath::kEvenOdd_FillType);
2977 path.moveTo(0, 2);
2978 path.cubicTo(2, 3, 5, 1, 3, 2);
2979 path.close();
2980 pathB.setFillType(SkPath::kEvenOdd_FillType);
2981 pathB.moveTo(1, 5);
2982 pathB.cubicTo(2, 3, 2, 0, 3, 2);
2983 pathB.close();
2984 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2985}
2986
2987static void cubicOp96d(skiatest::Reporter* reporter, const char* filename) {
2988 SkPath path, pathB;
2989 path.setFillType(SkPath::kEvenOdd_FillType);
2990 path.moveTo(1, 6);
2991 path.cubicTo(0, 3, 6, 3, 5, 0);
2992 path.close();
2993 pathB.setFillType(SkPath::kEvenOdd_FillType);
2994 pathB.moveTo(3, 6);
2995 pathB.cubicTo(0, 5, 6, 1, 3, 0);
2996 pathB.close();
2997 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2998}
2999
3000static void cubicOp97x(skiatest::Reporter* reporter, const char* filename) {
3001 SkPath path, pathB;
3002 path.setFillType(SkPath::kEvenOdd_FillType);
3003 path.moveTo(0, 2);
3004 path.cubicTo(0, 6, 2, 1, 2, 1);
3005 path.close();
3006 pathB.setFillType(SkPath::kEvenOdd_FillType);
3007 pathB.moveTo(1, 2);
3008 pathB.cubicTo(1, 2, 2, 0, 6, 0);
3009 pathB.close();
3010 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
3011}
3012
3013static void cubicOp98x(skiatest::Reporter* reporter, const char* filename) {
3014 SkPath path, pathB;
3015 path.setFillType(SkPath::kEvenOdd_FillType);
3016 path.moveTo(0, 3);
3017 path.cubicTo(3, 6, 4, 1, 6, 3);
3018 path.close();
3019 pathB.setFillType(SkPath::kEvenOdd_FillType);
3020 pathB.moveTo(1, 4);
3021 pathB.cubicTo(3, 6, 3, 0, 6, 3);
3022 pathB.close();
3023 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
3024}
3025
3026static void cubicOp99(skiatest::Reporter* reporter, const char* filename) {
3027 SkPath path, pathB;
3028 path.setFillType(SkPath::kWinding_FillType);
3029 path.moveTo(3,6);
3030 path.cubicTo(0,3, 6,5, 5,4);
3031 path.close();
3032 pathB.setFillType(SkPath::kWinding_FillType);
3033 pathB.moveTo(5,6);
3034 pathB.cubicTo(4,5, 6,3, 3,0);
3035 pathB.close();
3036 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3037}
3038
3039static void cubicOp100(skiatest::Reporter* reporter, const char* filename) {
3040 SkPath path, pathB;
3041 path.setFillType(SkPath::kWinding_FillType);
3042 path.moveTo(0,1);
3043 path.cubicTo(0,2, 2,1, 4,2);
3044 path.close();
3045 pathB.setFillType(SkPath::kWinding_FillType);
3046 pathB.moveTo(1,2);
3047 pathB.cubicTo(2,4, 1,0, 2,0);
3048 pathB.close();
3049 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3050}
3051
3052static void cubicOp101(skiatest::Reporter* reporter, const char* filename) {
3053 SkPath path, pathB;
3054 path.setFillType(SkPath::kWinding_FillType);
3055 path.moveTo(0, 1);
3056 path.cubicTo(2, 3, 2, 1, 5, 3);
3057 path.close();
3058 pathB.setFillType(SkPath::kWinding_FillType);
3059 pathB.moveTo(1, 2);
3060 pathB.cubicTo(3, 5, 1, 0, 3, 2);
3061 pathB.close();
3062 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3063}
3064
3065static void cubicOp102(skiatest::Reporter* reporter, const char* filename) {
3066 SkPath path, pathB;
3067 path.setFillType(SkPath::kWinding_FillType);
3068 path.moveTo(0,1);
3069 path.cubicTo(1,2, 1,0, 3,0);
3070 path.close();
3071 pathB.setFillType(SkPath::kWinding_FillType);
3072 pathB.moveTo(0,1);
3073 pathB.cubicTo(0,3, 1,0, 2,1);
3074 pathB.close();
3075 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3076}
3077
3078static void cubicOp103(skiatest::Reporter* reporter, const char* filename) {
3079 SkPath path, pathB;
3080 path.setFillType(SkPath::kWinding_FillType);
3081 path.moveTo(0,1);
3082 path.cubicTo(1,5, 2,0, 2,1);
3083 path.close();
3084 pathB.setFillType(SkPath::kWinding_FillType);
3085 pathB.moveTo(0,2);
3086 pathB.cubicTo(1,2, 1,0, 5,1);
3087 pathB.close();
3088 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3089}
3090
3091static void cubicOp104(skiatest::Reporter* reporter, const char* filename) {
3092 SkPath path, pathB;
3093 path.setFillType(SkPath::kWinding_FillType);
3094 path.moveTo(0,1);
3095 path.cubicTo(0,6, 4,0, 6,1);
3096 path.close();
3097 pathB.setFillType(SkPath::kWinding_FillType);
3098 pathB.moveTo(0,4);
3099 pathB.cubicTo(1,6, 1,0, 6,0);
3100 pathB.close();
3101 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3102}
3103
3104static void cubicOp105(skiatest::Reporter* reporter, const char* filename) {
3105 SkPath path, pathB;
3106 path.setFillType(SkPath::kWinding_FillType);
3107 path.moveTo(0,1);
3108 path.cubicTo(0,4, 6,5, 2,0);
3109 path.close();
3110 pathB.setFillType(SkPath::kWinding_FillType);
3111 pathB.moveTo(5,6);
3112 pathB.cubicTo(0,2, 1,0, 4,0);
3113 pathB.close();
3114 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3115}
3116
3117static void cubicOp106(skiatest::Reporter* reporter, const char* filename) {
3118 SkPath path, pathB;
3119 path.setFillType(SkPath::kWinding_FillType);
3120 path.moveTo(0, 1);
3121 path.cubicTo(4, 6, 2, 1, 2, 0);
3122 path.close();
3123 pathB.setFillType(SkPath::kWinding_FillType);
3124 pathB.moveTo(1, 2);
3125 pathB.cubicTo(0, 2, 1, 0, 6, 4);
3126 pathB.close();
3127 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3128}
3129
3130static void cubicOp107(skiatest::Reporter* reporter, const char* filename) {
3131 SkPath path, pathB;
3132 path.setFillType(SkPath::kWinding_FillType);
3133 path.moveTo(0, 1);
3134 path.cubicTo(4, 6, 2, 1, 2, 0);
3135 path.close();
3136 pathB.setFillType(SkPath::kWinding_FillType);
3137 pathB.moveTo(1, 2);
3138 pathB.cubicTo(0, 2, 1, 0, 6, 4);
3139 pathB.close();
3140 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3141}
3142
3143static void cubicOp108(skiatest::Reporter* reporter, const char* filename) {
3144 SkPath path, pathB;
3145 path.setFillType(SkPath::kWinding_FillType);
3146 path.moveTo(0, 1);
3147 path.cubicTo(4, 6, 2, 1, 2, 0);
3148 path.close();
3149 pathB.setFillType(SkPath::kWinding_FillType);
3150 pathB.moveTo(1, 2);
3151 pathB.cubicTo(0, 2, 1, 0, 6, 4);
3152 pathB.close();
3153 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3154}
3155
3156static void cubicOp109(skiatest::Reporter* reporter, const char* filename) {
3157 SkPath path, pathB;
3158 path.setFillType(SkPath::kWinding_FillType);
3159 path.moveTo(0,1);
3160 path.cubicTo(4,5, 6,3, 5,4);
3161 path.close();
3162 pathB.setFillType(SkPath::kWinding_FillType);
3163 pathB.moveTo(3,6);
3164 pathB.cubicTo(4,5, 1,0, 5,4);
3165 pathB.close();
3166 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3167}
3168
3169static void cubicOp110(skiatest::Reporter* reporter, const char* filename) {
3170 SkPath path, pathB;
3171 path.setFillType(SkPath::kEvenOdd_FillType);
3172 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3173 path.addRect(0, 0, 4, 4, SkPath::kCW_Direction);
3174 pathB.setFillType(SkPath::kEvenOdd_FillType);
3175 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3176 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3177 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3178}
3179
3180static void cubicOp111(skiatest::Reporter* reporter, const char* filename) {
3181 SkPath path, pathB;
3182 path.setFillType(SkPath::kWinding_FillType);
3183 path.moveTo(1,4);
3184 path.cubicTo(0,5, 4,1, 3,1);
3185 path.close();
3186 pathB.setFillType(SkPath::kWinding_FillType);
3187 pathB.moveTo(1,4);
3188 pathB.cubicTo(1,3, 4,1, 5,0);
3189 pathB.close();
3190 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3191}
3192
3193static void xOp1u(skiatest::Reporter* reporter, const char* filename) {
3194 SkPath path, pathB;
3195 path.setFillType(SkPath::kEvenOdd_FillType);
3196 path.moveTo(1, 4);
3197 path.cubicTo(4, 5, 3, 2, 6, 3);
3198 path.close();
3199 pathB.setFillType(SkPath::kEvenOdd_FillType);
3200 pathB.moveTo(2, 3);
3201 pathB.cubicTo(3, 6, 4, 1, 5, 4);
3202 pathB.close();
3203 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3204}
3205
3206static void xOp1i(skiatest::Reporter* reporter, const char* filename) {
3207 SkPath path, pathB;
3208 path.setFillType(SkPath::kEvenOdd_FillType);
3209 path.moveTo(1, 4);
3210 path.cubicTo(1, 5, 6, 0, 5, 1);
3211 path.close();
3212 pathB.setFillType(SkPath::kEvenOdd_FillType);
3213 pathB.moveTo(0, 6);
3214 pathB.cubicTo(1, 5, 4, 1, 5, 1);
3215 pathB.close();
3216 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3217}
3218
3219static void xOp2i(skiatest::Reporter* reporter, const char* filename) {
3220 SkPath path, pathB;
3221 path.setFillType(SkPath::kEvenOdd_FillType);
3222 path.moveTo(1, 5);
3223 path.cubicTo(0, 4, 3, 2, 6, 1);
3224 path.close();
3225 pathB.setFillType(SkPath::kEvenOdd_FillType);
3226 pathB.moveTo(2, 3);
3227 pathB.cubicTo(1, 6, 5, 1, 4, 0);
3228 pathB.close();
3229 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3230}
3231
3232static void xOp3i(skiatest::Reporter* reporter, const char* filename) {
3233 SkPath path, pathB;
3234 path.setFillType(SkPath::kWinding_FillType);
3235 path.moveTo(1,4);
3236 path.cubicTo(0,5, 4,1, 3,1);
3237 path.close();
3238 pathB.setFillType(SkPath::kWinding_FillType);
3239 pathB.moveTo(1,4);
3240 pathB.cubicTo(1,3, 4,1, 5,0);
3241 pathB.close();
3242 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3243}
3244
3245static void findFirst1(skiatest::Reporter* reporter, const char* filename) {
3246 SkPath path, pathB;
3247 path.setFillType(SkPath::kWinding_FillType);
3248 path.moveTo(0,1);
3249 path.cubicTo(1,6, 5,0, 2,1);
3250 path.close();
3251 pathB.setFillType(SkPath::kWinding_FillType);
3252 pathB.moveTo(0,5);
3253 pathB.cubicTo(1,2, 1,0, 6,1);
3254 pathB.close();
3255 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3256}
3257
3258static void cubicOp112(skiatest::Reporter* reporter, const char* filename) {
3259 SkPath path, pathB;
3260 path.setFillType(SkPath::kWinding_FillType);
3261 path.moveTo(2,4);
3262 path.cubicTo(2,3, 6,4, 1,0);
3263 path.close();
3264 pathB.setFillType(SkPath::kWinding_FillType);
3265 pathB.moveTo(4,6);
3266 pathB.cubicTo(0,1, 4,2, 3,2);
3267 pathB.close();
3268 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3269}
3270
3271static void cubicOp113(skiatest::Reporter* reporter, const char* filename) {
3272 SkPath path, pathB;
3273 path.moveTo(2,4);
3274 path.cubicTo(3,5, 2.33333325f,4.33333349f, 3.83333325f,3.83333349f);
3275 path.close();
3276 pathB.moveTo(3,5);
3277 pathB.cubicTo(2.33333325f,4.33333349f, 3.83333325f,3.83333349f, 2,4);
3278 pathB.close();
3279 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3280}
3281
3282static void cubicOp114(skiatest::Reporter* reporter, const char* filename) {
3283 SkPath path, pathB;
3284 path.setFillType(SkPath::kWinding_FillType);
3285 path.moveTo(0, 1);
3286 path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
3287 path.close();
3288 pathB.setFillType(SkPath::kWinding_FillType);
3289 pathB.moveTo(1, 3);
3290 pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1);
3291 pathB.close();
3292 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3293}
3294
3295static void cubicOp114asQuad(skiatest::Reporter* reporter, const char* filename) {
3296 SkPath path, pathB;
3297 path.setFillType(SkPath::kWinding_FillType);
3298 path.moveTo(0, 1);
3299 path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
3300 path.close();
3301 pathB.setFillType(SkPath::kWinding_FillType);
3302 pathB.moveTo(1, 3);
3303 pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1);
3304 pathB.close();
3305 SkPath qPath, qPathB;
3306 CubicPathToQuads(path, &qPath);
3307 CubicPathToQuads(pathB, &qPathB);
3308 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename);
3309}
3310
3311static void quadOp10i(skiatest::Reporter* reporter, const char* filename) {
3312 SkPath path, pathB;
3313 path.moveTo(0, 0);
3314 path.quadTo(1, 8, 3, 5);
3315 path.lineTo(8, 1);
3316 path.close();
3317 pathB.moveTo(0, 0);
3318 pathB.quadTo(8, 1, 4, 8);
3319 pathB.close();
3320 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3321}
3322
3323static void kari1(skiatest::Reporter* reporter, const char* filename) {
3324 SkPath path1;
3325 path1.moveTo(39.9375, -5.8359375);
3326 path1.lineTo(40.625, -5.7890625);
3327 path1.lineTo(37.7109375, 1.3515625);
3328 path1.lineTo(37.203125, 0.9609375);
3329 path1.close();
3330
3331 SkPath path2;
3332 path2.moveTo(37.52734375f, -1.44140625f);
3333 path2.cubicTo(37.8736991882324f, -1.69921875f, 38.1640625f, -2.140625f, 38.3984375f, -2.765625f);
3334 path2.lineTo(38.640625f, -2.609375f);
3335 path2.cubicTo(38.53125f, -1.89583337306976f, 38.0664443969727f, -0.154893040657043f, 38.0664443969727f, -0.154893040657043f);
3336 path2.cubicTo(38.0664443969727f, -0.154893040657043f, 37.1809883117676f, -1.18359375f, 37.52734375, -1.44140625f);
3337 path2.close();
3338
3339 testPathOp(reporter, path1, path2, kDifference_SkPathOp, filename);
3340}
3341
3342static void issue2504(skiatest::Reporter* reporter, const char* filename) {
3343 SkPath path1;
3344 path1.moveTo(34.2421875, -5.976562976837158203125);
3345 path1.lineTo(35.453121185302734375, 0);
3346 path1.lineTo(31.9375, 0);
3347 path1.close();
3348
3349 SkPath path2;
3350 path2.moveTo(36.71843719482421875, 0.8886508941650390625);
3351 path2.cubicTo(36.71843719482421875, 0.8886508941650390625,
3352 35.123386383056640625, 0.554015457630157470703125,
3353 34.511409759521484375, -0.1152553558349609375);
3354 path2.cubicTo(33.899425506591796875, -0.7845261096954345703125,
3355 34.53484344482421875, -5.6777553558349609375,
3356 34.53484344482421875, -5.6777553558349609375);
3357 path2.close();
3358 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename);
3359}
3360
3361static void issue2540(skiatest::Reporter* reporter, const char* filename) {
3362 SkPath path1;
3363 path1.moveTo(26.5054988861083984375, 85.73960113525390625);
3364 path1.cubicTo(84.19739532470703125, 17.77140045166015625, 16.93920135498046875, 101.86199951171875, 12.631000518798828125, 105.24700164794921875);
3365 path1.cubicTo(11.0819997787475585937500000, 106.46399688720703125, 11.5260000228881835937500000, 104.464996337890625, 11.5260000228881835937500000, 104.464996337890625);
3366 path1.lineTo(23.1654987335205078125, 89.72879791259765625);
3367 path1.cubicTo(23.1654987335205078125, 89.72879791259765625, -10.1713008880615234375, 119.9160003662109375, -17.1620006561279296875, 120.8249969482421875);
3368 path1.cubicTo(-19.1149997711181640625, 121.07900238037109375, -18.0380001068115234375, 119.79299163818359375, -18.0380001068115234375, 119.79299163818359375);
3369 path1.cubicTo(-18.0380001068115234375, 119.79299163818359375, 14.22100067138671875, 90.60700225830078125, 26.5054988861083984375, 85.73960113525390625);
3370 path1.close();
3371
3372 SkPath path2;
3373 path2.moveTo(-25.077999114990234375, 124.9120025634765625);
3374 path2.cubicTo(-25.077999114990234375, 124.9120025634765625, -25.9509983062744140625, 125.95400238037109375, -24.368999481201171875, 125.7480010986328125);
3375 path2.cubicTo(-16.06999969482421875, 124.66899871826171875, 1.2680000066757202148437500, 91.23999786376953125, 37.264003753662109375, 95.35400390625);
3376 path2.cubicTo(37.264003753662109375, 95.35400390625, 11.3710002899169921875, 83.7339935302734375, -25.077999114990234375, 124.9120025634765625);
3377 path2.close();
3378 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename);
3379}
3380
3381static void rects1(skiatest::Reporter* reporter, const char* filename) {
3382 SkPath path, pathB;
3383 path.setFillType(SkPath::kEvenOdd_FillType);
3384 path.moveTo(0, 0);
3385 path.lineTo(1, 0);
3386 path.lineTo(1, 1);
3387 path.lineTo(0, 1);
3388 path.close();
3389 path.moveTo(0, 0);
3390 path.lineTo(6, 0);
3391 path.lineTo(6, 6);
3392 path.lineTo(0, 6);
3393 path.close();
3394 pathB.setFillType(SkPath::kEvenOdd_FillType);
3395 pathB.moveTo(0, 0);
3396 pathB.lineTo(1, 0);
3397 pathB.lineTo(1, 1);
3398 pathB.lineTo(0, 1);
3399 pathB.close();
3400 pathB.moveTo(0, 0);
3401 pathB.lineTo(2, 0);
3402 pathB.lineTo(2, 2);
3403 pathB.lineTo(0, 2);
3404 pathB.close();
3405 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3406}
3407
3408static void rects2(skiatest::Reporter* reporter, const char* filename) {
3409 SkPath path, pathB;
3410 path.setFillType(SkPath::kEvenOdd_FillType);
3411 path.moveTo(0, 0);
3412 path.lineTo(4, 0);
3413 path.lineTo(4, 4);
3414 path.lineTo(0, 4);
3415 path.close();
3416 path.moveTo(3, 3);
3417 path.lineTo(4, 3);
3418 path.lineTo(4, 4);
3419 path.lineTo(3, 4);
3420 path.close();
3421 pathB.setFillType(SkPath::kWinding_FillType);
3422 pathB.moveTo(3, 3);
3423 pathB.lineTo(6, 3);
3424 pathB.lineTo(6, 6);
3425 pathB.lineTo(3, 6);
3426 pathB.close();
3427 pathB.moveTo(3, 3);
3428 pathB.lineTo(4, 3);
3429 pathB.lineTo(4, 4);
3430 pathB.lineTo(3, 4);
3431 pathB.close();
3432 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3433}
3434
3435static void rects3(skiatest::Reporter* reporter, const char* filename) {
3436 SkPath path, pathB;
3437 path.setFillType(SkPath::kEvenOdd_FillType);
3438 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3439 path.addRect(0, 0, 4, 4, SkPath::kCW_Direction);
3440 pathB.setFillType(SkPath::kWinding_FillType);
3441 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3442 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3443 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3444}
3445
3446static void rects4(skiatest::Reporter* reporter, const char* filename) {
3447 SkPath path, pathB;
3448 path.setFillType(SkPath::kEvenOdd_FillType);
3449 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3450 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3451 pathB.setFillType(SkPath::kWinding_FillType);
3452 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3453 pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
3454 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3455}
3456
3457static void issue2753(skiatest::Reporter* reporter, const char* filename) {
3458 SkPath path1;
3459 path1.moveTo(142.701f, 110.568f);
3460 path1.lineTo(142.957f, 100);
3461 path1.lineTo(153.835f, 100);
3462 path1.lineTo(154.592f, 108.188f);
3463 path1.cubicTo(154.592f, 108.188f, 153.173f, 108.483f, 152.83f, 109.412f);
3464 path1.cubicTo(152.83f, 109.412f, 142.701f, 110.568f, 142.701f, 110.568f);
3465 path1.close();
3466
3467 SkPath path2;
3468 path2.moveTo(39, 124.001f);
3469 path2.cubicTo(39, 124.001f, 50.6f, 117.001f, 50.6f, 117.001f);
3470 path2.cubicTo(50.6f, 117.001f, 164.601f, 85.2f, 188.201f, 117.601f);
3471 path2.cubicTo(188.201f, 117.601f, 174.801f, 93, 39, 124.001f);
3472 path2.close();
3473
3474 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename);
3475}
3476
3477static void issue2808(skiatest::Reporter* reporter, const char* filename) {
3478 SkPath path1, path2;
3479
3480 path1.moveTo(509.20300293f, 385.601989746f);
3481 path1.quadTo(509.20300293f, 415.68838501f, 487.928710938f, 436.96270752f);
3482 path1.quadTo(466.654388428f, 458.236999512f, 436.567993164f, 458.236999512f);
3483 path1.quadTo(406.4815979f, 458.236999512f, 385.207275391f, 436.96270752f);
3484 path1.quadTo(363.932983398f, 415.68838501f, 363.932983398f, 385.601989746f);
3485 path1.quadTo(363.932983398f, 355.515594482f, 385.207275391f, 334.241271973f);
3486 path1.quadTo(406.4815979f, 312.96697998f, 436.567993164f, 312.96697998f);
3487 path1.quadTo(466.654388428f, 312.96697998f, 487.928710938f, 334.241271973f);
3488 path1.quadTo(509.20300293f, 355.515594482f, 509.20300293f, 385.601989746f);
3489 path1.close();
3490
3491 path2.moveTo(449.033996582f, 290.87298584f);
3492 path2.quadTo(449.033996582f, 301.028259277f, 441.853149414f, 308.209106445f);
3493 path2.quadTo(434.672271729f, 315.389984131f, 424.516998291f, 315.389984131f);
3494 path2.quadTo(414.361724854f, 315.389984131f, 407.180847168f, 308.209106445f);
3495 path2.quadTo(400, 301.028259277f, 400, 290.87298584f);
3496 path2.quadTo(400, 280.717712402f, 407.180847168f, 273.536865234f);
3497 path2.quadTo(414.361724854f, 266.355987549f, 424.516998291f, 266.355987549f);
3498 path2.quadTo(434.672271729f, 266.355987549f, 441.853149414f, 273.536865234f);
3499 path2.quadTo(449.033996582f, 280.717712402f, 449.033996582f, 290.87298584f);
3500 path2.close();
3501
3502 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename);
3503}
3504
3505static void cubicOp115(skiatest::Reporter* reporter, const char* filename) {
3506 SkPath path, pathB;
3507 path.setFillType(SkPath::kWinding_FillType);
3508 path.moveTo(0,1);
3509 path.cubicTo(3,4, 2,1, 5,3);
3510 path.close();
3511 pathB.setFillType(SkPath::kWinding_FillType);
3512 pathB.moveTo(1,2);
3513 pathB.cubicTo(3,5, 1,0, 4,3);
3514 pathB.close();
3515 SkPath path2(path);
3516 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3517}
3518
3519static void testRect1(skiatest::Reporter* reporter, const char* filename) {
3520 SkPath path, path2;
3521 path.addRect(0, 0, 60, 60, SkPath::kCCW_Direction);
3522 path.addRect(30, 20, 50, 50, SkPath::kCCW_Direction);
3523 path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
3524// path.addRect(32, 24, 36, 41, SkPath::kCCW_Direction);
3525 testPathOp(reporter, path, path2, kUnion_SkPathOp, filename);
3526}
3527
3528static void testRect2(skiatest::Reporter* reporter, const char* filename) {
3529 SkPath path, pathB;
3530 path.setFillType(SkPath::kWinding_FillType);
3531 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3532 path.addRect(4, 4, 5, 5, SkPath::kCW_Direction);
3533 pathB.setFillType(SkPath::kEvenOdd_FillType);
3534 pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3535 pathB.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
3536 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3537}
3538
3539static void cubicOp116(skiatest::Reporter* reporter, const char* filename) {
3540 SkPath path, pathB;
3541 path.setFillType(SkPath::kWinding_FillType);
3542 path.moveTo(0,1);
3543 path.cubicTo(4,6, 2,0, 2,0);
3544 path.close();
3545 pathB.setFillType(SkPath::kWinding_FillType);
3546 pathB.moveTo(0,2);
3547 pathB.cubicTo(0,2, 1,0, 6,4);
3548 pathB.close();
3549 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3550}
3551
3552static void cubicOp117(skiatest::Reporter* reporter, const char* filename) {
3553 SkPath path, pathB;
3554 path.setFillType(SkPath::kWinding_FillType);
3555 path.moveTo(0,1);
3556 path.cubicTo(4,5, 6,0, 1,0);
3557 path.close();
3558 pathB.setFillType(SkPath::kWinding_FillType);
3559 pathB.moveTo(0,6);
3560 pathB.cubicTo(0,1, 1,0, 5,4);
3561 pathB.close();
3562 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3563}
3564
3565static void cubicOp118(skiatest::Reporter* reporter, const char* filename) {
3566 SkPath path, pathB;
3567 path.setFillType(SkPath::kWinding_FillType);
3568 path.moveTo(0,1);
3569 path.cubicTo(4,6, 5,1, 6,2);
3570 path.close();
3571 pathB.setFillType(SkPath::kWinding_FillType);
3572 pathB.moveTo(1,5);
3573 pathB.cubicTo(2,6, 1,0, 6,4);
3574 pathB.close();
3575 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3576}
3577
3578static void loop1(skiatest::Reporter* reporter, const char* filename) {
3579 SkPath path, pathB;
3580 path.moveTo(0,1);
3581 path.cubicTo(1,5, -5.66666651f,3.33333349f, 8.83333302f,2.33333349f);
3582 path.close();
3583 pathB.moveTo(1,5);
3584 pathB.cubicTo(-5.66666651f,3.33333349f, 8.83333302f,2.33333349f, 0,1);
3585 pathB.close();
3586 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3587}
3588
3589#include "SkPathOpsCubic.h"
3590
3591static void loop1asQuad(skiatest::Reporter* reporter, const char* filename) {
3592 CubicPts cubic1 = {{{0,1}, {1,5}, {-5.66666651f,3.33333349f}, {8.83333302f,2.33333349f}}};
3593 CubicPts cubic2 = {{{1,5}, {-5.66666651f,3.33333349f}, {8.83333302f,2.33333349f}, {0,1}}};
3594 SkDCubic c1, c2;
3595 c1.debugSet(cubic1.fPts);
3596 c2.debugSet(cubic2.fPts);
3597 double c1InflectionTs[2], c2InflectionTs[2];
3598 SkDEBUGCODE(int c1InfTCount =) c1.findInflections(c1InflectionTs);
3599 SkASSERT(c1InfTCount == 2);
3600 SkDEBUGCODE(int c2InfTCount =) c2.findInflections(c2InflectionTs);
3601 SkASSERT(c2InfTCount == 1);
3602 SkASSERT(c1InflectionTs[0] > c1InflectionTs[1]);
3603 SkDCubicPair c1pair = c1.chopAt(c1InflectionTs[0]);
3604 SkDCubicPair c1apair = c1pair.first().chopAt(c1InflectionTs[1]);
3605 SkDCubicPair c2pair = c2.chopAt(c2InflectionTs[0]);
3606 SkDQuad q1[2] = { c1pair.first().toQuad(), c1pair.second().toQuad() };
3607 SkDQuad q1a[2] = { c1apair.first().toQuad(), c1apair.second().toQuad() };
3608 SkDQuad q2[2] = { c2pair.first().toQuad(), c2pair.second().toQuad() };
3609 SkPath path, pathB;
3610 path.moveTo(q1a[0].fPts[0].asSkPoint());
3611 path.quadTo(q1a[0].fPts[1].asSkPoint(), q1a[0].fPts[2].asSkPoint());
3612 path.quadTo(q1a[1].fPts[1].asSkPoint(), q1a[1].fPts[2].asSkPoint());
3613 path.quadTo(q1[1].fPts[1].asSkPoint(), q1[1].fPts[2].asSkPoint());
3614 path.close();
3615 pathB.moveTo(q2[0].fPts[0].asSkPoint());
3616 pathB.quadTo(q2[0].fPts[1].asSkPoint(), q2[0].fPts[2].asSkPoint());
3617 pathB.quadTo(q2[1].fPts[1].asSkPoint(), q2[1].fPts[2].asSkPoint());
3618 pathB.close();
3619 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3620}
3621
3622static void loop2(skiatest::Reporter* reporter, const char* filename) {
3623 SkPath path, pathB;
3624 path.moveTo(0,1);
3625 path.cubicTo(3,4, 3.f,4.f, 4.5f,1.5f);
3626 path.close();
3627 pathB.moveTo(3,4);
3628 pathB.cubicTo(3.f,4.f, 4.5f,1.5f, 0,1);
3629 pathB.close();
3630 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3631}
3632
3633static void loop3(skiatest::Reporter* reporter, const char* filename) {
3634 SkPath path, pathB;
3635 path.moveTo(0,1);
3636 path.cubicTo(3,5, -3.66666651f,0, 10.5f,-1.66666651f);
3637 path.close();
3638 pathB.moveTo(3,5);
3639 pathB.cubicTo(-3.66666651f,0, 10.5f,-1.66666651f, 0,1);
3640 pathB.close();
3641 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3642}
3643
3644static void loop4(skiatest::Reporter* reporter, const char* filename) {
3645 SkPath path, pathB;
3646 path.moveTo(0,5);
3647 path.cubicTo(1,5, 1,4, 0.833333313f,3);
3648 path.close();
3649 pathB.moveTo(1,5);
3650 pathB.cubicTo(1,4, 0.833333313f,3, 0,5);
3651 pathB.close();
3652 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3653}
3654
3655#include "SkParsePath.h"
3656
3657static void issue3517(skiatest::Reporter* reporter, const char* filename) {
3658 SkPath path, pathB;
3659
3660 const char str[] = "M31.35 57.75L31.35 57.75C31.9 57.7486 32.45 57.7948 33 57.7413C33.55 57.6878 34.1 57.5014 34.65 57.4291C35.2 57.3569 35.75 57.3223 36.3 57.3079C36.85 57.2935 37.4 57.3143 37.95 57.3428C38.5 57.3712 39.05 57.4112 39.6 57.4786C40.15 57.546 40.7 57.7029 41.25 57.7472C41.8 57.7916 42.35 57.7962 42.9 57.7445C43.45 57.6928 44 57.5345 44.55 57.4373C45.1 57.34 45.65 57.2115 46.2 57.1611C46.75 57.1107 47.3 57.1371 47.85 57.1349C48.4 57.1327 48.95 57.144 49.5 57.1478C50.05 57.1516 50.6 57.1553 51.15 57.1579C51.7 57.1605 52.25 57.1601 52.8 57.1634C53.35 57.1667 53.9 57.1731 54.45 57.1776C55 57.182 55.55 57.1916 56.1 57.19C56.65 57.1884 57.2 57.178 57.75 57.168C58.3 57.158 58.85 57.1355 59.4 57.1299C59.95 57.1243 60.5 57.1338 61.05 57.1345C61.6 57.1352 62.15 57.124 62.7 57.134C63.25 57.1441 63.8 57.1731 64.35 57.195C64.9 57.2169 65.45 57.2532 66 57.2655C66.55 57.2778 67.1 57.2647 67.65 57.2687C68.2 57.2728 68.75 57.267 69.3 57.2896C69.85 57.3122 70.4 57.371 70.95 57.4044C71.5 57.4377 72.05 57.4668 72.6 57.4896C73.15 57.5123 73.7 57.545 74.25 57.5408C74.8 57.5365 75.35 57.5068 75.9 57.4641C76.45 57.4213 77 57.3244 77.55 57.2842C78.1 57.244 78.65 57.2163 79.2 57.2228C79.75 57.2293 80.3 57.29 80.85 57.3232C81.4 57.3563 81.95 57.396 82.5 57.4219C83.05 57.4478 83.6 57.4637 84.15 57.4787C84.7 57.4937 85.25 57.5011 85.8 57.5121C86.35 57.523 86.9 57.5411 87.45 57.5444C88 57.5477 88.55 57.5663 89.1 57.5318C89.65 57.4972 90.2 57.3126 90.75 57.337C91.3 57.3613 91.85 57.6088 92.4 57.6776C92.95 57.7465 93.5 57.7379 94.05 57.75C94.6 57.7621 95.15 57.75 95.7 57.75L95.7 57.75L31.35 57.75Z";
3661 SkParsePath::FromSVGString(str, &path);
3662
3663 const char strB[] = "M31.35 57.75L31.35 57.75C31.9 57.7514 32.45 57.7052 33 57.7587C33.55 57.8122 34.1 57.9986 34.65 58.0709C35.2 58.1431 35.75 58.1777 36.3 58.1921C36.85 58.2065 37.4 58.1857 37.95 58.1572C38.5 58.1288 39.05 58.0888 39.6 58.0214C40.15 57.954 40.7 57.7971 41.25 57.7528C41.8 57.7084 42.35 57.7038 42.9 57.7555C43.45 57.8072 44 57.9655 44.55 58.0627C45.1 58.16 45.65 58.2885 46.2 58.3389C46.75 58.3893 47.3 58.3629 47.85 58.3651C48.4 58.3673 48.95 58.356 49.5 58.3522C50.05 58.3484 50.6 58.3447 51.15 58.3421C51.7 58.3395 52.25 58.3399 52.8 58.3366C53.35 58.3333 53.9 58.3269 54.45 58.3224C55 58.318 55.55 58.3084 56.1 58.31C56.65 58.3116 57.2 58.322 57.75 58.332C58.3 58.342 58.85 58.3645 59.4 58.3701C59.95 58.3757 60.5 58.3662 61.05 58.3655C61.6 58.3648 62.15 58.376 62.7 58.366C63.25 58.3559 63.8 58.3269 64.35 58.305C64.9 58.2831 65.45 58.2468 66 58.2345C66.55 58.2222 67.1 58.2353 67.65 58.2313C68.2 58.2272 68.75 58.233 69.3 58.2104C69.85 58.1878 70.4 58.129 70.95 58.0956C71.5 58.0623 72.05 58.0332 72.6 58.0104C73.15 57.9877 73.7 57.955 74.25 57.9592C74.8 57.9635 75.35 57.9932 75.9 58.0359C76.45 58.0787 77 58.1756 77.55 58.2158C78.1 58.256 78.65 58.2837 79.2 58.2772C79.75 58.2707 80.3 58.21 80.85 58.1768C81.4 58.1437 81.95 58.104 82.5 58.0781C83.05 58.0522 83.6 58.0363 84.15 58.0213C84.7 58.0063 85.25 57.9989 85.8 57.9879C86.35 57.977 86.9 57.9589 87.45 57.9556C88 57.9523 88.55 57.9337 89.1 57.9682C89.65 58.0028 90.2 58.1874 90.75 58.163C91.3 58.1387 91.85 57.8912 92.4 57.8224C92.95 57.7535 93.5 57.7621 94.05 57.75C94.6 57.7379 95.15 57.75 95.7 57.75L95.7 57.75L31.35 57.75Z";
3664 SkParsePath::FromSVGString(strB, &pathB);
3665 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3666}
3667
3668static void cubicOp119(skiatest::Reporter* reporter, const char* filename) {
3669 SkPath path, pathB;
3670 path.setFillType(SkPath::kWinding_FillType);
3671 path.moveTo(0,1);
3672 path.cubicTo(3,5, 2,1, 3,1);
3673 path.close();
3674 pathB.setFillType(SkPath::kWinding_FillType);
3675 pathB.moveTo(1,2);
3676 pathB.cubicTo(1,3, 1,0, 5,3);
3677 pathB.close();
3678 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3679}
3680
3681static void cubicOp120(skiatest::Reporter* reporter, const char* filename) {
3682 SkPath path, pathB;
3683 path.setFillType(SkPath::kWinding_FillType);
3684 path.moveTo(0,1);
3685 path.cubicTo(2,4, 2,1, 4,0);
3686 path.close();
3687 pathB.setFillType(SkPath::kWinding_FillType);
3688 pathB.moveTo(1,2);
3689 pathB.cubicTo(0,4, 1,0, 4,2);
3690 pathB.close();
3691 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3692}
3693
3694static void cubicOp121(skiatest::Reporter* reporter, const char* filename) {
3695 SkPath path, pathB;
3696 path.setFillType(SkPath::kWinding_FillType);
3697 path.moveTo(0,1);
3698 path.cubicTo(3,4, 3,2, 4,3);
3699 path.close();
3700 pathB.setFillType(SkPath::kWinding_FillType);
3701 pathB.moveTo(2,3);
3702 pathB.cubicTo(3,4, 1,0, 4,3);
3703 pathB.close();
3704 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3705}
3706
3707// FIXME : haven't debugged this failure yet
3708static void cubicOp122(skiatest::Reporter* reporter, const char* filename) {
3709 SkPath path, pathB;
3710 path.setFillType(SkPath::kWinding_FillType);
3711 path.moveTo(0,1);
3712 path.cubicTo(3,5, 4,1, 4,0);
3713 path.close();
3714 pathB.setFillType(SkPath::kWinding_FillType);
3715 pathB.moveTo(1,4);
3716 pathB.cubicTo(0,4, 1,0, 5,3);
3717 pathB.close();
3718 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3719}
3720
3721static void cubicOp123(skiatest::Reporter* reporter, const char* filename) {
3722 SkPath path, pathB;
3723 path.setFillType(SkPath::kWinding_FillType);
3724 path.moveTo(0,1);
3725 path.cubicTo(1,5, 2,0, 6,0);
3726 path.close();
3727 pathB.setFillType(SkPath::kWinding_FillType);
3728 pathB.moveTo(0,2);
3729 pathB.cubicTo(0,6, 1,0, 5,1);
3730 pathB.close();
3731 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3732}
3733
3734static void loop5(skiatest::Reporter* reporter, const char* filename) {
3735 SkPath path, pathB;
3736 path.moveTo(0,2);
3737 path.cubicTo(1,2, 1,1.66666663f, 0.833333313f,1.33333325f);
3738 path.close();
3739 pathB.moveTo(1,2);
3740 pathB.cubicTo(1,1.66666663f, 0.833333313f,1.33333325f, 0,2);
3741 pathB.close();
3742 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3743}
3744
3745static void loop6(skiatest::Reporter* reporter, const char* filename) {
3746 SkPath path, pathB;
3747 path.moveTo(0,1);
3748 path.cubicTo(1,3, -1.66666675f,1.66666663f, 4.16666651f,1.00000012f);
3749 path.close();
3750 pathB.moveTo(1,3);
3751 pathB.cubicTo(-1.66666675f,1.66666663f, 4.16666651f,1.00000012f, 0,1);
3752 pathB.close();
3753 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3754}
3755
3756static void cubicOp124(skiatest::Reporter* reporter, const char* filename) {
3757 SkPath path, pathB;
3758 path.setFillType(SkPath::kWinding_FillType);
3759 path.moveTo(0,1);
3760 path.cubicTo(1,5, 6,0, 3,0);
3761 path.close();
3762 pathB.setFillType(SkPath::kWinding_FillType);
3763 pathB.moveTo(0,6);
3764 pathB.cubicTo(0,3, 1,0, 5,1);
3765 pathB.close();
3766 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3767}
3768
3769static void cubicOp125(skiatest::Reporter* reporter, const char* filename) {
3770 SkPath path, pathB;
3771 path.setFillType(SkPath::kWinding_FillType);
3772 path.moveTo(0,1);
3773 path.cubicTo(3,6, 3,1, 6,2);
3774 path.close();
3775 pathB.setFillType(SkPath::kWinding_FillType);
3776 pathB.moveTo(1,3);
3777 pathB.cubicTo(2,6, 1,0, 6,3);
3778 pathB.close();
3779 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3780}
3781
3782static void cubicOp126(skiatest::Reporter* reporter, const char* filename) {
3783 SkPath path, pathB;
3784 path.setFillType(SkPath::kWinding_FillType);
3785 path.moveTo(0,1);
3786 path.cubicTo(0,3, 6,0, 2,1);
3787 path.close();
3788 pathB.setFillType(SkPath::kWinding_FillType);
3789 pathB.moveTo(0,6);
3790 pathB.cubicTo(1,2, 1,0, 3,0);
3791 pathB.close();
3792 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3793}
3794
3795static void cubicOp127(skiatest::Reporter* reporter, const char* filename) {
3796 SkPath path, pathB;
3797 path.setFillType(SkPath::kWinding_FillType);
3798 path.moveTo(0,1);
3799 path.cubicTo(1,5, 6,0, 3,0);
3800 path.close();
3801 pathB.setFillType(SkPath::kWinding_FillType);
3802 pathB.moveTo(0,6);
3803 pathB.cubicTo(0,3, 1,0, 5,1);
3804 pathB.close();
3805 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3806}
3807
3808static void cubicOp128(skiatest::Reporter* reporter, const char* filename) {
3809 SkPath path, pathB;
3810 path.setFillType(SkPath::kWinding_FillType);
3811 path.moveTo(0,1);
3812 path.cubicTo(0,3, 3,2, 5,2);
3813 path.close();
3814 pathB.setFillType(SkPath::kWinding_FillType);
3815 pathB.moveTo(2,3);
3816 pathB.cubicTo(2,5, 1,0, 3,0);
3817 pathB.close();
3818 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3819}
3820
3821static void cubicOp129(skiatest::Reporter* reporter, const char* filename) {
3822 SkPath path, pathB;
3823 path.setFillType(SkPath::kWinding_FillType);
3824 path.moveTo(5,6);
3825 path.cubicTo(3,4, 2,0, 2,1);
3826 path.close();
3827 pathB.setFillType(SkPath::kWinding_FillType);
3828 pathB.moveTo(0,2);
3829 pathB.cubicTo(1,2, 6,5, 4,3);
3830 pathB.close();
3831 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3832}
3833
3834static void cubicOp130(skiatest::Reporter* reporter, const char* filename) {
3835 SkPath path, pathB;
3836 path.setFillType(SkPath::kWinding_FillType);
3837 path.moveTo(5,6);
3838 path.cubicTo(4,6, 3,0, 2,1);
3839 path.close();
3840 pathB.setFillType(SkPath::kWinding_FillType);
3841 pathB.moveTo(0,3);
3842 pathB.cubicTo(1,2, 6,5, 6,4);
3843 pathB.close();
3844 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3845}
3846
3847#include "SkGeometry.h"
3848
3849static void complex_to_quads(const SkPoint pts[], SkPath* path) {
3850 SkScalar loopT[3];
3851 if (SkDCubic::ComplexBreak(pts, loopT)) {
3852 SkPoint cubicPair[7];
3853 SkChopCubicAt(pts, cubicPair, loopT[0]);
3854 SkDCubic c1, c2;
3855 c1.set(cubicPair);
3856 c2.set(&cubicPair[3]);
3857 SkDQuad q1 = c1.toQuad();
3858 SkDQuad q2 = c2.toQuad();
3859 path->quadTo(q1[1].asSkPoint(), q1[2].asSkPoint());
3860 path->quadTo(q2[1].asSkPoint(), q2[2].asSkPoint());
3861 } else {
3862 path->cubicTo(pts[1], pts[2], pts[3]);
3863 }
3864}
3865
3866static void cubicOp130a(skiatest::Reporter* reporter, const char* filename) {
3867 SkPath path, pathB;
3868 path.setFillType(SkPath::kWinding_FillType);
3869 path.moveTo(5,6);
3870 SkPoint pts[] = { {5,6}, {4,6}, {3,0}, {2,1} };
3871 complex_to_quads(pts, &path);
3872 path.close();
3873 pathB.setFillType(SkPath::kWinding_FillType);
3874 pathB.moveTo(0,3);
3875 SkPoint pts2[] = { {0,3}, {1,2}, {6,5}, {6,4} };
3876 complex_to_quads(pts2, &path);
3877 pathB.close();
3878 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3879}
3880
3881static void cubicOp131(skiatest::Reporter* reporter, const char* filename) {
3882 SkPath path, pathB;
3883 path.setFillType(SkPath::kWinding_FillType);
3884 path.moveTo(0,1);
3885 path.cubicTo(3,4, 3,0, 6,2);
3886 path.close();
3887 pathB.setFillType(SkPath::kWinding_FillType);
3888 pathB.moveTo(0,3);
3889 pathB.cubicTo(2,6, 1,0, 4,3);
3890 pathB.close();
3891 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3892}
3893
3894static void circlesOp1(skiatest::Reporter* reporter, const char* filename) {
3895 SkPath path, pathB;
3896 path.setFillType(SkPath::kWinding_FillType);
3897 path.addCircle(0, 1, 2, SkPath::kCCW_Direction);
3898 pathB.setFillType(SkPath::kWinding_FillType);
3899 pathB.addCircle(0, 1, 1, SkPath::kCW_Direction);
3900 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3901}
3902
3903static void circlesOp2(skiatest::Reporter* reporter, const char* filename) {
3904 SkPath path, pathB;
3905 path.setFillType(SkPath::kWinding_FillType);
3906 path.addCircle(0, 1, 4, SkPath::kCCW_Direction);
3907 pathB.setFillType(SkPath::kWinding_FillType);
3908 pathB.addCircle(0, 4, 3, SkPath::kCW_Direction);
3909 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3910}
3911
3912static void rRect1x(skiatest::Reporter* reporter, const char* filename) {
3913 SkPath path, pathB;
3914 path.setFillType(SkPath::kEvenOdd_FillType);
3915 path.moveTo(20.65f, 5.65f);
3916 path.conicTo(20.65f, 1.13612f, 25.1404f, 0.65f, 0.888488f);
3917 path.lineTo(25.65f, 0.65f);
3918 path.lineTo(26.1596f, 0.67604f);
3919 path.conicTo(30.65f, 1.13612f, 30.65f, 5.65f, 0.888488f);
3920 path.lineTo(30.65f, 25.65f);
3921 path.conicTo(30.65f, 20.65f, 25.65f, 20.65f, 0.707107f);
3922 path.lineTo(20.65f, 20.65f);
3923 path.lineTo(20.65f, 5.65f);
3924 path.close();
3925 path.moveTo(20.65f, 20.65f);
3926 path.lineTo(5.65f, 20.65f);
3927 path.conicTo(0.65f, 20.65f, 0.65f, 25.65f, 0.707107f);
3928 path.lineTo(0.65f, 45.65f);
3929 path.conicTo(0.65f, 50.65f, 5.65f, 50.65f, 0.707107f);
3930 path.lineTo(25.65f, 50.65f);
3931 path.conicTo(30.65f, 50.65f, 30.65f, 45.65f, 0.707107f);
3932 path.lineTo(30.65f, 25.65f);
3933 path.conicTo(30.65f, 30.65f, 25.65f, 30.65f, 0.707107f);
3934 path.conicTo(20.65f, 30.65f, 20.65f, 25.65f, 0.707107f);
3935 path.lineTo(20.65f, 20.65f);
3936 path.close();
3937 SkPath path1(path);
3938
3939 path.reset();
3940 path.setFillType(SkPath::kWinding_FillType);
3941 path.moveTo(20.65f, 45.65f);
3942 path.lineTo(20.65f, 25.65f);
3943 path.conicTo(20.65f, 20.65f, 25.65f, 20.65f, 0.707107f);
3944 path.lineTo(45.65f, 20.65f);
3945 path.conicTo(50.65f, 20.65f, 50.65f, 25.65f, 0.707107f);
3946 path.lineTo(50.65f, 45.65f);
3947 path.conicTo(50.65f, 50.65f, 45.65f, 50.65f, 0.707107f);
3948 path.lineTo(25.65f, 50.65f);
3949 path.conicTo(20.65f, 50.65f, 20.65f, 45.65f, 0.707107f);
3950 path.close();
3951 SkPath path2(path);
3952
3953 testPathOp(reporter, path1, path2, kDifference_SkPathOp, filename);
3954}
3955
3956static void loop7(skiatest::Reporter* reporter, const char* filename) {
3957 SkPath path, pathB;
3958 path.moveTo(0,1);
3959 path.cubicTo(3,4, -1,0, 8.5f,-2.5f);
3960 path.close();
3961 pathB.moveTo(3,4);
3962 pathB.cubicTo(-1,0, 8.5f,-2.5f, 0,1);
3963 pathB.close();
3964 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3965}
3966
3967static void rects5(skiatest::Reporter* reporter, const char* filename) {
3968 SkPath path, pathB;
3969 path.setFillType(SkPath::kWinding_FillType);
3970 path.addRect(5, 5, 6, 6, SkPath::kCW_Direction);
3971 path.addRect(5, 5, 6, 6, SkPath::kCW_Direction);
3972 pathB.setFillType(SkPath::kEvenOdd_FillType);
3973 pathB.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
3974 pathB.addRect(5, 5, 6, 6, SkPath::kCW_Direction);
3975 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3976}
3977
3978static void loop8(skiatest::Reporter* reporter, const char* filename) {
3979 SkPath path, pathB;
3980 path.moveTo(0,1);
3981 path.cubicTo(1,4, -3.83333325f,0.166666627f, 6,-1);
3982 path.close();
3983 pathB.moveTo(1,4);
3984 pathB.cubicTo(-3.83333325f,0.166666627f, 6,-1, 0,1);
3985 pathB.close();
3986 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3987}
3988
3989static void loop9(skiatest::Reporter* reporter, const char* filename) {
3990 SkPath path, pathB;
3991 path.moveTo(0,1);
3992 path.cubicTo(1,3, -2.5f,0, 3.33333325f,-0.666666627f);
3993 path.close();
3994 pathB.moveTo(1,3);
3995 pathB.cubicTo(-2.5f,0, 3.33333325f,-0.666666627f, 0,1);
3996 pathB.close();
3997 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3998}
3999
4000static void circlesOp3(skiatest::Reporter* reporter, const char* filename) {
4001 SkPath path, pathB;
4002 path.setFillType(SkPath::kWinding_FillType);
4003 path.addCircle(0, 1, 2, SkPath::kCCW_Direction);
4004 pathB.setFillType(SkPath::kWinding_FillType);
4005 pathB.addCircle(3, 5, 3, SkPath::kCW_Direction);
4006 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4007}
4008
4009static void loop10(skiatest::Reporter* reporter, const char* filename) {
4010 SkPath path, pathB;
4011 path.moveTo(5,6);
4012 path.cubicTo(1,2, 1,2, -3.66666651f,13.333334f);
4013 path.close();
4014 pathB.moveTo(1,2);
4015 pathB.cubicTo(1,2, -3.66666651f,13.333334f, 5,6);
4016 pathB.close();
4017 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4018}
4019
4020static void loop11(skiatest::Reporter* reporter, const char* filename) {
4021 SkPath path, pathB;
4022 path.moveTo(0,1);
4023 path.cubicTo(1,3, -1.83333349f,1.33333337f, 4,-1);
4024 path.close();
4025 pathB.moveTo(1,3);
4026 pathB.cubicTo(-1.83333349f,1.33333337f, 4,-1, 0,1);
4027 pathB.close();
4028 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4029}
4030
4031static void cubicOp132(skiatest::Reporter* reporter, const char* filename) {
4032 SkPath path, pathB;
4033 path.setFillType(SkPath::kWinding_FillType);
4034 path.moveTo(5,6);
4035 path.cubicTo(3,4, 3,0, 3,2);
4036 path.close();
4037 pathB.setFillType(SkPath::kWinding_FillType);
4038 pathB.moveTo(0,3);
4039 pathB.cubicTo(2,3, 6,5, 4,3);
4040 pathB.close();
4041 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4042}
4043
4044static void loop12(skiatest::Reporter* reporter, const char* filename) {
4045 SkPath path, pathB;
4046 path.moveTo(1,2);
4047 path.cubicTo(0,6, -3.16666675f,3.66666675f, 6.33333349f,3.33333349f);
4048 path.close();
4049 pathB.moveTo(0,6);
4050 pathB.cubicTo(-3.16666675f,3.66666675f, 6.33333349f,3.33333349f, 1,2);
4051 pathB.close();
4052 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4053}
4054
4055static void cubicOp133(skiatest::Reporter* reporter, const char* filename) {
4056 SkPath path, pathB;
4057 path.setFillType(SkPath::kWinding_FillType);
4058 path.moveTo(5,6);
4059 path.cubicTo(5,6, 5,0, 4,1);
4060 path.close();
4061 pathB.setFillType(SkPath::kWinding_FillType);
4062 pathB.moveTo(0,5);
4063 pathB.cubicTo(1,4, 6,5, 6,5);
4064 pathB.close();
4065 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4066}
4067
4068static void cubicOp134(skiatest::Reporter* reporter, const char* filename) {
4069 SkPath path, pathB;
4070 path.setFillType(SkPath::kWinding_FillType);
4071 path.moveTo(5,6);
4072 path.cubicTo(5,6, 6,0, 3,1);
4073 path.close();
4074 pathB.setFillType(SkPath::kWinding_FillType);
4075 pathB.moveTo(0,6);
4076 pathB.cubicTo(1,3, 6,5, 6,5);
4077 pathB.close();
4078 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4079}
4080
4081static void cubicOp135(skiatest::Reporter* reporter, const char* filename) {
4082 SkPath path, pathB;
4083 path.setFillType(SkPath::kWinding_FillType);
4084 path.moveTo(5,6);
4085 path.cubicTo(5,6, 6,0, 4,1);
4086 path.close();
4087 pathB.setFillType(SkPath::kWinding_FillType);
4088 pathB.moveTo(0,6);
4089 pathB.cubicTo(1,4, 6,5, 6,5);
4090 pathB.close();
4091 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4092}
4093
4094static void cubicOp136(skiatest::Reporter* reporter, const char* filename) {
4095 SkPath path, pathB;
4096 path.setFillType(SkPath::kWinding_FillType);
4097 path.moveTo(5,6);
4098 path.cubicTo(5,6, 5,0, 3,1);
4099 path.close();
4100 pathB.setFillType(SkPath::kWinding_FillType);
4101 pathB.moveTo(0,5);
4102 pathB.cubicTo(1,3, 6,5, 6,5);
4103 pathB.close();
4104 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4105}
4106
4107static void cubicOp136a(skiatest::Reporter* reporter, const char* filename) {
4108 SkPath path, pathB;
4109 path.setFillType(SkPath::kWinding_FillType);
4110 path.moveTo(5,6);
4111 path.quadTo(5,0, 3,1);
4112 path.close();
4113 pathB.setFillType(SkPath::kWinding_FillType);
4114 pathB.moveTo(0,5);
4115 pathB.cubicTo(1,3, 6,5, 6,5);
4116 pathB.close();
4117 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4118}
4119
4120static void cubics137(skiatest::Reporter* reporter, const char* filename) {
4121 SkPath path, pathB;
4122 path.setFillType(SkPath::kWinding_FillType);
4123 path.moveTo(0, 5);
4124 path.cubicTo(3, 6, 1, 0, 3, 2);
4125 path.close();
4126 pathB.setFillType(SkPath::kWinding_FillType);
4127 pathB.moveTo(0, 1);
4128 pathB.cubicTo(2, 3, 5, 0, 6, 3);
4129 pathB.close();
4130 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4131}
4132
4133static void cubics138(skiatest::Reporter* reporter, const char* filename) {
4134 SkPath path, pathB;
4135 path.setFillType(SkPath::kWinding_FillType);
4136 path.moveTo(0, 5);
4137 path.cubicTo(3, 6, 1, 0, 4, 2);
4138 path.close();
4139 pathB.setFillType(SkPath::kWinding_FillType);
4140 pathB.moveTo(0, 1);
4141 pathB.cubicTo(2, 4, 5, 0, 6, 3);
4142 pathB.close();
4143 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4144}
4145
4146// three curves intersect successfully nearby -- the angle only gets 2 of the 3 pts
4147static void cubicOp139(skiatest::Reporter* reporter, const char* filename) {
4148 SkPath path, pathB;
4149 path.setFillType(SkPath::kWinding_FillType);
4150 path.moveTo(0,2);
4151 path.cubicTo(0,4, 3,1, 5,1);
4152 path.close();
4153 pathB.setFillType(SkPath::kWinding_FillType);
4154 pathB.moveTo(1,3);
4155 pathB.cubicTo(1,5, 2,0, 4,0);
4156 pathB.close();
4157 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4158}
4159
4160static void cubicOp140(skiatest::Reporter* reporter, const char* filename) {
4161 SkPath path, pathB;
4162 path.setFillType(SkPath::kWinding_FillType);
4163 path.moveTo(0,2);
4164 path.cubicTo(1,2, 5,4, 3,2);
4165 path.close();
4166 pathB.setFillType(SkPath::kWinding_FillType);
4167 pathB.moveTo(4,5);
4168 pathB.cubicTo(2,3, 2,0, 2,1);
4169 pathB.close();
4170 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4171}
4172
4173static void cubicOp141(skiatest::Reporter* reporter, const char* filename) {
4174 SkPath path, pathB;
4175 path.setFillType(SkPath::kWinding_FillType);
4176 path.moveTo(0,2);
4177 path.cubicTo(1,2, 6,4, 3,2);
4178 path.close();
4179 pathB.setFillType(SkPath::kWinding_FillType);
4180 pathB.moveTo(4,6);
4181 pathB.cubicTo(2,3, 2,0, 2,1);
4182 pathB.close();
4183 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4184}
4185
4186static void quadRect1(skiatest::Reporter* reporter, const char* filename) {
4187 SkPath path, pathB;
4188 path.moveTo(6,15);
4189 path.quadTo(16,0, 8,4);
4190 path.quadTo(2,7, 12,12);
4191 path.close();
4192 pathB.addRect(4,11, 13,16);
4193 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4194}
4195
4196static void quadRect2(skiatest::Reporter* reporter, const char* filename) {
4197 SkPath path, pathB;
4198 path.moveTo(5,12);
4199 path.quadTo(15,7, 9,4);
4200 path.quadTo(1,0, 11,15);
4201 path.close();
4202 pathB.addRect(4,11, 13,16);
4203 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4204}
4205
4206static void quadRect3(skiatest::Reporter* reporter, const char* filename) {
4207 SkPath path, pathB;
4208 path.moveTo(12,12);
4209 path.quadTo(2,7, 8,4);
4210 path.quadTo(16,0, 6,15);
4211 path.close();
4212 pathB.addRect(4,11, 13,16);
4213 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4214}
4215
4216static void quadRect4(skiatest::Reporter* reporter, const char* filename) {
4217 SkPath path, pathB;
4218 path.moveTo(11,15);
4219 path.quadTo(1,0, 9,4);
4220 path.quadTo(15,7, 5,12);
4221 path.close();
4222 pathB.addRect(4,11, 13,16);
4223 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4224}
4225
4226static void quadRect5(skiatest::Reporter* reporter, const char* filename) {
4227 SkPath path, pathB;
4228 path.moveTo(11,13);
4229 path.quadTo(4,4, 8,4);
4230 path.quadTo(12,4, 5,13);
4231 path.close();
4232 pathB.addRect(4,11, 13,16);
4233 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4234}
4235
4236static void quadRect6(skiatest::Reporter* reporter, const char* filename) {
4237 SkPath path, pathB;
4238 path.moveTo(5,13);
4239 path.quadTo(12,4, 8,4);
4240 path.quadTo(4,4, 11,13);
4241 path.close();
4242 pathB.addRect(4,11, 13,16);
4243 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4244}
4245
4246static void loops4i(skiatest::Reporter* reporter, const char* filename) {
4247 SkPath path, pathB;
4248 path.setFillType(SkPath::kWinding_FillType);
4249 path.moveTo(0, 3);
4250 path.cubicTo(0, 2, 0, 2, -1.66666663f, 2.16666675f);
4251 path.close();
4252 pathB.setFillType(SkPath::kWinding_FillType);
4253 pathB.moveTo(0, 2);
4254 pathB.cubicTo(0, 2, -1.66666663f, 2.16666675f, 0, 3);
4255 pathB.close();
4256 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4257}
4258
4259static void loops5i(skiatest::Reporter* reporter, const char* filename) {
4260 SkPath path, pathB;
4261 path.setFillType(SkPath::kWinding_FillType);
4262 path.moveTo(1, 2);
4263 path.cubicTo(0, 2, 0, 2, 0.166666672f, 2.66666675f);
4264 path.close();
4265 pathB.setFillType(SkPath::kWinding_FillType);
4266 pathB.moveTo(0, 2);
4267 pathB.cubicTo(0, 2, 0.166666672f, 2.66666675f, 1, 2);
4268 pathB.close();
4269 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4270}
4271
4272static void cubicOp142(skiatest::Reporter* reporter, const char* filename) {
4273 SkPath path, pathB;
4274 path.setFillType(SkPath::kWinding_FillType);
4275 path.moveTo(5,6);
4276 path.cubicTo(2,5, 2,1, 1,0);
4277 path.close();
4278 pathB.setFillType(SkPath::kWinding_FillType);
4279 pathB.moveTo(1,2);
4280 pathB.cubicTo(0,1, 6,5, 5,2);
4281 pathB.close();
4282 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4283}
4284
4285static void cubics6d(skiatest::Reporter* reporter, const char* filename) {
4286 SkPath path, pathB;
4287 path.setFillType(SkPath::kWinding_FillType);
4288 path.moveTo(3, 5);
4289 path.cubicTo(1, 5, 4, 2, 4, 0);
4290 path.close();
4291 pathB.setFillType(SkPath::kWinding_FillType);
4292 pathB.moveTo(2, 4);
4293 pathB.cubicTo(0, 4, 5, 3, 5, 1);
4294 pathB.close();
4295 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4296}
4297
4298static void cubics7d(skiatest::Reporter* reporter, const char* filename) {
4299 SkPath path, pathB;
4300 path.setFillType(SkPath::kWinding_FillType);
4301 path.moveTo(2, 6);
4302 path.cubicTo(2, 4, 5, 1, 3, 1);
4303 path.close();
4304 pathB.setFillType(SkPath::kWinding_FillType);
4305 pathB.moveTo(1, 5);
4306 pathB.cubicTo(1, 3, 6, 2, 4, 2);
4307 pathB.close();
4308 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4309}
4310
4311static void cubics8d(skiatest::Reporter* reporter, const char* filename) {
4312 SkPath path, pathB;
4313 path.setFillType(SkPath::kWinding_FillType);
4314 path.moveTo(2, 5);
4315 path.cubicTo(2, 4, 5, 1, 3, 2);
4316 path.close();
4317 pathB.setFillType(SkPath::kWinding_FillType);
4318 pathB.moveTo(1, 5);
4319 pathB.cubicTo(2, 3, 5, 2, 4, 2);
4320 pathB.close();
4321 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4322}
4323
4324static void cubics9d(skiatest::Reporter* reporter, const char* filename) {
4325 SkPath path, pathB;
4326 path.setFillType(SkPath::kWinding_FillType);
4327 path.moveTo(2, 4);
4328 path.cubicTo(2, 6, 3, 1, 5, 1);
4329 path.close();
4330 pathB.setFillType(SkPath::kWinding_FillType);
4331 pathB.moveTo(1, 3);
4332 pathB.cubicTo(1, 5, 4, 2, 6, 2);
4333 pathB.close();
4334 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4335}
4336
4337static void cubics10u(skiatest::Reporter* reporter, const char* filename) {
4338 SkPath path, pathB;
4339 path.setFillType(SkPath::kWinding_FillType);
4340 path.moveTo(2, 4);
4341 path.cubicTo(1, 6, 4, 1, 5, 1);
4342 path.close();
4343 pathB.setFillType(SkPath::kWinding_FillType);
4344 pathB.moveTo(1, 4);
4345 pathB.cubicTo(1, 5, 4, 2, 6, 1);
4346 pathB.close();
4347 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
4348}
4349
4350static void cubics11i(skiatest::Reporter* reporter, const char* filename) {
4351 SkPath path, pathB;
4352 path.setFillType(SkPath::kWinding_FillType);
4353 path.moveTo(2, 4);
4354 path.cubicTo(2, 5, 3, 2, 5, 1);
4355 path.close();
4356 pathB.setFillType(SkPath::kWinding_FillType);
4357 pathB.moveTo(2, 3);
4358 pathB.cubicTo(1, 5, 4, 2, 5, 2);
4359 pathB.close();
4360 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4361}
4362
4363static void cubics12d(skiatest::Reporter* reporter, const char* filename) {
4364 SkPath path, pathB;
4365 path.setFillType(SkPath::kWinding_FillType);
4366 path.moveTo(2, 4);
4367 path.cubicTo(0, 4, 5, 3, 5, 1);
4368 path.close();
4369 pathB.setFillType(SkPath::kWinding_FillType);
4370 pathB.moveTo(3, 5);
4371 pathB.cubicTo(1, 5, 4, 2, 4, 0);
4372 pathB.close();
4373 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4374}
4375
4376static void cubics13d(skiatest::Reporter* reporter, const char* filename) {
4377 SkPath path, pathB;
4378 path.setFillType(SkPath::kWinding_FillType);
4379 path.moveTo(2, 3);
4380 path.cubicTo(1, 5, 4, 2, 5, 2);
4381 path.close();
4382 pathB.setFillType(SkPath::kWinding_FillType);
4383 pathB.moveTo(2, 4);
4384 pathB.cubicTo(2, 5, 3, 2, 5, 1);
4385 pathB.close();
4386 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4387}
4388
4389static void cubics14d(skiatest::Reporter* reporter, const char* filename) {
4390 SkPath path, pathB;
4391 path.setFillType(SkPath::kWinding_FillType);
4392 path.moveTo(2, 3);
4393 path.cubicTo(0, 4, 3, 1, 3, 0);
4394 path.close();
4395 pathB.setFillType(SkPath::kWinding_FillType);
4396 pathB.moveTo(1, 3);
4397 pathB.cubicTo(0, 3, 3, 2, 4, 0);
4398 pathB.close();
4399 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4400}
4401
4402static void cubics15d(skiatest::Reporter* reporter, const char* filename) {
4403 SkPath path, pathB;
4404 path.setFillType(SkPath::kWinding_FillType);
4405 path.moveTo(1, 5);
4406 path.cubicTo(3, 5, 4, 0, 4, 2);
4407 path.close();
4408 pathB.setFillType(SkPath::kWinding_FillType);
4409 pathB.moveTo(0, 4);
4410 pathB.cubicTo(2, 4, 5, 1, 5, 3);
4411 pathB.close();
4412 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4413}
4414
4415static void cubics16i(skiatest::Reporter* reporter, const char* filename) {
4416 SkPath path, pathB;
4417 path.setFillType(SkPath::kWinding_FillType);
4418 path.moveTo(1, 5);
4419 path.cubicTo(2, 5, 5, 0, 4, 2);
4420 path.close();
4421 pathB.setFillType(SkPath::kWinding_FillType);
4422 pathB.moveTo(0, 5);
4423 pathB.cubicTo(2, 4, 5, 1, 5, 2);
4424 pathB.close();
4425 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4426}
4427
4428static void cubics17d(skiatest::Reporter* reporter, const char* filename) {
4429 SkPath path, pathB;
4430 path.setFillType(SkPath::kWinding_FillType);
4431 path.moveTo(1, 5);
4432 path.cubicTo(3, 4, 4, 1, 4, 2);
4433 path.close();
4434 pathB.setFillType(SkPath::kWinding_FillType);
4435 pathB.moveTo(1, 4);
4436 pathB.cubicTo(2, 4, 5, 1, 4, 3);
4437 pathB.close();
4438 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4439}
4440
4441static void cubics18d(skiatest::Reporter* reporter, const char* filename) {
4442 SkPath path, pathB;
4443 path.setFillType(SkPath::kWinding_FillType);
4444 path.moveTo(1, 5);
4445 path.cubicTo(1, 3, 4, 0, 2, 0);
4446 path.close();
4447 pathB.setFillType(SkPath::kWinding_FillType);
4448 pathB.moveTo(0, 4);
4449 pathB.cubicTo(0, 2, 5, 1, 3, 1);
4450 pathB.close();
4451 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4452}
4453
4454static void cubics19d(skiatest::Reporter* reporter, const char* filename) {
4455 SkPath path, pathB;
4456 path.setFillType(SkPath::kWinding_FillType);
4457 path.moveTo(1, 5);
4458 path.cubicTo(2, 3, 5, 2, 4, 2);
4459 path.close();
4460 pathB.setFillType(SkPath::kWinding_FillType);
4461 pathB.moveTo(2, 5);
4462 pathB.cubicTo(2, 4, 5, 1, 3, 2);
4463 pathB.close();
4464 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4465}
4466
4467static void cubicOp157(skiatest::Reporter* reporter, const char* filename) {
4468 SkPath path, pathB;
4469 path.setFillType(SkPath::kWinding_FillType);
4470 path.moveTo(1,5);
4471 path.cubicTo(1,3, 6,2, 4,2);
4472 path.close();
4473 pathB.setFillType(SkPath::kWinding_FillType);
4474 pathB.moveTo(2,6);
4475 pathB.cubicTo(2,4, 5,1, 3,1);
4476 pathB.close();
4477 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4478}
4479
4480static void cubics20d(skiatest::Reporter* reporter, const char* filename) {
4481 SkPath path, pathB;
4482 path.setFillType(SkPath::kWinding_FillType);
4483 path.moveTo(1, 2);
4484 path.cubicTo(0, 3, 6, 0, 3, 2);
4485 path.close();
4486 pathB.setFillType(SkPath::kWinding_FillType);
4487 pathB.moveTo(0, 6);
4488 pathB.cubicTo(2, 3, 2, 1, 3, 0);
4489 pathB.close();
4490 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4491}
4492
4493static void loops20i(skiatest::Reporter* reporter, const char* filename) {
4494 SkPath path, pathB;
4495 path.setFillType(SkPath::kWinding_FillType);
4496 path.moveTo(1, 2);
4497 path.cubicTo(0, 2, 0.833333313f, 2, 1, 3.66666651f);
4498 path.close();
4499 pathB.setFillType(SkPath::kWinding_FillType);
4500 pathB.moveTo(0, 2);
4501 pathB.cubicTo(0.833333313f, 2, 1, 3.66666651f, 1, 2);
4502 pathB.close();
4503 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4504}
4505
4506static void loops21i(skiatest::Reporter* reporter, const char* filename) {
4507 SkPath path, pathB;
4508 path.setFillType(SkPath::kWinding_FillType);
4509 path.moveTo(1, 2);
4510 path.cubicTo(0, 2, 0.833333313f, 2, 1, 4);
4511 path.close();
4512 pathB.setFillType(SkPath::kWinding_FillType);
4513 pathB.moveTo(0, 2);
4514 pathB.cubicTo(0.833333313f, 2, 1, 4, 1, 2);
4515 pathB.close();
4516 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4517}
4518
4519static void loops22i(skiatest::Reporter* reporter, const char* filename) {
4520 SkPath path, pathB;
4521 path.setFillType(SkPath::kWinding_FillType);
4522 path.moveTo(1, 3);
4523 path.cubicTo(0, 3, 0.833333313f, 3, 1, 4.66666651f);
4524 path.close();
4525 pathB.setFillType(SkPath::kWinding_FillType);
4526 pathB.moveTo(0, 3);
4527 pathB.cubicTo(0.833333313f, 3, 1, 4.66666651f, 1, 3);
4528 pathB.close();
4529 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4530}
4531
4532static void loops23i(skiatest::Reporter* reporter, const char* filename) {
4533 SkPath path, pathB;
4534 path.setFillType(SkPath::kWinding_FillType);
4535 path.moveTo(1, 5);
4536 path.cubicTo(0, 1, 6.16666698f, 5.66666698f, -5.66666651f, 6.66666651f);
4537 path.close();
4538 pathB.setFillType(SkPath::kWinding_FillType);
4539 pathB.moveTo(0, 1);
4540 pathB.cubicTo(6.16666698f, 5.66666698f, -5.66666651f, 6.66666651f, 1, 5);
4541 pathB.close();
4542 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4543}
4544
4545static void loops24i(skiatest::Reporter* reporter, const char* filename) {
4546 SkPath path, pathB;
4547 path.setFillType(SkPath::kWinding_FillType);
4548 path.moveTo(1, 2);
4549 path.cubicTo(0, 2, 0.833333313f, 2, 1, 3);
4550 path.close();
4551 pathB.setFillType(SkPath::kWinding_FillType);
4552 pathB.moveTo(0, 2);
4553 pathB.cubicTo(0.833333313f, 2, 1, 3, 1, 2);
4554 pathB.close();
4555 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4556}
4557
4558static void loops25i(skiatest::Reporter* reporter, const char* filename) {
4559 SkPath path, pathB;
4560 path.setFillType(SkPath::kWinding_FillType);
4561 path.moveTo(1, 5);
4562 path.cubicTo(0, 5, 0.833333313f, 5, 1, 7);
4563 path.close();
4564 pathB.setFillType(SkPath::kWinding_FillType);
4565 pathB.moveTo(0, 5);
4566 pathB.cubicTo(0.833333313f, 5, 1, 7, 1, 5);
4567 pathB.close();
4568 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4569}
4570
4571static void loops26i(skiatest::Reporter* reporter, const char* filename) {
4572 SkPath path, pathB;
4573 path.setFillType(SkPath::kWinding_FillType);
4574 path.moveTo(1, 6);
4575 path.cubicTo(0, 2, 6.16666698f, 6.66666698f, -5.66666651f, 7.66666651f);
4576 path.close();
4577 pathB.setFillType(SkPath::kWinding_FillType);
4578 pathB.moveTo(0, 2);
4579 pathB.cubicTo(6.16666698f, 6.66666698f, -5.66666651f, 7.66666651f, 1, 6);
4580 pathB.close();
4581 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4582}
4583
4584static void loops27i(skiatest::Reporter* reporter, const char* filename) {
4585 SkPath path, pathB;
4586 path.setFillType(SkPath::kWinding_FillType);
4587 path.moveTo(1, 3);
4588 path.cubicTo(0, 3, 0.833333313f, 3, 1, 4.33333349f);
4589 path.close();
4590 pathB.setFillType(SkPath::kWinding_FillType);
4591 pathB.moveTo(0, 3);
4592 pathB.cubicTo(0.833333313f, 3, 1, 4.33333349f, 1, 3);
4593 pathB.close();
4594 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4595}
4596
4597static void loops28i(skiatest::Reporter* reporter, const char* filename) {
4598 SkPath path, pathB;
4599 path.setFillType(SkPath::kWinding_FillType);
4600 path.moveTo(2, 3);
4601 path.cubicTo(1, 3, 1.83333337f, 3, 2, 4.66666651f);
4602 path.close();
4603 pathB.setFillType(SkPath::kWinding_FillType);
4604 pathB.moveTo(1, 3);
4605 pathB.cubicTo(1.83333337f, 3, 2, 4.66666651f, 2, 3);
4606 pathB.close();
4607 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4608}
4609
4610static void loops29i(skiatest::Reporter* reporter, const char* filename) {
4611 SkPath path, pathB;
4612 path.setFillType(SkPath::kWinding_FillType);
4613 path.moveTo(2, 4);
4614 path.cubicTo(0, 4, 1.66666663f, 4, 2, 7.33333302f);
4615 path.close();
4616 pathB.setFillType(SkPath::kWinding_FillType);
4617 pathB.moveTo(0, 4);
4618 pathB.cubicTo(1.66666663f, 4, 2, 7.33333302f, 2, 4);
4619 pathB.close();
4620 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4621}
4622
4623static void loops30i(skiatest::Reporter* reporter, const char* filename) {
4624 SkPath path, pathB;
4625 path.setFillType(SkPath::kWinding_FillType);
4626 path.moveTo(2, 4);
4627 path.cubicTo(0, 4, 1.66666663f, 4, 2, 8);
4628 path.close();
4629 pathB.setFillType(SkPath::kWinding_FillType);
4630 pathB.moveTo(0, 4);
4631 pathB.cubicTo(1.66666663f, 4, 2, 8, 2, 4);
4632 pathB.close();
4633 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4634}
4635
4636static void loops31i(skiatest::Reporter* reporter, const char* filename) {
4637 SkPath path, pathB;
4638 path.setFillType(SkPath::kWinding_FillType);
4639 path.moveTo(2, 5);
4640 path.cubicTo(1, 5, 1.83333337f, 5, 2, 6.66666651f);
4641 path.close();
4642 pathB.setFillType(SkPath::kWinding_FillType);
4643 pathB.moveTo(1, 5);
4644 pathB.cubicTo(1.83333337f, 5, 2, 6.66666651f, 2, 5);
4645 pathB.close();
4646 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4647}
4648
4649static void loops32i(skiatest::Reporter* reporter, const char* filename) {
4650 SkPath path, pathB;
4651 path.setFillType(SkPath::kWinding_FillType);
4652 path.moveTo(2, 6);
4653 path.cubicTo(1, 6, 1.83333337f, 6, 2, 8);
4654 path.close();
4655 pathB.setFillType(SkPath::kWinding_FillType);
4656 pathB.moveTo(1, 6);
4657 pathB.cubicTo(1.83333337f, 6, 2, 8, 2, 6);
4658 pathB.close();
4659 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4660}
4661
4662static void loops33i(skiatest::Reporter* reporter, const char* filename) {
4663 SkPath path, pathB;
4664 path.setFillType(SkPath::kWinding_FillType);
4665 path.moveTo(2, 6);
4666 path.cubicTo(1, 2, 7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f);
4667 path.close();
4668 pathB.setFillType(SkPath::kWinding_FillType);
4669 pathB.moveTo(1, 2);
4670 pathB.cubicTo(7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f, 2, 6);
4671 pathB.close();
4672 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4673}
4674
4675static void loops33iMod(skiatest::Reporter* reporter, const char* filename) {
4676 SkPoint pts[] = {{2, 6}, {1, 2}, {7.16666698f, 6.66666698f}, {-4.66666651f, 7.66666651f},
4677 {1, 2}, {7.16666698f, 6.66666698f}, {-4.66666651f, 7.66666651f}, {2, 6}};
4678 bool up = false;
4679 float offset = 0.0380172729f;
4680 float step = 7.62939453e-006f;
4681 bool lastResult = true;
4682 // for (int i = 0; i < 30; ++i) {
4683 SkString name(filename);
4684 // name.appendS32(i);
4685 // if (i > 0) {
4686 // SkDebugf("\n\n<div id=\"%s\">\n", name.c_str());
4687 // }
4688 pts[5].fY = 6.66666698f + offset;
4689 SkPath path, pathB;
4690 path.setFillType(SkPath::kWinding_FillType);
4691 path.moveTo(pts[0]);
4692 path.cubicTo(pts[1], pts[2], pts[3]);
4693 path.close();
4694 pathB.setFillType(SkPath::kWinding_FillType);
4695 pathB.moveTo(pts[4]);
4696 pathB.cubicTo(pts[5], pts[6], pts[7]);
4697 pathB.close();
4698 bool result = testPathOp(reporter, path, pathB, kIntersect_SkPathOp, name.c_str());
4699 if (lastResult != result) {
4700 up = !up;
4701 }
4702 step /= 2;
4703 offset += up ? step : -step;
4704 lastResult = result;
4705 // }
4706}
4707
4708
4709static void loops33iAsQuads(skiatest::Reporter* reporter, const char* filename) {
4710 SkPath path, pathB;
4711 path.setFillType(SkPath::kWinding_FillType);
4712 path.moveTo(2, 6);
4713 path.cubicTo(1, 2, 7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f);
4714 path.close();
4715 pathB.setFillType(SkPath::kWinding_FillType);
4716 pathB.moveTo(1, 2);
4717 pathB.cubicTo(7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f, 2, 6);
4718 pathB.close();
4719 SkPath qPath, qPathB;
4720 CubicPathToQuads(path, &qPath);
4721 CubicPathToQuads(pathB, &qPathB);
4722 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename);
4723}
4724
4725static void loops34i(skiatest::Reporter* reporter, const char* filename) {
4726 SkPath path, pathB;
4727 path.setFillType(SkPath::kWinding_FillType);
4728 path.moveTo(3, 4);
4729 path.cubicTo(0, 4, 2.5f, 4, 3, 9);
4730 path.close();
4731 pathB.setFillType(SkPath::kWinding_FillType);
4732 pathB.moveTo(0, 4);
4733 pathB.cubicTo(2.5f, 4, 3, 9, 3, 4);
4734 pathB.close();
4735 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4736}
4737
4738static void loops35i(skiatest::Reporter* reporter, const char* filename) {
4739 SkPath path, pathB;
4740 path.setFillType(SkPath::kWinding_FillType);
4741 path.moveTo(3, 4);
4742 path.cubicTo(0, 4, 2.5f, 4, 3, 10);
4743 path.close();
4744 pathB.setFillType(SkPath::kWinding_FillType);
4745 pathB.moveTo(0, 4);
4746 pathB.cubicTo(2.5f, 4, 3, 10, 3, 4);
4747 pathB.close();
4748 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4749}
4750
4751static void loops36i(skiatest::Reporter* reporter, const char* filename) {
4752 SkPath path, pathB;
4753 path.setFillType(SkPath::kWinding_FillType);
4754 path.moveTo(3, 4);
4755 path.cubicTo(1, 4, 2.66666675f, 4, 3, 8);
4756 path.close();
4757 pathB.setFillType(SkPath::kWinding_FillType);
4758 pathB.moveTo(1, 4);
4759 pathB.cubicTo(2.66666675f, 4, 3, 8, 3, 4);
4760 pathB.close();
4761 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4762}
4763
4764static void loops37i(skiatest::Reporter* reporter, const char* filename) {
4765 SkPath path, pathB;
4766 path.setFillType(SkPath::kWinding_FillType);
4767 path.moveTo(2, 4);
4768 path.cubicTo(1, 4, 1.83333337f, 4, 2, 5.33333349f);
4769 path.close();
4770 pathB.setFillType(SkPath::kWinding_FillType);
4771 pathB.moveTo(1, 4);
4772 pathB.cubicTo(1.83333337f, 4, 2, 5.33333349f, 2, 4);
4773 pathB.close();
4774 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4775}
4776
4777static void loops38i(skiatest::Reporter* reporter, const char* filename) {
4778 SkPath path, pathB;
4779 path.setFillType(SkPath::kWinding_FillType);
4780 path.moveTo(3, 4);
4781 path.cubicTo(2, 4, 2.83333325f, 4, 3, 6);
4782 path.close();
4783 pathB.setFillType(SkPath::kWinding_FillType);
4784 pathB.moveTo(2, 4);
4785 pathB.cubicTo(2.83333325f, 4, 3, 6, 3, 4);
4786 pathB.close();
4787 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4788}
4789
4790static void loops39i(skiatest::Reporter* reporter, const char* filename) {
4791 SkPath path, pathB;
4792 path.setFillType(SkPath::kWinding_FillType);
4793 path.moveTo(3, 5);
4794 path.cubicTo(0, 5, 2.5f, 5, 3, 10);
4795 path.close();
4796 pathB.setFillType(SkPath::kWinding_FillType);
4797 pathB.moveTo(0, 5);
4798 pathB.cubicTo(2.5f, 5, 3, 10, 3, 5);
4799 pathB.close();
4800 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4801}
4802
4803static void loops40i(skiatest::Reporter* reporter, const char* filename) {
4804 SkPath path, pathB;
4805 path.setFillType(SkPath::kWinding_FillType);
4806 path.moveTo(3, 5);
4807 path.cubicTo(0, 5, 2.5f, 5, 3, 11);
4808 path.close();
4809 pathB.setFillType(SkPath::kWinding_FillType);
4810 pathB.moveTo(0, 5);
4811 pathB.cubicTo(2.5f, 5, 3, 11, 3, 5);
4812 pathB.close();
4813 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4814}
4815
4816static void loops40iAsQuads(skiatest::Reporter* reporter, const char* filename) {
4817 SkPath path, pathB;
4818 path.setFillType(SkPath::kWinding_FillType);
4819 path.moveTo(3, 5);
4820 path.cubicTo(0, 5, 2.5f, 5, 3, 11);
4821 path.close();
4822 pathB.setFillType(SkPath::kWinding_FillType);
4823 pathB.moveTo(0, 5);
4824 pathB.cubicTo(2.5f, 5, 3, 11, 3, 5);
4825 pathB.close();
4826 SkPath qPath, qPathB;
4827 CubicPathToQuads(path, &qPath);
4828 CubicPathToQuads(pathB, &qPathB);
4829 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename);
4830}
4831
4832static void loops44i(skiatest::Reporter* reporter, const char* filename) {
4833 SkPath path, pathB;
4834 path.setFillType(SkPath::kWinding_FillType);
4835 path.moveTo(1, 5);
4836 path.cubicTo(0, 1, 7.33333302f, 5.33333349f, -7, 7);
4837 path.close();
4838 pathB.setFillType(SkPath::kWinding_FillType);
4839 pathB.moveTo(0, 1);
4840 pathB.cubicTo(7.33333302f, 5.33333349f, -7, 7, 1, 5);
4841 pathB.close();
4842 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4843}
4844
4845static void loops45i(skiatest::Reporter* reporter, const char* filename) {
4846 SkPath path, pathB;
4847 path.setFillType(SkPath::kWinding_FillType);
4848 path.moveTo(1, 6);
4849 path.cubicTo(0, 2, 7.33333302f, 6.33333302f, -7, 8);
4850 path.close();
4851 pathB.setFillType(SkPath::kWinding_FillType);
4852 pathB.moveTo(0, 2);
4853 pathB.cubicTo(7.33333302f, 6.33333302f, -7, 8, 1, 6);
4854 pathB.close();
4855 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4856}
4857
4858static void loops46i(skiatest::Reporter* reporter, const char* filename) {
4859 SkPath path, pathB;
4860 path.setFillType(SkPath::kWinding_FillType);
4861 path.moveTo(2, 6);
4862 path.cubicTo(1, 2, 8.33333302f, 6.33333302f, -6, 8);
4863 path.close();
4864 pathB.setFillType(SkPath::kWinding_FillType);
4865 pathB.moveTo(1, 2);
4866 pathB.cubicTo(8.33333302f, 6.33333302f, -6, 8, 2, 6);
4867 pathB.close();
4868 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4869}
4870
4871/*
4872FAILED: d:\cygwin\puregit\tests\pathopsextendedtest.cpp:346 0 */
4873static void loops47i(skiatest::Reporter* reporter, const char* filename) {
4874 SkPath path, pathB;
4875 path.setFillType(SkPath::kWinding_FillType);
4876 path.moveTo(2, 4);
4877 path.cubicTo(0, 1, 6, 5.83333302f, -4, 8);
4878 path.close();
4879 pathB.setFillType(SkPath::kWinding_FillType);
4880 pathB.moveTo(0, 1);
4881 pathB.cubicTo(6, 5.83333302f, -4, 8, 2, 4);
4882 pathB.close();
4883 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4884}
4885
4886static void loops48i(skiatest::Reporter* reporter, const char* filename) {
4887 SkPath path, pathB;
4888 path.setFillType(SkPath::kWinding_FillType);
4889 path.moveTo(2, 6);
4890 path.cubicTo(0, 1, 9.33333302f, 6.83333302f, -8.33333302f, 9.16666603f);
4891 path.close();
4892 pathB.setFillType(SkPath::kWinding_FillType);
4893 pathB.moveTo(0, 1);
4894 pathB.cubicTo(9.33333302f, 6.83333302f, -8.33333302f, 9.16666603f, 2, 6);
4895 pathB.close();
4896 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4897}
4898
4899static void loops49i(skiatest::Reporter* reporter, const char* filename) {
4900 SkPath path, pathB;
4901 path.setFillType(SkPath::kWinding_FillType);
4902 path.moveTo(0, 2);
4903 path.cubicTo(1, 4, -0.166666687f, 2.66666675f, 1.66666675f, 2);
4904 path.close();
4905 pathB.setFillType(SkPath::kWinding_FillType);
4906 pathB.moveTo(1, 4);
4907 pathB.cubicTo(-0.166666687f, 2.66666675f, 1.66666675f, 2, 0, 2);
4908 pathB.close();
4909 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4910}
4911
4912static void loops50i(skiatest::Reporter* reporter, const char* filename) {
4913 SkPath path, pathB;
4914 path.setFillType(SkPath::kWinding_FillType);
4915 path.moveTo(0, 3);
4916 path.cubicTo(1, 5, -0.166666687f, 3.66666675f, 1.66666675f, 3);
4917 path.close();
4918 pathB.setFillType(SkPath::kWinding_FillType);
4919 pathB.moveTo(1, 5);
4920 pathB.cubicTo(-0.166666687f, 3.66666675f, 1.66666675f, 3, 0, 3);
4921 pathB.close();
4922 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4923}
4924
4925static void loops51i(skiatest::Reporter* reporter, const char* filename) {
4926 SkPath path, pathB;
4927 path.setFillType(SkPath::kWinding_FillType);
4928 path.moveTo(1, 2);
4929 path.cubicTo(2, 4, 0.833333313f, 2.66666675f, 2.66666675f, 2);
4930 path.close();
4931 pathB.setFillType(SkPath::kWinding_FillType);
4932 pathB.moveTo(2, 4);
4933 pathB.cubicTo(0.833333313f, 2.66666675f, 2.66666675f, 2, 1, 2);
4934 pathB.close();
4935 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4936}
4937
4938static void loops52i(skiatest::Reporter* reporter, const char* filename) {
4939 SkPath path, pathB;
4940 path.setFillType(SkPath::kWinding_FillType);
4941 path.moveTo(1, 3);
4942 path.cubicTo(2, 5, 0.833333313f, 3.66666675f, 2.66666675f, 3);
4943 path.close();
4944 pathB.setFillType(SkPath::kWinding_FillType);
4945 pathB.moveTo(2, 5);
4946 pathB.cubicTo(0.833333313f, 3.66666675f, 2.66666675f, 3, 1, 3);
4947 pathB.close();
4948 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4949}
4950
4951static void loops53i(skiatest::Reporter* reporter, const char* filename) {
4952 SkPath path, pathB;
4953 path.setFillType(SkPath::kWinding_FillType);
4954 path.moveTo(2, 3);
4955 path.cubicTo(3, 5, 1.83333325f, 3.66666675f, 3.66666651f, 3);
4956 path.close();
4957 pathB.setFillType(SkPath::kWinding_FillType);
4958 pathB.moveTo(3, 5);
4959 pathB.cubicTo(1.83333325f, 3.66666675f, 3.66666651f, 3, 2, 3);
4960 pathB.close();
4961 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4962}
4963
4964static void loops54i(skiatest::Reporter* reporter, const char* filename) {
4965 SkPath path, pathB;
4966 path.setFillType(SkPath::kWinding_FillType);
4967 path.moveTo(0, 2);
4968 path.cubicTo(1, 4, 0, 3, 1.66666675f, 2);
4969 path.close();
4970 pathB.setFillType(SkPath::kWinding_FillType);
4971 pathB.moveTo(1, 4);
4972 pathB.cubicTo(0, 3, 1.66666675f, 2, 0, 2);
4973 pathB.close();
4974 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4975}
4976
4977static void loops55i(skiatest::Reporter* reporter, const char* filename) {
4978 SkPath path, pathB;
4979 path.setFillType(SkPath::kWinding_FillType);
4980 path.moveTo(0, 3);
4981 path.cubicTo(1, 5, 0, 4, 1.66666675f, 3);
4982 path.close();
4983 pathB.setFillType(SkPath::kWinding_FillType);
4984 pathB.moveTo(1, 5);
4985 pathB.cubicTo(0, 4, 1.66666675f, 3, 0, 3);
4986 pathB.close();
4987 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4988}
4989
4990static void loops56i(skiatest::Reporter* reporter, const char* filename) {
4991 SkPath path, pathB;
4992 path.setFillType(SkPath::kWinding_FillType);
4993 path.moveTo(1, 2);
4994 path.cubicTo(2, 4, 0.99999994f, 3, 2.66666675f, 2);
4995 path.close();
4996 pathB.setFillType(SkPath::kWinding_FillType);
4997 pathB.moveTo(2, 4);
4998 pathB.cubicTo(0.99999994f, 3, 2.66666675f, 2, 1, 2);
4999 pathB.close();
5000 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5001}
5002
5003static void loops57i(skiatest::Reporter* reporter, const char* filename) {
5004 SkPath path, pathB;
5005 path.setFillType(SkPath::kWinding_FillType);
5006 path.moveTo(1, 3);
5007 path.cubicTo(2, 5, 0.99999994f, 4, 2.66666675f, 3);
5008 path.close();
5009 pathB.setFillType(SkPath::kWinding_FillType);
5010 pathB.moveTo(2, 5);
5011 pathB.cubicTo(0.99999994f, 4, 2.66666675f, 3, 1, 3);
5012 pathB.close();
5013 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5014}
5015
5016static void loops58i(skiatest::Reporter* reporter, const char* filename) {
5017 SkPath path, pathB;
5018 path.setFillType(SkPath::kWinding_FillType);
5019 path.moveTo(2, 3);
5020 path.cubicTo(3, 5, 2, 4, 3.66666651f, 3);
5021 path.close();
5022 pathB.setFillType(SkPath::kWinding_FillType);
5023 pathB.moveTo(3, 5);
5024 pathB.cubicTo(2, 4, 3.66666651f, 3, 2, 3);
5025 pathB.close();
5026 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5027}
5028
5029static void loops58iAsQuads(skiatest::Reporter* reporter, const char* filename) {
5030 SkPath path, pathB;
5031 path.setFillType(SkPath::kWinding_FillType);
5032 path.moveTo(2, 3);
5033 path.cubicTo(3, 5, 2, 4, 3.66666651f, 3);
5034 path.close();
5035 pathB.setFillType(SkPath::kWinding_FillType);
5036 pathB.moveTo(3, 5);
5037 pathB.cubicTo(2, 4, 3.66666651f, 3, 2, 3);
5038 pathB.close();
5039 SkPath qPath, qPathB;
5040 CubicPathToQuads(path, &qPath);
5041 CubicPathToQuads(pathB, &qPathB);
5042// SkPoint from = {2.61714339f,1.90228665f};
5043// SkPoint to = {2.617045833359139f,1.9013528935803314f};
5044// path_edit(from, to, &qPathB);
5045 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename);
5046}
5047
5048static void loops59i(skiatest::Reporter* reporter, const char* filename) {
5049 SkPath path, pathB;
5050 path.setFillType(SkPath::kWinding_FillType);
5051 path.moveTo(0, 6);
5052 path.cubicTo(1, 2, 7.33333302f, 1.66666663f, -7.5f, 2);
5053 path.close();
5054 pathB.setFillType(SkPath::kWinding_FillType);
5055 pathB.moveTo(1, 2);
5056 pathB.cubicTo(7.33333302f, 1.66666663f, -7.5f, 2, 0, 6);
5057 pathB.close();
5058 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5059}
5060
5061static void loops59iasQuads(skiatest::Reporter* reporter, const char* filename) {
5062 SkPath path, pathB;
5063 path.setFillType(SkPath::kWinding_FillType);
5064 path.moveTo(0, 6);
5065 path.cubicTo(1, 2, 7.33333302f, 1.66666663f, -7.5f, 2);
5066 path.close();
5067 pathB.setFillType(SkPath::kWinding_FillType);
5068 pathB.moveTo(1, 2);
5069 pathB.cubicTo(7.33333302f, 1.66666663f, -7.5f, 2, 0, 6);
5070 pathB.close();
5071 SkPath qPath, qPathB;
5072 CubicPathToQuads(path, &qPath);
5073 CubicPathToQuads(pathB, &qPathB);
5074 SkPoint from = {2.61714339f,1.90228665f};
5075 SkPoint to = {2.617045833359139f,1.9013528935803314f};
5076 path_edit(from, to, &qPathB);
5077 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename);
5078}
5079
5080static void cubics41d(skiatest::Reporter* reporter, const char* filename) {
5081 SkPath path, pathB;
5082 path.setFillType(SkPath::kWinding_FillType);
5083 path.moveTo(0, 1);
5084 path.cubicTo(1, 4, 3, 0, 3, 1);
5085 path.close();
5086 pathB.setFillType(SkPath::kWinding_FillType);
5087 pathB.moveTo(0, 3);
5088 pathB.cubicTo(1, 3, 1, 0, 4, 1);
5089 pathB.close();
5090 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5091}
5092
5093void loops61i(skiatest::Reporter* reporter, const char* filename) {
5094 SkPath path, pathB;
5095 path.setFillType(SkPath::kWinding_FillType);
5096 path.moveTo(0, 1);
5097 path.cubicTo(1, 5, -6.33333302f, 0.666666627f, 8, -1);
5098 path.close();
5099 pathB.setFillType(SkPath::kWinding_FillType);
5100 pathB.moveTo(1, 5);
5101 pathB.cubicTo(-6.33333302f, 0.666666627f, 8, -1, 0, 1);
5102 pathB.close();
5103 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5104}
5105
5106static void loops62i(skiatest::Reporter* reporter, const char* filename) {
5107 SkPath path, pathB;
5108 path.setFillType(SkPath::kWinding_FillType);
5109 path.moveTo(0, 2);
5110 path.cubicTo(1, 6, -6.33333302f, 1.66666663f, 8, 0);
5111 path.close();
5112 pathB.setFillType(SkPath::kWinding_FillType);
5113 pathB.moveTo(1, 6);
5114 pathB.cubicTo(-6.33333302f, 1.66666663f, 8, 0, 0, 2);
5115 pathB.close();
5116 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5117}
5118
5119static void loops63i(skiatest::Reporter* reporter, const char* filename) {
5120 SkPath path, pathB;
5121 path.setFillType(SkPath::kWinding_FillType);
5122 path.moveTo(0, 1);
5123 path.cubicTo(2, 4, -4, -0.833333254f, 6, -3);
5124 path.close();
5125 pathB.setFillType(SkPath::kWinding_FillType);
5126 pathB.moveTo(2, 4);
5127 pathB.cubicTo(-4, -0.833333254f, 6, -3, 0, 1);
5128 pathB.close();
5129 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5130}
5131
5132static void cubics44d(skiatest::Reporter* reporter, const char* filename) {
5133 SkPath path, pathB;
5134 path.setFillType(SkPath::kWinding_FillType);
5135 path.moveTo(3, 4);
5136 path.cubicTo(2, 5, 3, 1, 6, 2);
5137 path.close();
5138 pathB.setFillType(SkPath::kWinding_FillType);
5139 pathB.moveTo(1, 3);
5140 pathB.cubicTo(2, 6, 4, 3, 5, 2);
5141 pathB.close();
5142 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5143}
5144
5145static void cubics45u(skiatest::Reporter* reporter, const char* filename) {
5146 SkPath path, pathB;
5147 path.setFillType(SkPath::kWinding_FillType);
5148 path.moveTo(1, 3);
5149 path.cubicTo(2, 6, 4, 3, 5, 2);
5150 path.close();
5151 pathB.setFillType(SkPath::kWinding_FillType);
5152 pathB.moveTo(3, 4);
5153 pathB.cubicTo(2, 5, 3, 1, 6, 2);
5154 pathB.close();
5155 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
5156}
5157
5158static void fuzz38(skiatest::Reporter* reporter, const char* filename) {
5159 SkPath path, pathB;
5160 path.moveTo(100.34f, 303.312f);
5161 path.lineTo(-1e+08, 303.312f);
5162 path.lineTo(102, 310.156f);
5163 path.lineTo(100.34f, 310.156f);
5164 path.lineTo(100.34f, 303.312f);
5165 path.close();
5166 testPathOpCheck(reporter, path, pathB, kUnion_SkPathOp, filename, true);
5167}
5168
5169static void crbug_526025(skiatest::Reporter* reporter, const char* filename) {
5170 SkPath path;
5171 path.setFillType((SkPath::FillType) 1);
5172path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0xcf000000)); // 360, -2.14748e+09f
5173path.cubicTo(SkBits2Float(0x4e0d628f), SkBits2Float(0xceffffff), SkBits2Float(0x4e800003), SkBits2Float(0xcec6b143), SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffc)); // 5.93012e+08f, -2.14748e+09f, 1.07374e+09f, -1.66675e+09f, 1.07374e+09f, -1.07374e+09f
5174path.cubicTo(SkBits2Float(0x4e800002), SkBits2Float(0xcde53aee), SkBits2Float(0x4e0d6292), SkBits2Float(0xc307820e), SkBits2Float(0x44627d00), SkBits2Float(0x437ffff2)); // 1.07374e+09f, -4.80731e+08f, 5.93012e+08f, -135.508f, 905.953f, 256
5175path.lineTo(SkBits2Float(0x444bf3bc), SkBits2Float(0x4460537e)); // 815.808f, 897.305f
5176path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f
5177path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000)); // 32, 16
5178path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000)); // 100, 512
5179path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f
5180path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000)); // 360, 1024
5181path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140
5182
5183 SkPath path1(path);
5184 path.reset();
5185 path.setFillType((SkPath::FillType) 0);
5186path.moveTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321
5187path.lineTo(SkBits2Float(0x45d5c000), SkBits2Float(0x43870000)); // 6840, 270
5188path.lineTo(SkBits2Float(0xd0a00000), SkBits2Float(0x4cbebc20)); // -2.14748e+10f, 1e+08
5189path.lineTo(SkBits2Float(0x451f7000), SkBits2Float(0x42800000)); // 2551, 64
5190path.lineTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321
5191path.close();
5192
5193 SkPath path2(path);
5194 testPathOp(reporter, path1, path2, (SkPathOp) 2, filename);
5195}
5196
5197static void fuzzX_392(skiatest::Reporter* reporter, const char* filename) {
5198 SkPath path;
5199 path.setFillType(SkPath::kEvenOdd_FillType);
5200path.moveTo(SkBits2Float(0x41e80000), SkBits2Float(0x43bde212)); // 29, 379.766f
5201path.lineTo(SkBits2Float(0x41e80000), SkBits2Float(0x43bdc7ef)); // 29, 379.562f
5202path.conicTo(SkBits2Float(0x42a5861e), SkBits2Float(0x43c61f86), SkBits2Float(0x430b0610), SkBits2Float(0x43c61f86), SkBits2Float(0x3f7d23f3)); // 82.7619f, 396.246f, 139.024f, 396.246f, 0.98883f
5203path.conicTo(SkBits2Float(0x42a58e20), SkBits2Float(0x43c61f86), SkBits2Float(0x41e80000), SkBits2Float(0x43bde212), SkBits2Float(0x3f7d2cf5)); // 82.7776f, 396.246f, 29, 379.766f, 0.988967f
5204path.close();
5205
5206 SkPath path1(path);
5207 path.setFillType(SkPath::kWinding_FillType);
5208path.moveTo(SkBits2Float(0xc36c7bd8), SkBits2Float(0xc3a31d72)); // -236.484f, -326.23f
5209path.lineTo(SkBits2Float(0xc367a4ae), SkBits2Float(0xc3a31d72)); // -231.643f, -326.23f
5210path.lineTo(SkBits2Float(0x430b0610), SkBits2Float(0x43c61f86)); // 139.024f, 396.246f
5211path.lineTo(SkBits2Float(0xc36c7bd8), SkBits2Float(0x43c61f86)); // -236.484f, 396.246f
5212
5213 SkPath path2(path);
5214 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename);
5215}
5216
5217static void dean2(skiatest::Reporter* reporter, const char* filename) {
5218 SkPath path;
5219 path.setFillType((SkPath::FillType) 0);
5220path.moveTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5221path.cubicTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b), SkBits2Float(0x41531912), SkBits2Float(0x3f130322), SkBits2Float(0x4154a02b), SkBits2Float(0x3f2b74b3)); // 0.669749f, 13.2891f, 13.1936f, 0.574267f, 13.2891f, 0.669749f
5222path.cubicTo(SkBits2Float(0x414a835a), SkBits2Float(0x3ec07ba6), SkBits2Float(0x413fcc0d), SkBits2Float(0x3e193319), SkBits2Float(0x4134a02b), SkBits2Float(0x00000000)); // 12.6571f, 0.375943f, 11.9873f, 0.149609f, 11.2891f, 0
5223path.lineTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5224path.close();
5225 SkPath path1(path);
5226
5227 path.reset();
5228 path.setFillType((SkPath::FillType) 0);
5229path.moveTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5230path.cubicTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b), SkBits2Float(0x41531912), SkBits2Float(0x3f130322), SkBits2Float(0x4154a02b), SkBits2Float(0x3f2b74b3)); // 0.669749f, 13.2891f, 13.1936f, 0.574267f, 13.2891f, 0.669749f
5231path.lineTo(SkBits2Float(0x417ab74b), SkBits2Float(0x4154a02b)); // 15.6697f, 13.2891f
5232path.lineTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5233path.close();
5234 SkPath path2(path);
5235 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename);
5236}
5237
5238static void cubics_d(skiatest::Reporter* reporter, const char* filename) {
5239 SkPath path, pathB;
5240 path.setFillType(SkPath::kWinding_FillType);
5241 path.moveTo(0, 1);
5242 path.cubicTo(3, 5, 1, 0, 3, 0);
5243 path.close();
5244 pathB.setFillType(SkPath::kWinding_FillType);
5245 pathB.moveTo(0, 1);
5246 pathB.cubicTo(0, 3, 1, 0, 5, 3);
5247 pathB.close();
5248 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5249}
5250
5251static void cubics_d2(skiatest::Reporter* reporter, const char* filename) {
5252 SkPath path, pathB;
5253 path.setFillType(SkPath::kWinding_FillType);
5254 path.moveTo(0, 1);
5255 path.cubicTo(2, 5, 2, 0, 2, 1);
5256 path.close();
5257 pathB.setFillType(SkPath::kWinding_FillType);
5258 pathB.moveTo(0, 2);
5259 pathB.cubicTo(1, 2, 1, 0, 5, 2);
5260 pathB.close();
5261 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5262}
5263
5264static void loops_i1(skiatest::Reporter* reporter, const char* filename) {
5265 SkPath path, pathB;
5266 path.setFillType(SkPath::kWinding_FillType);
5267 path.moveTo(2, 3);
5268 path.cubicTo(0, 4, -0.333333343f, 4.66666651f, 3, 5.83333349f);
5269 path.close();
5270 pathB.setFillType(SkPath::kWinding_FillType);
5271 pathB.moveTo(0, 4);
5272 pathB.cubicTo(-0.333333343f, 4.66666651f, 3, 5.83333349f, 2, 3);
5273 pathB.close();
5274 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5275}
5276
5277static void loops_i2(skiatest::Reporter* reporter, const char* filename) {
5278 SkPath path, pathB;
5279 path.setFillType(SkPath::kWinding_FillType);
5280 path.moveTo(2, 4);
5281 path.cubicTo(0, 5, -0.333333343f, 5.66666651f, 3, 6.83333302f);
5282 path.close();
5283 pathB.setFillType(SkPath::kWinding_FillType);
5284 pathB.moveTo(0, 5);
5285 pathB.cubicTo(-0.333333343f, 5.66666651f, 3, 6.83333302f, 2, 4);
5286 pathB.close();
5287 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5288}
5289
5290static void loops_i3(skiatest::Reporter* reporter, const char* filename) {
5291 SkPath path, pathB;
5292 path.setFillType(SkPath::kWinding_FillType);
5293 path.moveTo(2, 5);
5294 path.cubicTo(0, 6, -0.333333343f, 6.66666651f, 3, 7.83333302f);
5295 path.close();
5296 pathB.setFillType(SkPath::kWinding_FillType);
5297 pathB.moveTo(0, 6);
5298 pathB.cubicTo(-0.333333343f, 6.66666651f, 3, 7.83333302f, 2, 5);
5299 pathB.close();
5300 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5301}
5302
5303static void loops_i4(skiatest::Reporter* reporter, const char* filename) {
5304 SkPath path, pathB;
5305 path.setFillType(SkPath::kWinding_FillType);
5306 path.moveTo(3, 4);
5307 path.cubicTo(1, 5, 0.666666627f, 5.66666651f, 4, 6.83333302f);
5308 path.close();
5309 pathB.setFillType(SkPath::kWinding_FillType);
5310 pathB.moveTo(1, 5);
5311 pathB.cubicTo(0.666666627f, 5.66666651f, 4, 6.83333302f, 3, 4);
5312 pathB.close();
5313 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5314}
5315
5316static void loops_i5(skiatest::Reporter* reporter, const char* filename) {
5317 SkPath path, pathB;
5318 path.setFillType(SkPath::kWinding_FillType);
5319 path.moveTo(3, 5);
5320 path.cubicTo(1, 6, 0.666666627f, 6.66666651f, 4, 7.83333302f);
5321 path.close();
5322 pathB.setFillType(SkPath::kWinding_FillType);
5323 pathB.moveTo(1, 6);
5324 pathB.cubicTo(0.666666627f, 6.66666651f, 4, 7.83333302f, 3, 5);
5325 pathB.close();
5326 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5327}
5328
5329static void loops_i6(skiatest::Reporter* reporter, const char* filename) {
5330 SkPath path, pathB;
5331 path.setFillType(SkPath::kWinding_FillType);
5332 path.moveTo(4, 5);
5333 path.cubicTo(2, 6, 1.66666663f, 6.66666651f, 5, 7.83333302f);
5334 path.close();
5335 pathB.setFillType(SkPath::kWinding_FillType);
5336 pathB.moveTo(2, 6);
5337 pathB.cubicTo(1.66666663f, 6.66666651f, 5, 7.83333302f, 4, 5);
5338 pathB.close();
5339 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5340}
5341
5342static void cubics_d3(skiatest::Reporter* reporter, const char* filename) {
5343 SkPath path, pathB;
5344 path.setFillType(SkPath::kWinding_FillType);
5345 path.moveTo(3, 4);
5346 path.cubicTo(0, 6, 6, 1, 4, 2);
5347 path.close();
5348 pathB.setFillType(SkPath::kWinding_FillType);
5349 pathB.moveTo(1, 6);
5350 pathB.cubicTo(2, 4, 4, 3, 6, 0);
5351 pathB.close();
5352 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5353}
5354
5355static void cubics_o(skiatest::Reporter* reporter, const char* filename) {
5356 SkPath path, pathB;
5357 path.setFillType(SkPath::kWinding_FillType);
5358 path.moveTo(1, 4);
5359 path.cubicTo(2, 6, 5, 0, 5, 3);
5360 path.close();
5361 pathB.setFillType(SkPath::kWinding_FillType);
5362 pathB.moveTo(0, 5);
5363 pathB.cubicTo(3, 5, 4, 1, 6, 2);
5364 pathB.close();
5365 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
5366}
5367
5368static void cubicOp158(skiatest::Reporter* reporter, const char* filename) {
5369 SkPath path, pathB;
5370 path.setFillType(SkPath::kWinding_FillType);
5371 path.moveTo(0,1);
5372 path.cubicTo(2,4, 2,0, 2,0);
5373 path.close();
5374 pathB.setFillType(SkPath::kWinding_FillType);
5375 pathB.moveTo(0,2);
5376 pathB.cubicTo(0,2, 1,0, 4,2);
5377 pathB.close();
5378 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5379}
5380
5381static void loop17(skiatest::Reporter* reporter, const char* filename) {
5382 SkPath path, pathB;
5383 path.moveTo(1, 2);
5384 path.cubicTo(0, 3, -0.333333343f, 3.33333325f, 0.833333373f, 3.5f);
5385 path.close();
5386 pathB.moveTo(0, 3);
5387 pathB.cubicTo(-0.333333343f, 3.33333325f, 0.833333373f, 3.5f, 1, 2);
5388 pathB.close();
5389 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5390}
5391
5392static void circlesOp4(skiatest::Reporter* reporter, const char* filename) {
5393 SkPath path, pathB;
5394 path.setFillType(SkPath::kWinding_FillType);
5395 path.addCircle(0, 1, 5, SkPath::kCW_Direction);
5396 pathB.setFillType(SkPath::kWinding_FillType);
5397 pathB.addCircle(0, 1, 0, SkPath::kCW_Direction);
5398 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5399}
5400
5401static void bug5240(skiatest::Reporter* reporter, const char* filename) {
5402 SkPath path;
5403path.moveTo(815, 82);
5404path.cubicTo(814.4794311523438f, 82.7868881225586f, 814.5330810546875f,
540582.6266555786133f, 814.5291137695312f, 82.6252212524414f);
5406path.cubicTo(814.5229492187500f, 82.6230010986328f, 814.3790283203125f,
540783.0008087158203f, 813.8533935546875f, 82.7072601318359f);
5408path.close();
5409 testPathOp(reporter, path, path, kUnion_SkPathOp, filename);
5410}
5411
5412static void android1(skiatest::Reporter* reporter, const char* filename) {
5413 SkPath path, pathB;
5414path.moveTo(SkBits2Float(0xc0a00000), SkBits2Float(0x00000000)); // -5, 0
5415path.lineTo(SkBits2Float(0x44866000), SkBits2Float(0x00000000)); // 1075, 0
5416path.lineTo(SkBits2Float(0x44866000), SkBits2Float(0x43720000)); // 1075, 242
5417path.lineTo(SkBits2Float(0xc0a00000), SkBits2Float(0x43720000)); // -5, 242
5418path.lineTo(SkBits2Float(0xc0a00000), SkBits2Float(0x00000000)); // -5, 0
5419path.close();
5420pathB.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
5421pathB.lineTo(SkBits2Float(0x44870000), SkBits2Float(0x00000000)); // 1080, 0
5422pathB.lineTo(SkBits2Float(0x44870000), SkBits2Float(0x43720000)); // 1080, 242
5423pathB.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x43720000)); // 0, 242
5424pathB.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
5425pathB.close();
5426 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5427}
5428
5429
5430static void (*skipTest)(skiatest::Reporter* , const char* filename) = 0;
5431static void (*firstTest)(skiatest::Reporter* , const char* filename) = 0;
5432static void (*stopTest)(skiatest::Reporter* , const char* filename) = 0;
5433
5434#define TEST(name) { name, #name }
5435
5436static struct TestDesc tests[] = {
5437 TEST(android1),
5438 TEST(bug5240),
5439 TEST(circlesOp4),
5440 TEST(loop17),
5441 TEST(cubicOp158),
5442 TEST(loops_i1),
5443 TEST(loops_i2),
5444 TEST(loops_i3),
5445 TEST(loops_i4),
5446 TEST(loops_i5),
5447 TEST(loops_i6),
5448 TEST(cubics_d3),
5449 TEST(cubics_o),
5450 TEST(cubics_d2),
5451 TEST(cubics_d),
5452 TEST(dean2),
5453 TEST(fuzzX_392),
5454 TEST(crbug_526025),
5455 TEST(fuzz38),
5456 TEST(cubics44d),
5457 TEST(cubics45u),
5458 TEST(loops61i),
5459 TEST(loops62i),
5460 TEST(loops63i),
5461 TEST(loops58iAsQuads),
5462 TEST(cubics41d),
5463 TEST(loops59iasQuads),
5464 TEST(loops59i),
5465 TEST(loops44i),
5466 TEST(loops45i),
5467 TEST(loops46i),
5468 TEST(loops47i),
5469 TEST(loops48i),
5470 TEST(loops49i),
5471 TEST(loops50i),
5472 TEST(loops51i),
5473 TEST(loops52i),
5474 TEST(loops53i),
5475 TEST(loops54i),
5476 TEST(loops55i),
5477 TEST(loops56i),
5478 TEST(loops57i),
5479 TEST(loops58i),
5480 TEST(loops33iMod),
5481 TEST(loops33iAsQuads),
5482 TEST(loops33i),
5483 TEST(loops40i),
5484 TEST(loops40iAsQuads),
5485 TEST(loops39i),
5486 TEST(loops38i),
5487 TEST(loops37i),
5488 TEST(loops36i),
5489 TEST(loops35i),
5490 TEST(loops34i),
5491 TEST(loops32i),
5492 TEST(loops31i),
5493 TEST(loops30i),
5494 TEST(loops29i),
5495 TEST(loops28i),
5496 TEST(loops27i),
5497 TEST(loops26i),
5498 TEST(loops25i),
5499 TEST(loops24i),
5500 TEST(loops23i),
5501 TEST(loops22i),
5502 TEST(loops21i),
5503 TEST(loops20i),
5504 TEST(cubics20d),
5505 TEST(cubics6d),
5506 TEST(cubics7d),
5507 TEST(cubics8d),
5508 TEST(cubics9d),
5509 TEST(cubics10u),
5510 TEST(cubics11i),
5511 TEST(cubics12d),
5512 TEST(cubics13d),
5513 TEST(cubics14d),
5514 TEST(cubics15d),
5515 TEST(cubics16i),
5516 TEST(cubics17d),
5517 TEST(cubics18d),
5518 TEST(cubics19d),
5519 TEST(cubicOp157),
5520 TEST(cubicOp142),
5521 TEST(loops4i),
5522 TEST(quadRect1),
5523 TEST(quadRect2),
5524 TEST(quadRect3),
5525 TEST(quadRect4),
5526 TEST(quadRect5),
5527 TEST(quadRect6),
5528 TEST(cubicOp141),
5529 TEST(cubicOp58d),
5530 TEST(loops5i),
5531 TEST(cubicOp140),
5532 TEST(cubicOp139),
5533 TEST(cubics138),
5534 TEST(cubics137),
5535 TEST(cubicOp136a),
5536 TEST(cubicOp136),
5537 TEST(cubicOp135),
5538 TEST(cubicOp134),
5539 TEST(cubicOp133),
5540 TEST(loop12),
5541 TEST(cubicOp132),
5542 TEST(loop11),
5543 TEST(loop10),
5544 TEST(circlesOp3),
5545 TEST(loop9),
5546 TEST(loop8),
5547 TEST(rects5),
5548 TEST(loop7),
5549 TEST(cubicOp130a),
5550 TEST(rRect1x),
5551 TEST(circlesOp2),
5552 TEST(circlesOp1),
5553 TEST(cubicOp131),
5554 TEST(cubicOp130),
5555 TEST(cubicOp129),
5556 TEST(cubicOp128),
5557 TEST(cubicOp127),
5558 TEST(cubicOp126),
5559 TEST(cubicOp125),
5560 TEST(cubicOp124),
5561 TEST(loop6),
5562 TEST(loop5),
5563 TEST(cubicOp123),
5564 TEST(cubicOp122),
5565 TEST(cubicOp121),
5566 TEST(cubicOp120),
5567 TEST(cubicOp119),
5568 TEST(loop4),
5569 TEST(loop3),
5570 TEST(loop2),
5571 TEST(loop1asQuad),
5572 TEST(loop1),
5573 TEST(issue3517),
5574 TEST(cubicOp118),
5575 TEST(cubicOp117),
5576 TEST(cubicOp116),
5577 TEST(testRect2),
5578 TEST(testRect1),
5579 TEST(cubicOp115),
5580 TEST(issue2753),
5581 TEST(cubicOp114),
5582 TEST(issue2808),
5583 TEST(cubicOp114asQuad),
5584 TEST(rects4),
5585 TEST(rects3),
5586 TEST(rects2),
5587 TEST(rects1),
5588 TEST(issue2540),
5589 TEST(issue2504),
5590 TEST(kari1),
5591 TEST(quadOp10i),
5592 TEST(cubicOp113),
5593 TEST(skpcarrot_is24),
5594 TEST(issue1417),
5595 TEST(cubicOp112),
5596 TEST(skpadspert_net23),
5597 TEST(skpadspert_de11),
5598 TEST(findFirst1),
5599 TEST(xOp2i),
5600 TEST(xOp3i),
5601 TEST(xOp1u),
5602 TEST(xOp1i),
5603 TEST(cubicOp111),
5604 TEST(cubicOp110),
5605 TEST(cubicOp109),
5606 TEST(cubicOp108),
5607 TEST(cubicOp107),
5608 TEST(cubicOp106),
5609 TEST(cubicOp105),
5610 TEST(cubicOp104),
5611 TEST(cubicOp103),
5612 TEST(cubicOp102),
5613 TEST(cubicOp101),
5614 TEST(cubicOp100),
5615 TEST(cubicOp99),
5616 TEST(issue1435),
5617 TEST(cubicOp98x),
5618 TEST(cubicOp97x),
5619 TEST(skpcarpetplanet_ru22),
5620 TEST(cubicOp96d),
5621 TEST(cubicOp95u),
5622 TEST(skpadbox_lt15),
5623 TEST(skpagentxsites_com55),
5624 TEST(skpadventistmission_org572),
5625 TEST(skpadoption_org196),
5626 TEST(skpbambootheme_com12),
5627 TEST(skpbakosoft_com10),
5628 TEST(skpakmmos_ru100),
5629 TEST(skpbangalorenest_com4),
5630 TEST(skpbingoentertainment_net189),
5631 TEST(skpbestred_ru37),
5632 TEST(skpbenzoteh_ru152),
5633 TEST(skpcamcorder_kz21),
5634 TEST(skpcaffelavazzait_com_ua21),
5635 TEST(skpcarrefour_ro62),
5636 TEST(skpcavablar_net563),
5637 TEST(skpinsomnia_gr72),
5638 TEST(skpadbox_lt8),
5639 TEST(skpact_com43),
5640 TEST(skpacesoftech_com47),
5641 TEST(skpabcspark_ca103),
5642 TEST(cubicOp94u),
5643 TEST(cubicOp93d),
5644 TEST(cubicOp92i),
5645 TEST(skpadithya_putr4_blogspot_com551),
5646 TEST(skpadindex_de4),
5647 TEST(skpaiaigames_com870),
5648 TEST(skpaaalgarve_org53),
5649 TEST(skpkkiste_to716),
5650 TEST(cubicOp91u),
5651 TEST(cubicOp90u),
5652 TEST(cubicOp89u),
5653 TEST(cubicOp88u),
5654 TEST(cubicOp87u),
5655 TEST(cubicOp86i),
5656 TEST(loopEdge2),
5657 TEST(loopEdge1),
5658 TEST(rectOp3x),
5659 TEST(rectOp2i),
5660 TEST(rectOp1i),
5661 TEST(issue1418b),
5662 TEST(cubicOp85i),
5663 TEST(issue1418),
5664 TEST(skpkkiste_to98),
5665 TEST(skpahrefs_com29),
5666 TEST(cubicOp85d),
5667 TEST(skpahrefs_com88),
5668 TEST(skphealth_com76),
5669 TEST(skpancestry_com1),
5670 TEST(skpbyte_com1),
5671 TEST(skpeldorado_com_ua1),
5672 TEST(skp96prezzi1),
5673 TEST(skpClip2),
5674 TEST(skpClip1),
5675 TEST(cubicOp84d),
5676 TEST(cubicOp83i),
5677 TEST(cubicOp82i),
5678 TEST(cubicOp81d),
5679 TEST(cubicOp80i),
5680 TEST(cubicOp79u),
5681 TEST(cubicOp78u),
5682 TEST(cubicOp77i),
5683 TEST(cubicOp76u),
5684 TEST(cubicOp75d),
5685 TEST(cubicOp74d),
5686 TEST(cubicOp73d),
5687 TEST(cubicOp72i),
5688 TEST(cubicOp71d),
5689 TEST(skp5),
5690 TEST(skp4),
5691 TEST(skp3),
5692 TEST(skp2),
5693 TEST(skp1),
5694 TEST(rRect1),
5695 TEST(cubicOp70d),
5696 TEST(cubicOp69d),
5697 TEST(cubicOp68u),
5698 TEST(cubicOp67u),
5699 TEST(cubicOp66u),
5700 TEST(rectOp1d),
5701 TEST(cubicOp65d),
5702 TEST(cubicOp64d),
5703 TEST(cubicOp63d),
5704 TEST(cubicOp62d),
5705 TEST(cubicOp61d),
5706 TEST(cubicOp60d),
5707 TEST(cubicOp59d),
5708 TEST(cubicOp57d),
5709 TEST(cubicOp56d),
5710 TEST(cubicOp55d),
5711 TEST(cubicOp54d),
5712 TEST(cubicOp53d),
5713 TEST(cubicOp52d),
5714 TEST(cubicOp51d),
5715 TEST(cubicOp50d),
5716 TEST(cubicOp49d),
5717 TEST(cubicOp48d),
5718 TEST(cubicOp47d),
5719 TEST(cubicOp46d),
5720 TEST(cubicOp45d),
5721 TEST(cubicOp44d),
5722 TEST(cubicOp43d),
5723 TEST(cubicOp42d),
5724 TEST(cubicOp41i),
5725 TEST(cubicOp40d),
5726 TEST(cubicOp39d),
5727 TEST(cubicOp38d),
5728 TEST(cubicOp37d),
5729 TEST(cubicOp36u),
5730 TEST(cubicOp35d),
5731 TEST(cubicOp34d),
5732 TEST(cubicOp33i),
5733 TEST(cubicOp32d),
5734 TEST(cubicOp31d),
5735 TEST(cubicOp31x),
5736 TEST(cubicOp31u),
5737 TEST(cubicOp30d),
5738 TEST(cubicOp29d),
5739 TEST(cubicOp28u),
5740 TEST(cubicOp27d),
5741 TEST(cubicOp26d),
5742 TEST(cubicOp25i),
5743 TEST(testOp8d),
5744 TEST(testDiff1),
5745 TEST(testIntersect1),
5746 TEST(testUnion1),
5747 TEST(testXor1),
5748 TEST(testDiff2),
5749 TEST(testIntersect2),
5750 TEST(testUnion2),
5751 TEST(testXor2),
5752 TEST(testOp1d),
5753 TEST(testOp2d),
5754 TEST(testOp3d),
5755 TEST(testOp1u),
5756 TEST(testOp4d),
5757 TEST(testOp5d),
5758 TEST(testOp6d),
5759 TEST(testOp7d),
5760 TEST(testOp2u),
5761
5762 TEST(cubicOp24d),
5763 TEST(cubicOp23d),
5764 TEST(cubicOp22d),
5765 TEST(cubicOp21d),
5766 TEST(cubicOp20d),
5767 TEST(cubicOp19i),
5768 TEST(cubicOp18d),
5769 TEST(cubicOp17d),
5770 TEST(cubicOp16d),
5771 TEST(cubicOp15d),
5772 TEST(cubicOp14d),
5773 TEST(cubicOp13d),
5774 TEST(cubicOp12d),
5775 TEST(cubicOp11d),
5776 TEST(cubicOp10d),
5777 TEST(cubicOp1i),
5778 TEST(cubicOp9d),
5779 TEST(quadOp9d),
5780 TEST(lineOp9d),
5781 TEST(cubicOp8d),
5782 TEST(cubicOp7d),
5783 TEST(cubicOp6d),
5784 TEST(cubicOp5d),
5785 TEST(cubicOp3d),
5786 TEST(cubicOp2d),
5787 TEST(cubicOp1d),
5788};
5789
5790static const size_t testCount = SK_ARRAY_COUNT(tests);
5791
5792static struct TestDesc subTests[] = {
5793 TEST(loops47i),
5794 TEST(loops61i),
5795 TEST(loops62i),
5796 TEST(issue3517),
5797};
5798
5799static const size_t subTestCount = SK_ARRAY_COUNT(subTests);
5800
5801static void (*firstSubTest)(skiatest::Reporter* , const char* filename) = nullptr;
5802
5803static bool runSubTests = false;
5804static bool runSubTestsFirst = true;
5805static bool runReverse = false;
5806
5807DEF_TEST(PathOpsOp, reporter) {
5808#if DEBUG_SHOW_TEST_NAME
5809 strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH);
5810#endif
5811 if (runSubTests && runSubTestsFirst) {
5812 RunTestSet(reporter, subTests, subTestCount, firstSubTest, nullptr, stopTest, runReverse);
5813 }
5814 RunTestSet(reporter, tests, testCount, firstTest, skipTest, stopTest, runReverse);
5815 if (runSubTests && !runSubTestsFirst) {
5816 RunTestSet(reporter, subTests, subTestCount, firstSubTest, nullptr, stopTest, runReverse);
5817 }
5818}
5819
5820static void fuzz535151(skiatest::Reporter* reporter, const char* filename) {
5821 SkPath one;
5822 one.setFillType(SkPath::kWinding_FillType);
5823 SkPath two;
5824 two.setFillType(SkPath::kWinding_FillType);
5825 two.moveTo(0, 0);
5826 two.lineTo(0, 50);
5827 two.lineTo(4.29497e+09f, 50);
5828 SkPath dummy;
5829 testPathOpFuzz(reporter, one, two, kIntersect_SkPathOp, filename);
5830}
5831
5832static void bufferOverflow(skiatest::Reporter* reporter, const char* filename) {
5833 SkPath path;
5834 path.addRect(0,0, 300,170141183460469231731687303715884105728.f);
5835 SkPath pathB;
5836 pathB.addRect(0,0, 300,16);
5837 testPathOpFuzz(reporter, path, pathB, kUnion_SkPathOp, filename);
5838}
5839
5840// m 100,0 60,170 -160,-110 200,0 -170,11000000000 z
5841static void fuzz433(skiatest::Reporter* reporter, const char* filename) {
5842 SkPath path1, path2;
5843 path1.moveTo(100,0);
5844 path1.lineTo(60,170);
5845 path1.lineTo(-160,-110);
5846 path1.lineTo(200,0);
5847 path1.lineTo(-170,11000000000.0f);
5848 path1.close();
5849
5850 path2.moveTo(100 + 20,0 + 20);
5851 path2.lineTo(60 + 20,170 + 20);
5852 path2.lineTo(-160 + 20,-110 + 20);
5853 path2.lineTo(200 + 20,0 + 20);
5854 path2.lineTo(-170 + 20,11000000000.0f + 20);
5855 path2.close();
5856
5857 testPathOpFuzz(reporter, path1, path2, kIntersect_SkPathOp, filename);
5858}
5859
5860static void fuzz433b(skiatest::Reporter* reporter, const char* filename) {
5861 SkPath path1, path2;
5862 path1.setFillType(SkPath::kEvenOdd_FillType);
5863 path1.moveTo(140, 40);
5864 path1.lineTo(200, 210);
5865 path1.lineTo(40, 100);
5866 path1.lineTo(240, 100);
5867 path1.lineTo(70, 1.1e+10f);
5868 path1.lineTo(140, 40);
5869 path1.close();
5870
5871 path1.setFillType(SkPath::kWinding_FillType);
5872 path2.moveTo(190, 60);
5873 path2.lineTo(250, 230);
5874 path2.lineTo(90, 120);
5875 path2.lineTo(290, 120);
5876 path2.lineTo(120, 1.1e+10f);
5877 path2.lineTo(190, 60);
5878 path2.close();
5879
5880 testPathOpFuzz(reporter, path1, path2, kUnion_SkPathOp, filename);
5881}
5882
5883static void fuzz487a(skiatest::Reporter* reporter, const char* filename) {
5884 SkPath path;
5885 path.setFillType((SkPath::FillType) 0);
5886path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5887path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
5888path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333));
5889path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc));
5890path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff));
5891path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
5892path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
5893path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000));
5894path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000));
5895path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000));
5896path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
5897path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
5898path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000));
5899path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5900path.close();
5901
5902 SkPath path1(path);
5903 path.reset();
5904 path.setFillType((SkPath::FillType) 0);
5905path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5906path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
5907path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a));
5908path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a));
5909path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd));
5910path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000));
5911path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a));
5912path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333));
5913path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000));
5914path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000));
5915path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a));
5916path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334));
5917path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd));
5918path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd));
5919path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd));
5920path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334));
5921path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000));
5922path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5923path.close();
5924
5925 SkPath path2(path);
5926 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
5927}
5928
5929static void fuzz487b(skiatest::Reporter* reporter, const char* filename) {
5930 SkPath path;
5931 path.setFillType((SkPath::FillType) 0);
5932path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5933path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
5934path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333));
5935path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc));
5936path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff));
5937path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
5938path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
5939path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000));
5940path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000));
5941path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000));
5942path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
5943path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
5944path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000));
5945path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5946path.close();
5947
5948 SkPath path1(path);
5949 path.reset();
5950 path.setFillType((SkPath::FillType) 0);
5951path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5952path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
5953path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a));
5954path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a));
5955path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd));
5956path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000));
5957path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a));
5958path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333));
5959path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000));
5960path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000));
5961path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a));
5962path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334));
5963path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd));
5964path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd));
5965path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd));
5966path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334));
5967path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000));
5968path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5969path.close();
5970
5971 SkPath path2(path);
5972 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
5973}
5974
5975static void fuzz714(skiatest::Reporter* reporter, const char* filename) {
5976 SkPath path;
5977 path.setFillType((SkPath::FillType) 1);
5978path.moveTo(SkBits2Float(0x430c0000), SkBits2Float(0x42200000));
5979path.lineTo(SkBits2Float(0x43480000), SkBits2Float(0x43520000));
5980path.lineTo(SkBits2Float(0x42200000), SkBits2Float(0x42c80000));
5981path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x42c80000)); // 2.22222e+022f
5982path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x43520000)); // 2.22222e+022f
5983path.lineTo(SkBits2Float(0x430c0000), SkBits2Float(0x42200000));
5984path.close();
5985
5986 SkPath path1(path);
5987 path.reset();
5988 path.setFillType((SkPath::FillType) 0);
5989path.moveTo(SkBits2Float(0x43200000), SkBits2Float(0x42700000));
5990path.lineTo(SkBits2Float(0x435c0000), SkBits2Float(0x43660000));
5991path.lineTo(SkBits2Float(0x42700000), SkBits2Float(0x42f00000));
5992path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x42f00000)); // 2.22222e+022f
5993path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x43660000)); // 2.22222e+022f
5994path.lineTo(SkBits2Float(0x43200000), SkBits2Float(0x42700000));
5995path.close();
5996
5997 SkPath path2(path);
5998 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
5999}
6000
6001static void fuzz1(skiatest::Reporter* reporter, const char* filename) {
6002 SkPath path;
6003 path.setFillType((SkPath::FillType) 0);
6004path.moveTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
6005path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
6006path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
6007path.quadTo(SkBits2Float(0xffc00000), SkBits2Float(0x7f800000), SkBits2Float(0xffc00000), SkBits2Float(0x7f800000));
6008path.quadTo(SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000));
6009path.quadTo(SkBits2Float(0xff000001), SkBits2Float(0xffc00000), SkBits2Float(0xffc00000), SkBits2Float(0xffc00000));
6010path.quadTo(SkBits2Float(0xffc00000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xff000001));
6011path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xffc00000));
6012path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0xffc00000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
6013path.close();
6014
6015 SkPath path1(path);
6016 path.reset();
6017 path.setFillType((SkPath::FillType) 0);
6018
6019 SkPath path2(path);
6020 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
6021}
6022
6023
6024static void fuzz753_91(skiatest::Reporter* reporter, const char* filename) {
6025 SkPath path;
6026 path.setFillType((SkPath::FillType) 0);
6027path.moveTo(SkBits2Float(0x42910000), SkBits2Float(0x00000000)); // 72.5f, 0
6028path.lineTo(SkBits2Float(0x42166668), SkBits2Float(0x00000000)); // 37.6f, 0
6029path.cubicTo(SkBits2Float(0x42166668), SkBits2Float(0xc1966668), SkBits2Float(0x41c66668), SkBits2Float(0xc20a6666), SkBits2Float(0x40f00010), SkBits2Float(0xc21ccccd)); // 37.6f, -18.8f, 24.8f, -34.6f, 7.50001f, -39.2f
6030path.lineTo(SkBits2Float(0x41840004), SkBits2Float(0xc291cccd)); // 16.5f, -72.9f
6031path.lineTo(SkBits2Float(0x42fb6668), SkBits2Float(0x42c73334)); // 125.7f, 99.6f
6032path.lineTo(SkBits2Float(0x43646668), SkBits2Float(0x43880ccd)); // 228.4f, 272.1f
6033
6034 SkPath path1(path);
6035 path.reset();
6036 path.setFillType((SkPath::FillType) 0);
6037path.moveTo(SkBits2Float(0x428bf702), SkBits2Float(0xcf223cbf)); // 69.9824f, -2.72189e+09f
6038path.lineTo(SkBits2Float(0x42112d68), SkBits2Float(0xcf223cbf)); // 36.2943f, -2.72189e+09f
6039path.cubicTo(SkBits2Float(0x4220d9fc), SkBits2Float(0xcf223cc0), SkBits2Float(0x420ee118), SkBits2Float(0xcf223cc0), SkBits2Float(0x41cef2f8), SkBits2Float(0xcf223cc0)); // 40.2129f, -2.72189e+09f, 35.7198f, -2.72189e+09f, 25.8686f, -2.72189e+09f
6040path.lineTo(SkBits2Float(0x424a99e0), SkBits2Float(0xcf223cc0)); // 50.6503f, -2.72189e+09f
6041path.cubicTo(SkBits2Float(0x42266e32), SkBits2Float(0xcf223cc0), SkBits2Float(0x41f0fa20), SkBits2Float(0xcf223cc0), SkBits2Float(0x41872ed4), SkBits2Float(0xcf223cc0)); // 41.6076f, -2.72189e+09f, 30.1221f, -2.72189e+09f, 16.8979f, -2.72189e+09f
6042path.lineTo(SkBits2Float(0x40f8fbe0), SkBits2Float(0xcf223cc0)); // 7.78075f, -2.72189e+09f
6043
6044 SkPath path2(path);
6045 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
6046}
6047
6048static void bug597926_0(skiatest::Reporter* reporter, const char* filename) {
6049SkPath path;
6050path.setFillType((SkPath::FillType) 0);
6051path.moveTo(SkBits2Float(0x43b38000), SkBits2Float(0x433e0000)); // 359, 190
6052path.lineTo(SkBits2Float(0x40c00000), SkBits2Float(0x449ce000)); // 6, 1255
6053path.cubicTo(SkBits2Float(0x438c0000), SkBits2Float(0x4497a000), SkBits2Float(0x43e40000), SkBits2Float(0x44750000), SkBits2Float(0x41000000), SkBits2Float(0x44aa2000)); // 280, 1213, 456, 980, 8, 1361
6054path.moveTo(SkBits2Float(0x43290000), SkBits2Float(0x4431c000)); // 169, 711
6055path.lineTo(SkBits2Float(0xd987d6ba), SkBits2Float(0xd93d0ad4)); // -4.7794e+15f, -3.32567e+15f
6056path.conicTo(SkBits2Float(0x43cc8000), SkBits2Float(0x445b8000), SkBits2Float(0xd888b096), SkBits2Float(0xd9a1ebfa), SkBits2Float(0x3ebcb199)); // 409, 878, -1.20234e+15f, -5.69712e+15f, 0.368542f
6057path.cubicTo(SkBits2Float(0x43c00000), SkBits2Float(0x443a8000), SkBits2Float(0x42380000), SkBits2Float(0x4421c000), SkBits2Float(0x42500000), SkBits2Float(0x448ca000)); // 384, 746, 46, 647, 52, 1125
6058path.quadTo(SkBits2Float(0x43948000), SkBits2Float(0x42ac0000), SkBits2Float(0x43880000), SkBits2Float(0x4487e000)); // 297, 86, 272, 1087
6059SkPath path1(path);
6060path.reset();
6061path.setFillType((SkPath::FillType) 0);
6062path.moveTo(SkBits2Float(0xc51d735c), SkBits2Float(0xc49db029)); // -2519.21f, -1261.51f
6063path.cubicTo(SkBits2Float(0xc51d1dbd), SkBits2Float(0xc49d7a3f), SkBits2Float(0xc51c524a), SkBits2Float(0xc49d1610), SkBits2Float(0xc51d1a96), SkBits2Float(0xc49d86a6)); // -2513.86f, -1259.82f, -2501.14f, -1256.69f, -2513.66f, -1260.21f
6064path.cubicTo(SkBits2Float(0xc51cd471), SkBits2Float(0xc49d54d0), SkBits2Float(0xc51c2e51), SkBits2Float(0xc49d0081), SkBits2Float(0xc51d197b), SkBits2Float(0xc49d7927)); // -2509.28f, -1258.65f, -2498.89f, -1256.02f, -2513.59f, -1259.79f
6065path.quadTo(SkBits2Float(0xc51bf7eb), SkBits2Float(0xc49cf010), SkBits2Float(0xc51ba866), SkBits2Float(0xc49cb9e6)); // -2495.49f, -1255.5f, -2490.52f, -1253.81f
6066path.cubicTo(SkBits2Float(0xc51bac0d), SkBits2Float(0xc49cc50e), SkBits2Float(0xc51c29eb), SkBits2Float(0xc49cfb01), SkBits2Float(0xc51c5bca), SkBits2Float(0xc49d1fa6)); // -2490.75f, -1254.16f, -2498.62f, -1255.84f, -2501.74f, -1256.99f
6067SkPath path2(path);
6068testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
6069}
6070
6071static void fuzz1450_0(skiatest::Reporter* reporter, const char* filename) {
6072SkPath path;
6073path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0xcf000000)); // 360, -2.14748e+09f
6074path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0xcf000000), SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, -2.14748e+09f, 1.07374e+09f, -1.07374e+09f, 0.707107f
6075path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0x43800001), SkBits2Float(0x43348000), SkBits2Float(0x43800001), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, 256, 180.5f, 256, 0.707107f
6076SkPath path1(path);
6077path.reset();
6078path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140
6079path.conicTo(SkBits2Float(0x43b40005), SkBits2Float(0x458a945d), SkBits2Float(0x45610000), SkBits2Float(0x458a945d), SkBits2Float(0x3f3504f3)); // 360, 4434.55f, 3600, 4434.55f, 0.707107f
6080path.conicTo(SkBits2Float(0x45d5bfff), SkBits2Float(0x458a945d), SkBits2Float(0x45d5bfff), SkBits2Float(0x45816000), SkBits2Float(0x3f3504f3)); // 6840, 4434.55f, 6840, 4140, 0.707107f
6081path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000)); // 100, 512
6082path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000)); // 32, 16
6083path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000)); // 360, 1024
6084path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140
6085path.close();
6086SkPath path2(path);
6087testPathOpFuzz(reporter, path1, path2, kUnion_SkPathOp, filename);
6088}
6089
6090static void fuzz1450_1(skiatest::Reporter* reporter, const char* filename) {
6091SkPath path;
6092path.setFillType(SkPath::kEvenOdd_FillType);
6093path.moveTo(SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe)); // 1.07374e+09f, -1.07374e+09f
6094path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0xcf000000), SkBits2Float(0x43b40000), SkBits2Float(0xcf000000), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, -2.14748e+09f, 360, -2.14748e+09f, 0.707107f
6095path.lineTo(SkBits2Float(0x43348000), SkBits2Float(0x43800001)); // 180.5f, 256
6096path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000)); // 32, 16
6097path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000)); // 100, 512
6098path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f
6099path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000)); // 360, 1024
6100path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140
6101path.conicTo(SkBits2Float(0x43b40005), SkBits2Float(0x458a945d), SkBits2Float(0x45610000), SkBits2Float(0x458a945d), SkBits2Float(0x3f3504f3)); // 360, 4434.55f, 3600, 4434.55f, 0.707107f
6102path.conicTo(SkBits2Float(0x45d5bfff), SkBits2Float(0x458a945d), SkBits2Float(0x45d5bfff), SkBits2Float(0x45816000), SkBits2Float(0x3f3504f3)); // 6840, 4434.55f, 6840, 4140, 0.707107f
6103path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f
6104path.lineTo(SkBits2Float(0x43348000), SkBits2Float(0x43800001)); // 180.5f, 256
6105path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0x43800001), SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, 256, 1.07374e+09f, -1.07374e+09f, 0.707107f
6106path.close();
6107SkPath path1(path);
6108path.reset();
6109path.moveTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321
6110path.lineTo(SkBits2Float(0x45d5c000), SkBits2Float(0x43870000)); // 6840, 270
6111path.lineTo(SkBits2Float(0xd0a00000), SkBits2Float(0x4cbebc20)); // -2.14748e+10f, 1e+08
6112path.lineTo(SkBits2Float(0x451f7000), SkBits2Float(0x42800000)); // 2551, 64
6113path.lineTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321
6114path.close();
6115SkPath path2(path);
6116testPathOpFuzz(reporter, path1, path2, kUnion_SkPathOp, filename);
6117}
6118
6119static void fuzz763_9(skiatest::Reporter* reporter, const char* filename) {
6120 SkPath path;
6121 path.setFillType((SkPath::FillType) 1);
6122
6123 SkPath path1(path);
6124 path.reset();
6125 path.setFillType((SkPath::FillType) 0);
6126path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6127path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321), SkBits2Float(0xed7a6a4b), SkBits2Float(0x1f212a8c)); // 2.49282e-13f, 4.78968e-34f, 1.99397e+36f, -4.84373e+27f, 3.41283e-20f
6128path.lineTo(SkBits2Float(0x7bc00321), SkBits2Float(0xed7a6a4b)); // 1.99397e+36f, -4.84373e+27f
6129path.lineTo(SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28)); // 9.4495e-15f, 0.000617492f
6130path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6131path.close();
6132path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6133path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3), SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6)); // -8.10388e-33f, 0.00148185f, 2.25206e-21f, 5.54035e+21f
6134path.moveTo(SkBits2Float(0x29272a81), SkBits2Float(0x2ab03a55)); // 3.71183e-14f, 3.13044e-13f
6135path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a214729), SkBits2Float(0xdf28282a), SkBits2Float(0x8a2f2121)); // 2.22225e-15f, 0.000615227f, -1.2117e+19f, -8.43217e-33f
6136path.quadTo(SkBits2Float(0x373b3a27), SkBits2Float(0x201fc4c1), SkBits2Float(0x27576c2a), SkBits2Float(0x5921c25d)); // 1.11596e-05f, 1.35329e-19f, 2.98959e-15f, 2.8457e+15f
6137path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a214729), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21)); // 2.22225e-15f, 0.000615227f, -1.2117e+19f, 0.00105459f
6138path.cubicTo(SkBits2Float(0x373b3ac5), SkBits2Float(0x201fc422), SkBits2Float(0x523a702a), SkBits2Float(0x27576c51), SkBits2Float(0x5921c25d), SkBits2Float(0x51523a70)); // 1.11598e-05f, 1.35327e-19f, 2.00186e+11f, 2.9896e-15f, 2.8457e+15f, 5.64327e+10f
6139path.quadTo(SkBits2Float(0xd912102a), SkBits2Float(0x284f9a28), SkBits2Float(0xb38a1f30), SkBits2Float(0x3a3ac23a)); // -2.56957e+15f, 1.15242e-14f, -6.4318e-08f, 0.000712428f
6140path.lineTo(SkBits2Float(0xc809272a), SkBits2Float(0x29b02829)); // -140445, 7.82294e-14f
6141
6142 SkPath path2(path);
6143 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
6144}
6145
6146
6147static void fuzz763_4(skiatest::Reporter* reporter, const char* filename) {
6148 SkPath path;
6149 path.setFillType((SkPath::FillType) 1);
6150
6151 SkPath path1(path);
6152 path.reset();
6153 path.setFillType((SkPath::FillType) 0);
6154path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6155path.lineTo(SkBits2Float(0x555b3a2d), SkBits2Float(0x2a212a8c)); // 1.50652e+13f, 1.43144e-13f
6156path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f
6157path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac2b33a)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148544f
6158path.cubicTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6), SkBits2Float(0x295b2d2a), SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c275b)); // 2.25206e-21f, 5.54035e+21f, 4.86669e-14f, 3.19905e+24f, 9.6297e-12f, 2.48963e-13f
6159path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6160path.close();
6161path.moveTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f
6162path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x2a21081f)); // 1.43144e-13f, 1.43025e-13f
6163path.conicTo(SkBits2Float(0xde6a4b7b), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // -4.22068e+18f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121589
6164path.lineTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f
6165path.close();
6166path.moveTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f
6167path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
6168path.lineTo(SkBits2Float(0x2928088c), SkBits2Float(0x2be61d2a)); // 3.73109e-14f, 1.63506e-12f
6169path.conicTo(SkBits2Float(0x2a812a63), SkBits2Float(0x2d292a27), SkBits2Float(0x5568295b), SkBits2Float(0x5b2d2968), SkBits2Float(0x552d6829)); // 2.29444e-13f, 9.6159e-12f, 1.5954e+13f, 4.87407e+16f, 1.19164e+13f
6170path.conicTo(SkBits2Float(0x395b2d5b), SkBits2Float(0x68552768), SkBits2Float(0x555b2df0), SkBits2Float(0x1f722a8c), SkBits2Float(0x082a212a)); // 0.000209024f, 4.02636e+24f, 1.50619e+13f, 5.12807e-20f, 5.11965e-34f
6171path.lineTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f
6172path.close();
6173path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6174path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2147ed7a), SkBits2Float(0x28282a3a), SkBits2Float(0x21df212a), SkBits2Float(0x033a8a3a)); // 6.14991e+25f, 6.77381e-19f, 9.33503e-15f, 1.51198e-18f, 5.48192e-37f
6175
6176 SkPath path2(path);
6177 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
6178}
6179
6180static void fuzz763_3(skiatest::Reporter* reporter, const char* filename) {
6181 SkPath path;
6182 path.setFillType((SkPath::FillType) 1);
6183
6184 SkPath path1(path);
6185 path.reset();
6186 path.setFillType((SkPath::FillType) 0);
6187path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6188path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f
6189path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x295b2d1f), SkBits2Float(0x29685568)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.86669e-14f, 5.15884e-14f
6190path.conicTo(SkBits2Float(0x8c28295b), SkBits2Float(0x1f21212a), SkBits2Float(0xc0032a08), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced)); // -1.29547e-31f, 3.41205e-20f, -2.04944f, 3.04132e+35f, 5.77848e-19f
6191path.moveTo(SkBits2Float(0x25682929), SkBits2Float(0x212a8c5b)); // 2.01367e-16f, 5.7784e-19f
6192path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4a7bc0)); // 4.7323e-37f, 6.11969e+25f
6193path.conicTo(SkBits2Float(0x032108ed), SkBits2Float(0x283a7bc0), SkBits2Float(0x47ed7a6a), SkBits2Float(0x282a3a21), SkBits2Float(0x3a21ff28)); // 4.73239e-37f, 1.03519e-14f, 121589, 9.4495e-15f, 0.000617968f
6194path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.00148185f, 1.50241e-13f, -1.38859e-25f
6195path.lineTo(SkBits2Float(0x295b2d2a), SkBits2Float(0x2d296868)); // 4.86669e-14f, 9.62972e-12f
6196path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6197path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x898ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // 6.14991e+25f, -3.39271e-33f, 4.61198e-19f, 0.00096035f, 121589
6198path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6199path.close();
6200path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6201path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0xb38a281a), SkBits2Float(0x29283ac2)); // -1.2117e+19f, 0.00105459f, -6.43342e-08f, 3.73545e-14f
6202path.moveTo(SkBits2Float(0x962be61d), SkBits2Float(0x432a2927)); // -1.38859e-25f, 170.161f
6203path.conicTo(SkBits2Float(0x3a2a552a), SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x3b3ac527), SkBits2Float(0x1fc42236)); // 0.000649768f, 0.00241343f, 3.71093e-14f, 0.00284989f, 8.30658e-20f
6204path.cubicTo(SkBits2Float(0x27576c2a), SkBits2Float(0x5921c25d), SkBits2Float(0x51503a70), SkBits2Float(0x12102a10), SkBits2Float(0x633a28d9), SkBits2Float(0x29c80927)); // 2.98959e-15f, 2.8457e+15f, 5.58959e+10f, 4.54902e-28f, 3.43404e+21f, 8.88337e-14f
6205path.lineTo(SkBits2Float(0x272927b0), SkBits2Float(0x5b392929)); // 2.3475e-15f, 5.21181e+16f
6206path.moveTo(SkBits2Float(0x3a1127b4), SkBits2Float(0x2921ee3b)); // 0.000553723f, 3.59558e-14f
6207path.cubicTo(SkBits2Float(0x5e215d3b), SkBits2Float(0x7828ee3a), SkBits2Float(0x8e28b03b), SkBits2Float(0x50783be8), SkBits2Float(0x9e0b8a3a), SkBits2Float(0x555b2d68)); // 2.90688e+18f, 1.37053e+34f, -2.07925e-30f, 1.66587e+10f, -7.38718e-21f, 1.50618e+13f
6208path.moveTo(SkBits2Float(0x21081f3f), SkBits2Float(0x9fd4e62a)); // 4.61199e-19f, -9.01663e-20f
6209path.cubicTo(SkBits2Float(0x3a293a2a), SkBits2Float(0x0e3bf0c5), SkBits2Float(0x3b29d42a), SkBits2Float(0x0f217265), SkBits2Float(0x2d5d2921), SkBits2Float(0x5568295b)); // 0.000645551f, 2.31655e-30f, 0.00259138f, 7.95994e-30f, 1.25715e-11f, 1.5954e+13f
6210
6211 SkPath path2(path);
6212 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
6213}
6214
6215static void fuzz763_5(skiatest::Reporter* reporter, const char* filename) {
6216 SkPath path;
6217 path.setFillType((SkPath::FillType) 1);
6218
6219 SkPath path1(path);
6220 path.reset();
6221 path.setFillType((SkPath::FillType) 0);
6222path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
6223path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b79), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f
6224path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
6225path.cubicTo(SkBits2Float(0xe62a2928), SkBits2Float(0x2a63962b), SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x001f2a21)); // -2.0089e+23f, 2.02138e-13f, 3.19905e+24f, 9.6297e-12f, 2.49282e-13f, 2.86201e-39f
6226path.lineTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
6227path.close();
6228path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
6229path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121589
6230path.lineTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
6231path.close();
6232path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
6233path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3b21), SkBits2Float(0x28ee4f9a), SkBits2Float(0x68293b78)); // -1.2117e+19f, 0.00105462f, 2.64578e-14f, 3.19671e+24f
6234path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x5b2d8c55)); // 4.87407e+16f, 4.88495e+16f
6235
6236 SkPath path2(path);
6237 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
6238}
6239
6240static void fuzz763_2(skiatest::Reporter* reporter, const char* filename) {
6241 SkPath path;
6242 path.setFillType((SkPath::FillType) 1);
6243
6244 SkPath path1(path);
6245 path.reset();
6246 path.setFillType((SkPath::FillType) 0);
6247path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6248path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f
6249path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f
6250path.lineTo(SkBits2Float(0x081f2ad7), SkBits2Float(0x7bc00321)); // 4.78977e-34f, 1.99397e+36f
6251path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
6252path.quadTo(SkBits2Float(0x4f1a3a8a), SkBits2Float(0x3ab38a28), SkBits2Float(0x29283ac2), SkBits2Float(0x962be62a)); // 2.58753e+09f, 0.00136978f, 3.73545e-14f, -1.38859e-25f
6253path.cubicTo(SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529), SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x3b3ac527), SkBits2Float(0x1fc42237)); // 2.36623e-15f, 0.000649768f, 0.00241343f, 3.71093e-14f, 0.00284989f, 8.30658e-20f
6254path.cubicTo(SkBits2Float(0x27576c2a), SkBits2Float(0x5921c25d), SkBits2Float(0x51523a70), SkBits2Float(0x12102a10), SkBits2Float(0x633a28d9), SkBits2Float(0x29c80927)); // 2.98959e-15f, 2.8457e+15f, 5.64327e+10f, 4.54902e-28f, 3.43404e+21f, 8.88337e-14f
6255path.lineTo(SkBits2Float(0x29292727), SkBits2Float(0x21475b3b)); // 3.75595e-14f, 6.75446e-19f
6256path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
6257path.cubicTo(SkBits2Float(0x682d2928), SkBits2Float(0x555b6829), SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 3.27091e+24f, 1.50775e+13f, 1.50606e+13f, 1.43144e-13f, 4.7323e-37f, 6.14991e+25f
6258path.conicTo(SkBits2Float(0x295b2ded), SkBits2Float(0x29685568), SkBits2Float(0x8c555b2d), SkBits2Float(0xe61d2a2a), SkBits2Float(0x2a63962b)); // 4.86676e-14f, 5.15884e-14f, -1.64364e-31f, -1.85547e+23f, 2.02138e-13f
6259path.conicTo(SkBits2Float(0x5568295b), SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a), SkBits2Float(0x4b7bc003)); // 1.5954e+13f, 4.87407e+16f, 5.7784e-19f, 4.61198e-19f, 1.64987e+07f
6260path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21)); // 2.50338e-13f, 4.61198e-19f
6261path.conicTo(SkBits2Float(0x6a3a7bc0), SkBits2Float(0x2147ed7a), SkBits2Float(0x28282a3a), SkBits2Float(0x8a3a21df), SkBits2Float(0x27b42a3a)); // 5.63611e+25f, 6.77381e-19f, 9.33503e-15f, -8.96194e-33f, 5.00058e-15f
6262path.conicTo(SkBits2Float(0x2921217d), SkBits2Float(0x5e3a3b35), SkBits2Float(0x7828ee3a), SkBits2Float(0x8e28b03b), SkBits2Float(0x783be82a)); // 3.57782e-14f, 3.35484e+18f, 1.37053e+34f, -2.07925e-30f, 1.52448e+34f
6263path.conicTo(SkBits2Float(0x8e0b8a3a), SkBits2Float(0x279fd4e6), SkBits2Float(0x7a293a2a), SkBits2Float(0x2a0ef0c5), SkBits2Float(0x653b29d4)); // -1.71996e-30f, 4.43622e-15f, 2.19669e+35f, 1.26957e-13f, 5.52409e+22f
6264path.quadTo(SkBits2Float(0x29210f21), SkBits2Float(0x282a085d), SkBits2Float(0xc2ab2127), SkBits2Float(0xa6800028)); // 3.57623e-14f, 9.43871e-15f, -85.5648f, -8.88183e-16f
6265path.lineTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
6266path.close();
6267path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
6268path.quadTo(SkBits2Float(0x216a2770), SkBits2Float(0x2ab73b28), SkBits2Float(0x4b28f427), SkBits2Float(0x283b5b28)); // 7.93345e-19f, 3.25484e-13f, 1.10726e+07f, 1.04004e-14f
6269path.lineTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
6270path.close();
6271path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
6272path.conicTo(SkBits2Float(0xf86d273b), SkBits2Float(0x27e523e3), SkBits2Float(0x2927e0f5), SkBits2Float(0x2ac0e729), SkBits2Float(0x6b492128)); // -1.92402e+34f, 6.35992e-15f, 3.72766e-14f, 3.42665e-13f, 2.43151e+26f
6273path.cubicTo(SkBits2Float(0x2f273927), SkBits2Float(0xa83a2c21), SkBits2Float(0xd7122121), SkBits2Float(0x21212921), SkBits2Float(0x3be3db3a), SkBits2Float(0xa9deb63b)); // 1.52089e-10f, -1.03346e-14f, -1.60671e+14f, 5.46034e-19f, 0.00695362f, -9.89039e-14f
6274
6275 SkPath path2(path);
6276 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
6277}
6278
6279// crbug.com/626164
6280static void fuzz763_1c(skiatest::Reporter* reporter, const char* filename) {
6281 SkPath path;
6282 path.setFillType((SkPath::FillType) 0);
6283
6284 SkPath path1(path);
6285 path.reset();
6286 path.setFillType((SkPath::FillType) 0);
6287 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6288 path.cubicTo(SkBits2Float(0x1931204a), SkBits2Float(0x2ba1a14a), SkBits2Float(0x4a4a08ff), SkBits2Float(0x4a4a08ff), SkBits2Float(0x4a4a4a34), SkBits2Float(0x4a4a4a4a)); // 9.15721e-24f, 1.14845e-12f, 3.31014e+06f, 3.31014e+06f, 3.31432e+06f, 3.31432e+06f
6289 path.moveTo(SkBits2Float(0x000010a1), SkBits2Float(0x19312000)); // 5.96533e-42f, 9.15715e-24f
6290 path.cubicTo(SkBits2Float(0x4a4a4a4a), SkBits2Float(0x4a4a4a4a), SkBits2Float(0xa14a4a4a), SkBits2Float(0x08ff2ba1), SkBits2Float(0x08ff4a4a), SkBits2Float(0x4a344a4a)); // 3.31432e+06f, 3.31432e+06f, -6.85386e-19f, 1.53575e-33f, 1.53647e-33f, 2.95387e+06f
6291 path.cubicTo(SkBits2Float(0x4a4a4a4a), SkBits2Float(0x4a4a4a4a), SkBits2Float(0x2ba1a14a), SkBits2Float(0x4e4a08ff), SkBits2Float(0x4a4a4a4a), SkBits2Float(0xa1a181ff)); // 3.31432e+06f, 3.31432e+06f, 1.14845e-12f, 8.47397e+08f, 3.31432e+06f, -1.09442e-18f
6292
6293 SkPath path2(path);
6294 SkPath dummy;
6295 testPathOpFuzz(reporter, path1, path2, (SkPathOp)4, filename);
6296}
6297
6298// crbug.com/626186
6299static void fuzz763_1b(skiatest::Reporter* reporter, const char* filename) {
6300 SkPath path;
6301 path.setFillType((SkPath::FillType) 0);
6302 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6303 path.cubicTo(SkBits2Float(0x0000ff07), SkBits2Float(0xf9f9ff00), SkBits2Float(0xfe0ef9f4), SkBits2Float(0xd9b105fb), SkBits2Float(0x000000f9), SkBits2Float(0xfe11f901)); // 9.14866e-41f, -1.62257e+35f, -4.75121e+37f, -6.22846e+15f, 3.48923e-43f, -4.85077e+37f
6304 path.lineTo(SkBits2Float(0xda1905ed), SkBits2Float(0x3c05fbfb)); // -1.0768e+16f, 0.00817775f
6305 path.cubicTo(SkBits2Float(0x3c3c3c3c), SkBits2Float(0x3c3c3c3c), SkBits2Float(0x253c7f00), SkBits2Float(0xfa00d3fa), SkBits2Float(0x250025fe), SkBits2Float(0x00000006)); // 0.011489f, 0.011489f, 1.63494e-16f, -1.67228e+35f, 1.11151e-16f, 8.40779e-45f
6306
6307 SkPath path1(path);
6308 path.reset();
6309 path.setFillType((SkPath::FillType) 0);
6310 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6311 path.quadTo(SkBits2Float(0x3c3c3c3c), SkBits2Float(0xfa253c3c), SkBits2Float(0xfefa00d3), SkBits2Float(0x25fad9df)); // 0.011489f, -2.14488e+35f, -1.66156e+38f, 4.35157e-16f
6312 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6313 path.close();
6314 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6315 path.lineTo(SkBits2Float(0x8dfefa00), SkBits2Float(0xf0f9fad9)); // -1.57141e-30f, -6.1892e+29f
6316 path.cubicTo(SkBits2Float(0x20fe58f9), SkBits2Float(0x0525fbed), SkBits2Float(0x1905ffff), SkBits2Float(0x01f9f9f9), SkBits2Float(0xfbfe0ef9), SkBits2Float(0xfb212fff)); // 4.30882e-19f, 7.80453e-36f, 6.92764e-24f, 9.18268e-38f, -2.63829e+36f, -8.36933e+35f
6317
6318 SkPath path2(path);
6319 testPathOpFuzz(reporter, path1, path2, (SkPathOp)2, filename);
6320}
6321
6322static void fuzz763_1a(skiatest::Reporter* reporter, const char* filename) {
6323 SkPath path;
6324 path.setFillType((SkPath::FillType) 0);
6325 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6326 path.cubicTo(SkBits2Float(0x154be880), SkBits2Float(0x80000640), SkBits2Float(0x5559a419), SkBits2Float(0x59d55928), SkBits2Float(0x80045959), SkBits2Float(0x40154be8)); // 4.11789e-26f, -2.24208e-42f, 1.49562e+13f, 7.50652e+15f, -3.99394e-40f, 2.33276f
6327
6328 SkPath path1(path);
6329 path.reset();
6330 path.setFillType((SkPath::FillType) 0);
6331 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6332 path.quadTo(SkBits2Float(0x5559a419), SkBits2Float(0x59d55928), SkBits2Float(0xbd595959), SkBits2Float(0x3f3f3f09)); // 1.49562e+13f, 7.50652e+15f, -0.0530637f, 0.747056f
6333 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0x3f3f3f3f)); // 0.747059f, 0.747059f
6334 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f
6335 path.lineTo(SkBits2Float(0x09090909), SkBits2Float(0x3038d509)); // 1.6495e-33f, 6.72416e-10f
6336 path.conicTo(SkBits2Float(0x5947ffff), SkBits2Float(0x40e88004), SkBits2Float(0x00002059), SkBits2Float(0x28555900), SkBits2Float(0x5959d559)); // 3.51844e+15f, 7.26563f, 1.16042e-41f, 1.18432e-14f, 3.83217e+15f
6337 path.lineTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f
6338 path.close();
6339 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f
6340 path.lineTo(SkBits2Float(0x38d57f4b), SkBits2Float(0x59597f4b)); // 0.000101803f, 3.82625e+15f
6341 path.lineTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f
6342 path.close();
6343 path.moveTo(SkBits2Float(0x384700ff), SkBits2Float(0x0108804b)); // 4.74462e-05f, 2.50713e-38f
6344
6345 SkPath path2(path);
6346 testPathOpFuzz(reporter, path1, path2, (SkPathOp)0, filename);
6347}
6348
6349// crbug.com/627780
6350static void fuzz763_3a(skiatest::Reporter* reporter, const char* filename) {
6351 SkPath path;
6352 path.setFillType((SkPath::FillType) 1);
6353
6354 SkPath path1(path);
6355 path.reset();
6356 path.setFillType((SkPath::FillType) 0);
6357path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6358path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f
6359path.conicTo(SkBits2Float(0xc0032108), SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0)); // -2.04889f, 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f
6360path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
6361path.cubicTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6), SkBits2Float(0x272a812a), SkBits2Float(0x295b2d29), SkBits2Float(0x2a685568), SkBits2Float(0x68295b2d)); // 2.25206e-21f, 5.54035e+21f, 2.36623e-15f, 4.86669e-14f, 2.06354e-13f, 3.19905e+24f
6362path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321), SkBits2Float(0x7a6a4b77), SkBits2Float(0x3a214726)); // 2.49282e-13f, 4.78968e-34f, 1.99397e+36f, 3.04132e+35f, 0.000615226f
6363path.moveTo(SkBits2Float(0x8adf2028), SkBits2Float(0x3a219a3a)); // -2.14862e-32f, 0.000616464f
6364path.quadTo(SkBits2Float(0x3ab38e28), SkBits2Float(0x29283ac2), SkBits2Float(0x2be61d2a), SkBits2Float(0x812a4396)); // 0.0013699f, 3.73545e-14f, 1.63506e-12f, -3.12726e-38f
6365
6366 SkPath path2(path);
6367 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
6368}
6369
6370// crbug.com/627689
6371static void fuzz763_5a(skiatest::Reporter* reporter, const char* filename) {
6372 SkPath path;
6373 path.setFillType((SkPath::FillType) 1);
6374path.moveTo(SkBits2Float(0x38bd8610), SkBits2Float(0x00000000)); // 9.03719e-05f, 0
6375path.conicTo(SkBits2Float(0x4183d871), SkBits2Float(0x41fea321), SkBits2Float(0xb700ff00), SkBits2Float(0x4240b8b8), SkBits2Float(0x3b058283)); // 16.4807f, 31.8297f, -7.68877e-06f, 48.1804f, 0.0020372f
6376path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f
6377path.conicTo(SkBits2Float(0x3a455ec8), SkBits2Float(0xb8b8b8b3), SkBits2Float(0x38b2418d), SkBits2Float(0xb730d014), SkBits2Float(0x3f7ffff3)); // 0.000752908f, -8.80821e-05f, 8.49991e-05f, -1.05389e-05f, 0.999999f
6378path.quadTo(SkBits2Float(0x3a51246a), SkBits2Float(0xb6da45a3), SkBits2Float(0x38bc5c3c), SkBits2Float(0x00000000)); // 0.000797814f, -6.50501e-06f, 8.98172e-05f, 0
6379path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f
6380path.quadTo(SkBits2Float(0x39a32d2d), SkBits2Float(0x00000000), SkBits2Float(0xb8a13a00), SkBits2Float(0x00000000)); // 0.000311234f, 0, -7.68788e-05f, 0
6381path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f
6382path.quadTo(SkBits2Float(0x39ba814c), SkBits2Float(0xb838fed2), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0.00035573f, -4.41063e-05f, 0, 0
6383path.lineTo(SkBits2Float(0x38bd8610), SkBits2Float(0x00000000)); // 9.03719e-05f, 0
6384path.close();
6385
6386 SkPath path1(path);
6387 path.reset();
6388 path.setFillType((SkPath::FillType) 0);
6389
6390 SkPath path2(path);
6391 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
6392}
6393
6394// crbug.com/627401
6395static void fuzz763_2a(skiatest::Reporter* reporter, const char* filename) {
6396 SkPath path;
6397 path.setFillType((SkPath::FillType) 1);
6398
6399 SkPath path1(path);
6400 path.reset();
6401 path.setFillType((SkPath::FillType) 0);
6402path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6403path.quadTo(SkBits2Float(0x3e484500), SkBits2Float(0x164f3a30), SkBits2Float(0x49484801), SkBits2Float(0x7d0100c8)); // 0.195576f, 1.67397e-25f, 820352, 1.07172e+37f
6404path.conicTo(SkBits2Float(0xff7f36fd), SkBits2Float(0x3e647d01), SkBits2Float(0x0c00f430), SkBits2Float(0x486b6448), SkBits2Float(0x00484848)); // -3.39239e+38f, 0.223133f, 9.93424e-32f, 241041, 6.63809e-39f
6405path.lineTo(SkBits2Float(0x4f4f557d), SkBits2Float(0x48480112)); // 3.47849e+09f, 204804
6406path.lineTo(SkBits2Float(0xf40c01ff), SkBits2Float(0x45008000)); // -4.43702e+31f, 2056
6407path.moveTo(SkBits2Float(0x4bfffa00), SkBits2Float(0x7d4ac859)); // 3.35514e+07f, 1.68465e+37f
6408path.conicTo(SkBits2Float(0x7d014f3e), SkBits2Float(0x00f4ff01), SkBits2Float(0x6b64480c), SkBits2Float(0x48484848), SkBits2Float(0x557d0100)); // 1.07426e+37f, 2.24993e-38f, 2.75975e+26f, 205089, 1.73863e+13f
6409
6410 SkPath path2(path);
6411 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
6412}
6413
6414// crbug.com/627761
6415static void fuzz763_2b(skiatest::Reporter* reporter, const char* filename) {
6416 SkPath path;
6417 path.setFillType((SkPath::FillType) 1);
6418
6419 SkPath path1(path);
6420 path.reset();
6421 path.setFillType((SkPath::FillType) 0);
6422path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55)); // 4.76191e+16f, 5.7784e-19f
6423path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
6424path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21)); // 2.50338e-13f, 4.61198e-19f
6425path.conicTo(SkBits2Float(0x6a3a7bc0), SkBits2Float(0x4721ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28), SkBits2Float(0x4f9a3a8a)); // 5.63611e+25f, 41453.5f, 9.4495e-15f, 0.000617492f, 5.17506e+09f
6426path.lineTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
6427path.close();
6428path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
6429path.cubicTo(SkBits2Float(0x273ac23a), SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6), SkBits2Float(0x272a812a), SkBits2Float(0x295b2d29), SkBits2Float(0x29685568)); // 2.5918e-15f, 2.25206e-21f, 5.54035e+21f, 2.36623e-15f, 4.86669e-14f, 5.15884e-14f
6430path.lineTo(SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321)); // 4.78968e-34f, 1.99397e+36f
6431path.lineTo(SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28)); // 9.4495e-15f, 0.000617492f
6432path.lineTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
6433path.close();
6434path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
6435path.quadTo(SkBits2Float(0x8a4fc29a), SkBits2Float(0x3ab3283a), SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6)); // -1.00033e-32f, 0.00136686f, 2.25206e-21f, 300.343f
6436path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
6437path.conicTo(SkBits2Float(0x1e2ab03a), SkBits2Float(0x2920213b), SkBits2Float(0x3b3ac527), SkBits2Float(0xc422333b), SkBits2Float(0x6c2a9f1f)); // 9.03617e-21f, 3.5556e-14f, 0.00284989f, -648.8f, 8.25075e+26f
6438path.quadTo(SkBits2Float(0xc25d2757), SkBits2Float(0x3a705921), SkBits2Float(0x2a105152), SkBits2Float(0x28d91210)); // -55.2884f, 0.000916855f, 1.2818e-13f, 2.40997e-14f
6439path.quadTo(SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19905e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f
6440path.lineTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
6441path.close();
6442path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
6443path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0xcb7bc003), SkBits2Float(0x47ed7a6a)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, -1.64987e+07f, 121589
6444path.lineTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
6445path.close();
6446path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
6447path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x2d8a3a21), SkBits2Float(0x5b682b68), SkBits2Float(0x5b292d55)); // -1.2117e+19f, 1.57146e-11f, 6.53499e+16f, 4.76191e+16f
6448path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x0321081f)); // 1.43144e-13f, 4.7323e-37f
6449path.conicTo(SkBits2Float(0x7a6a4b7b), SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x3a21477a)); // 3.04132e+35f, 5.77848e-19f, 4.7323e-37f, 5.63611e+25f, 0.000615231f
6450path.moveTo(SkBits2Float(0x21df2828), SkBits2Float(0x9a3a8a3a)); // 1.51217e-18f, -3.85756e-23f
6451path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x28273ac2), SkBits2Float(0xe61d2a29), SkBits2Float(0x2a63962b)); // 0.00136978f, 9.2831e-15f, -1.85547e+23f, 2.02138e-13f
6452path.conicTo(SkBits2Float(0x2d29272a), SkBits2Float(0x5568295b), SkBits2Float(0x5b2d2968), SkBits2Float(0x5b2d6829), SkBits2Float(0x212a8c55)); // 9.61523e-12f, 1.5954e+13f, 4.87407e+16f, 4.88097e+16f, 5.7784e-19f
6453path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6454path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
6455path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6456path.close();
6457
6458 SkPath path2(path);
6459 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
6460}
6461
6462static void fuzz763_2c(skiatest::Reporter* reporter, const char* filename) {
6463 SkPath path;
6464 path.setFillType((SkPath::FillType) 1);
6465
6466path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x36344a4a)); // 0, 2.68653e-06f
6467path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x364a4a4a), SkBits2Float(0x364a4a4a), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0, 3.01436e-06f, 3.01436e-06f, 0, 0
6468path.lineTo(SkBits2Float(0x364a4a4a), SkBits2Float(0x00000000)); // 3.01436e-06f, 0
6469path.cubicTo(SkBits2Float(0x364a30f0), SkBits2Float(0x344ac7fb), SkBits2Float(0x3656d432), SkBits2Float(0x34cabb48), SkBits2Float(0x367031a9), SkBits2Float(0x351802f1)); // 3.01288e-06f, 1.88855e-07f, 3.2012e-06f, 3.77617e-07f, 3.57917e-06f, 5.66287e-07f
6470path.cubicTo(SkBits2Float(0x36a7b150), SkBits2Float(0x35ab09db), SkBits2Float(0x371874ed), SkBits2Float(0x3604f2c7), SkBits2Float(0x3784e0c7), SkBits2Float(0x36344a51)); // 4.99763e-06f, 1.27434e-06f, 9.08713e-06f, 1.98108e-06f, 1.58403e-05f, 2.68653e-06f
6471path.cubicTo(SkBits2Float(0x3743dc9a), SkBits2Float(0x36344a4f), SkBits2Float(0x36fbef33), SkBits2Float(0x36344a4e), SkBits2Float(0x36604a35), SkBits2Float(0x36344a4c)); // 1.16743e-05f, 2.68653e-06f, 7.50823e-06f, 2.68653e-06f, 3.34218e-06f, 2.68653e-06f
6472path.cubicTo(SkBits2Float(0x36531715), SkBits2Float(0x36344a4c), SkBits2Float(0x3645e3f5), SkBits2Float(0x36344a4b), SkBits2Float(0x3638b0d4), SkBits2Float(0x36344a4b)); // 3.14549e-06f, 2.68653e-06f, 2.9488e-06f, 2.68653e-06f, 2.75211e-06f, 2.68653e-06f
6473path.cubicTo(SkBits2Float(0x35f64120), SkBits2Float(0x36344a4b), SkBits2Float(0x35764124), SkBits2Float(0x36344a4a), SkBits2Float(0x00000000), SkBits2Float(0x36344a4a)); // 1.83474e-06f, 2.68653e-06f, 9.17369e-07f, 2.68653e-06f, 0, 2.68653e-06f
6474path.close();
6475 SkPath path1(path);
6476 path.reset();
6477 path.setFillType((SkPath::FillType) 0);
6478path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6479path.cubicTo(SkBits2Float(0x1931204a), SkBits2Float(0x2ba1a14a), SkBits2Float(0x4a4a08ff), SkBits2Float(0x4a4a08ff), SkBits2Float(0x4a4a4a34), SkBits2Float(0x4a4a4a4a)); // 9.15721e-24f, 1.14845e-12f, 3.31014e+06f, 3.31014e+06f, 3.31432e+06f, 3.31432e+06f
6480path.moveTo(SkBits2Float(0x000010a1), SkBits2Float(0x19312000)); // 5.96533e-42f, 9.15715e-24f
6481path.cubicTo(SkBits2Float(0x4a4a4a4a), SkBits2Float(0x4a4a4a4a), SkBits2Float(0xa14a4a4a), SkBits2Float(0x08ff2ba1), SkBits2Float(0x08ff4a4a), SkBits2Float(0x4a344a4a)); // 3.31432e+06f, 3.31432e+06f, -6.85386e-19f, 1.53575e-33f, 1.53647e-33f, 2.95387e+06f
6482path.cubicTo(SkBits2Float(0x544a4a4a), SkBits2Float(0x4a4a4a4a), SkBits2Float(0x2ba1a14a), SkBits2Float(0x4e4a08ff), SkBits2Float(0x4a4a4a4a), SkBits2Float(0xa1a181ff)); // 3.47532e+12f, 3.31432e+06f, 1.14845e-12f, 8.47397e+08f, 3.31432e+06f, -1.09442e-18f
6483 SkPath path2(path);
6484 testPathOpFuzz(reporter, path1, path2, kReverseDifference_SkPathOp, filename);
6485}
6486
6487static void fuzz763_6(skiatest::Reporter* reporter, const char* filename) {
6488 SkPath path;
6489 path.setFillType((SkPath::FillType) 1);
6490path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f
6491path.cubicTo(SkBits2Float(0x68295b2d), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 3.19905e+24f, 0, 0, 0, 0, 4.03114e+24f
6492path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f
6493path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x67d55b2a), SkBits2Float(0x67296a4b), SkBits2Float(0x67555b2a), SkBits2Float(0x677e1f70), SkBits2Float(0x66d55b2a)); // 0, 2.01509e+24f, 8.00041e+23f, 1.00755e+24f, 1.20006e+24f, 5.03773e+23f
6494path.cubicTo(SkBits2Float(0x678f0684), SkBits2Float(0x6684f008), SkBits2Float(0x6798f8ea), SkBits2Float(0x6625a942), SkBits2Float(0x67961914), SkBits2Float(0x65ce709a)); // 1.35084e+24f, 3.1389e+23f, 1.44478e+24f, 1.95578e+23f, 1.41764e+24f, 1.21861e+23f
6495path.cubicTo(SkBits2Float(0x679174f7), SkBits2Float(0x63199132), SkBits2Float(0x6756c79f), SkBits2Float(0x606478de), SkBits2Float(0x65682bcf), SkBits2Float(0x00000000)); // 1.3738e+24f, 2.83281e+21f, 1.01427e+24f, 6.58526e+19f, 6.85248e+22f, 0
6496path.conicTo(SkBits2Float(0x68295b02), SkBits2Float(0x60f7f28b), SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f), SkBits2Float(0x42784f5a)); // 3.19903e+24f, 1.42932e+20f, 0, 5.14279e+25f, 62.0775f
6497path.close();
6498path.moveTo(SkBits2Float(0x654d6d10), SkBits2Float(0x00000000)); // 6.06311e+22f, 0
6499path.lineTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000)); // 6.14991e+25f, 0
6500path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc0)); // 0, 6.14991e+25f
6501path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6502
6503 SkPath path1(path);
6504 path.reset();
6505 path.setFillType((SkPath::FillType) 0);
6506path.moveTo(SkBits2Float(0x3ac23a55), SkBits2Float(0x2a292827)); // 0.00148184f, 1.50241e-13f
6507path.lineTo(SkBits2Float(0x63962be6), SkBits2Float(0x272a812a)); // 5.54035e+21f, 2.36623e-15f
6508
6509 SkPath path2(path);
6510 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
6511}
6512
6513static void fuzz763_7(skiatest::Reporter* reporter, const char* filename) {
6514 SkPath path;
6515 path.setFillType((SkPath::FillType) 0);
6516
6517 SkPath path1(path);
6518 path.reset();
6519 path.setFillType((SkPath::FillType) 0);
6520path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
6521path.moveTo(SkBits2Float(0x0f2a312a), SkBits2Float(0xc0032108)); // 8.39112e-30f, -2.04889f
6522path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a1f2a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76395e-19f, 4.7323e-37f, 6.14991e+25f
6523path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
6524path.moveTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f
6525path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0xef2a8c55), SkBits2Float(0x295b2d2a), SkBits2Float(0x08685568), SkBits2Float(0x7bc00321)); // 5.76397e-19f, -5.27821e+28f, 4.86669e-14f, 6.99154e-34f, 1.99397e+36f
6526path.lineTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f
6527path.close();
6528path.moveTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f
6529path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
6530path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6531path.lineTo(SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a281a4f)); // 0.00105461f, -8.09385e-33f
6532path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f
6533path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f
6534path.conicTo(SkBits2Float(0xba1f203a), SkBits2Float(0xc422c538), SkBits2Float(0x215d5927), SkBits2Float(0x70ec2ac2), SkBits2Float(0x2a51523a)); // -0.000607017f, -651.082f, 7.49957e-19f, 5.84721e+29f, 1.85915e-13f
6535path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x683a5b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.52017e+24f
6536path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f
6537path.conicTo(SkBits2Float(0xaa8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x5b2d0321), SkBits2Float(0x68556829), SkBits2Float(0x2a552d29)); // -2.49282e-13f, 4.78968e-34f, 4.86986e+16f, 4.03114e+24f, 1.89339e-13f
6538path.cubicTo(SkBits2Float(0x21295b2d), SkBits2Float(0x2a688c5b), SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x8c08555b), SkBits2Float(0x2a2a29ca)); // 5.73801e-19f, 2.06544e-13f, 3.19905e+24f, 9.6297e-12f, -1.05027e-31f, 1.51135e-13f
6539path.quadTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f
6540path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6541path.close();
6542path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6543path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x5b2d6829), SkBits2Float(0x212a8c55), SkBits2Float(0xed7aba1f), SkBits2Float(0x2a212a8c)); // 6.14991e+25f, 4.88097e+16f, 5.7784e-19f, -4.84977e+27f, 1.43144e-13f
6544path.moveTo(SkBits2Float(0x2d212d08), SkBits2Float(0x5568295b)); // 9.16179e-12f, 1.5954e+13f
6545path.moveTo(SkBits2Float(0x5529685b), SkBits2Float(0x11295b68)); // 1.16416e+13f, 1.33599e-28f
6546path.conicTo(SkBits2Float(0x5b782968), SkBits2Float(0x3a292d55), SkBits2Float(0x2a8c555b), SkBits2Float(0x68295a2d), SkBits2Float(0x2d296855)); // 6.98513e+16f, 0.000645359f, 2.49282e-13f, 3.19897e+24f, 9.6297e-12f
6547path.moveTo(SkBits2Float(0x555b8c55), SkBits2Float(0x21682929)); // 1.50872e+13f, 7.86591e-19f
6548path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6549path.conicTo(SkBits2Float(0xac2d8ced), SkBits2Float(0x5b682968), SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55), SkBits2Float(0x081f282a)); // -2.4663e-12f, 6.53477e+16f, 4.76191e+16f, 5.7784e-19f, 4.78945e-34f
6550path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6551path.close();
6552path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6553path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x03081f21), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x2147ed7a)); // 6.14991e+25f, 2.50338e-13f, 4.00025e-37f, 5.63611e+25f, 6.77381e-19f
6554path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6555path.close();
6556path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6557path.quadTo(SkBits2Float(0x2d28282a), SkBits2Float(0x5568295b), SkBits2Float(0x3a21df68), SkBits2Float(0x4f9a3a8a)); // 9.55861e-12f, 1.5954e+13f, 0.000617495f, 5.17506e+09f
6558path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6559path.close();
6560path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6561path.cubicTo(SkBits2Float(0x5568c23a), SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a), SkBits2Float(0x3a7bc003), SkBits2Float(0x294b2827)); // 1.59951e+13f, 4.87407e+16f, 5.7784e-19f, 4.61198e-19f, 0.00096035f, 4.51099e-14f
6562
6563 SkPath path2(path);
6564 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
6565}
6566
6567static void kfuzz2(skiatest::Reporter* reporter, const char* filename) {
6568 SkPath path1;
6569 SkPath path;
6570path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
6571path.close();
6572path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
6573path.cubicTo(SkBits2Float(0xe3000000), SkBits2Float(0xf19e92c7), SkBits2Float(0xf17febcb), SkBits2Float(0xff7febcb), SkBits2Float(0x60600100), SkBits2Float(0x0100ff60)); // -2.36118e+21f, -1.57043e+30f, -1.26726e+30f, -3.40177e+38f, 6.45647e+19f, 2.36931e-38f
6574path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
6575path.close();
6576path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
6577path.lineTo(SkBits2Float(0x60601a1d), SkBits2Float(0x60606060)); // 6.4593e+19f, 6.46721e+19f
6578path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
6579path.close();
6580path.moveTo(SkBits2Float(0xe5e2f300), SkBits2Float(0xee244a40)); // -1.33967e+23f, -1.27113e+28f
6581path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
6582path.close();
6583path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
6584path.lineTo(SkBits2Float(0xfafafafa), SkBits2Float(0xe30000fa)); // -6.51582e+35f, -2.36125e+21f
6585path.conicTo(SkBits2Float(0x92e592e5), SkBits2Float(0xfafafafb), SkBits2Float(0xc4fa0000), SkBits2Float(0x6060fafa), SkBits2Float(0x60606060)); // -1.44881e-27f, -6.51582e+35f, -2000, 6.48462e+19f, 6.46721e+19f
6586path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
6587path.close();
6588path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
6589path.cubicTo(SkBits2Float(0xe3000000), SkBits2Float(0xf19e92c7), SkBits2Float(0xf17febcb), SkBits2Float(0xff7febcb), SkBits2Float(0xfafafa00), SkBits2Float(0xfafafafa)); // -2.36118e+21f, -1.57043e+30f, -1.26726e+30f, -3.40177e+38f, -6.51572e+35f, -6.51582e+35f
6590path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
6591path.close();
6592path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
6593path.cubicTo(SkBits2Float(0xe3000000), SkBits2Float(0xe39e92c7), SkBits2Float(0xf17febcb), SkBits2Float(0xff7febcb), SkBits2Float(0xeed0ee9a), SkBits2Float(0x9a98ffca)); // -2.36118e+21f, -5.85032e+21f, -1.26726e+30f, -3.40177e+38f, -3.23307e+28f, -6.3279e-23f
6594path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
6595path.close();
6596SkPath path2(path);
6597 testPathOpFuzz(reporter, path1, path2, kXOR_SkPathOp, filename);
6598}
6599
6600static void fuzz763_10(skiatest::Reporter* reporter, const char* filename) {
6601 SkPath path;
6602 path.setFillType((SkPath::FillType) 1);
6603path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 0, 4.03114e+24f
6604path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6605path.quadTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 6.14991e+25f, 0, 0, 6.14991e+25f
6606path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 0, 4.03114e+24f
6607path.close();
6608
6609 SkPath path1(path);
6610 path.reset();
6611 path.setFillType((SkPath::FillType) 0);
6612path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6613path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x2a8c8f55)); // 4.87407e+16f, 2.49685e-13f
6614path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6615path.close();
6616path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
6617path.conicTo(SkBits2Float(0x682d2fed), SkBits2Float(0x755b6829), SkBits2Float(0x5b292d2b), SkBits2Float(0xc92a8c55), SkBits2Float(0x081f2a21)); // 3.27141e+24f, 2.78131e+32f, 4.76189e+16f, -698565, 4.78968e-34f
6618path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
6619path.close();
6620path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
6621path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a29)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121588
6622path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
6623path.close();
6624path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
6625path.quadTo(SkBits2Float(0x6829682d), SkBits2Float(0x292d555b), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a29)); // 3.20001e+24f, 3.84878e-14f, 2.49282e-13f, 4.78969e-34f
6626path.conicTo(SkBits2Float(0x6a497b19), SkBits2Float(0x218ced7a), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x47ed3a7a)); // 6.08939e+25f, 9.54963e-19f, 4.7323e-37f, 5.63611e+25f, 121461
6627path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
6628path.close();
6629path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
6630path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3a21df), SkBits2Float(0x2728282a), SkBits2Float(0x8a3a2129)); // 9.4456e-15f, -8.96194e-33f, 2.33365e-15f, -8.96181e-33f
6631path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3a3ac2b3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.000712435f, 1.50241e-13f, -1.38859e-25f
6632path.lineTo(SkBits2Float(0x272a802a), SkBits2Float(0x2a8c2d29)); // 2.36617e-15f, 2.49003e-13f
6633path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
6634path.close();
6635path.moveTo(SkBits2Float(0x4f9a3a29), SkBits2Float(0x3ab38a28)); // 5.17501e+09f, 0.00136978f
6636path.quadTo(SkBits2Float(0xc368305b), SkBits2Float(0x5b296855), SkBits2Float(0x2d8c5568), SkBits2Float(0x1f2a2172)); // -232.189f, 4.7684e+16f, 1.59541e-11f, 3.60266e-20f
6637path.lineTo(SkBits2Float(0x29c00321), SkBits2Float(0x5b4b7b13)); // 8.52706e-14f, 5.72747e+16f
6638
6639 SkPath path2(path);
6640 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
6641}
6642
6643static void fuzz763_11(skiatest::Reporter* reporter, const char* filename) {
6644 SkPath path;
6645 path.setFillType((SkPath::FillType) 0);
6646
6647 SkPath path1(path);
6648 path.reset();
6649 path.setFillType((SkPath::FillType) 0);
6650path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
6651path.moveTo(SkBits2Float(0x2a0f312a), SkBits2Float(0xc0032108)); // 1.2718e-13f, -2.04889f
6652path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a1f2a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76395e-19f, 4.7323e-37f, 6.14991e+25f
6653path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7b21), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14984e+25f, 9.43289e-15f, 1.21279e-11f
6654path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f
6655path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0xef2a8c55), SkBits2Float(0x295b2d2a), SkBits2Float(0x08685568), SkBits2Float(0x7bc00321)); // 5.76397e-19f, -5.27821e+28f, 4.86669e-14f, 6.99154e-34f, 1.99397e+36f
6656path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f
6657path.close();
6658path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f
6659path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
6660path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6661path.lineTo(SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a281a4f)); // 0.00105461f, -8.09385e-33f
6662path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x2a812a3b), SkBits2Float(0x2a552927)); // 2.25206e-21f, 300.343f, 2.29443e-13f, 1.89325e-13f
6663path.quadTo(SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x203a3b27), SkBits2Float(0x22c5381f)); // 0.00241343f, 3.71093e-14f, 1.57744e-19f, 5.34564e-18f
6664path.moveTo(SkBits2Float(0x5d27ec2a), SkBits2Float(0x705921c2)); // 7.56256e+17f, 2.68796e+29f
6665path.quadTo(SkBits2Float(0x102a5152), SkBits2Float(0x5b2dd912), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 3.35892e-29f, 4.89338e+16f, 4.03114e+24f, 1.50617e+13f
6666path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032127)); // 3.60396e-20f, -2.0489f
6667path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0x2a8c684b), SkBits2Float(0xf05b272d), SkBits2Float(0x2a1f1555), SkBits2Float(0x21082a21), SkBits2Float(0x6a4b7b03)); // 3.4979e+24f, 2.49414e-13f, -2.71298e+29f, 1.41294e-13f, 4.61343e-19f, 6.14982e+25f
6668path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
6669path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
6670path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0xef2a8c55), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -5.27821e+28f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f
6671path.lineTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
6672path.close();
6673path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
6674path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x2a21211f)); // 4.85282e+16f, 1.43112e-13f
6675path.lineTo(SkBits2Float(0x03552a8c), SkBits2Float(0x6a4f7b28)); // 6.26439e-37f, 6.27073e+25f
6676path.conicTo(SkBits2Float(0x2347ed93), SkBits2Float(0x282a3a21), SkBits2Float(0x3adf2128), SkBits2Float(0x4f1a3a8a), SkBits2Float(0x3ab38a28)); // 1.08381e-17f, 9.4495e-15f, 0.00170234f, 2.58753e+09f, 0.00136978f
6677path.lineTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
6678path.close();
6679path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
6680path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x262a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 5.91556e-16f, 0.000649768f
6681path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f
6682path.conicTo(SkBits2Float(0x371f203a), SkBits2Float(0xc52a22c4), SkBits2Float(0xc25d27ec), SkBits2Float(0x3a705921), SkBits2Float(0x5210513a)); // 9.48464e-06f, -2722.17f, -55.289f, 0.000916855f, 1.5496e+11f
6683path.cubicTo(SkBits2Float(0x63102ad9), SkBits2Float(0x29c80927), SkBits2Float(0x633a27b0), SkBits2Float(0x2909c827), SkBits2Float(0x272927b1), SkBits2Float(0x3a685b2d)); // 2.65942e+21f, 8.88337e-14f, 3.43395e+21f, 3.05937e-14f, 2.3475e-15f, 0.000886368f
6684path.moveTo(SkBits2Float(0x682d6829), SkBits2Float(0x29685555)); // 3.27556e+24f, 5.15884e-14f
6685path.conicTo(SkBits2Float(0xaa8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x5b2d0321), SkBits2Float(0x68556829), SkBits2Float(0x5b2d2729)); // -2.49282e-13f, 4.78968e-34f, 4.86986e+16f, 4.03114e+24f, 4.87382e+16f
6686path.quadTo(SkBits2Float(0x2d685568), SkBits2Float(0x5568295b), SkBits2Float(0x2a552d29), SkBits2Float(0x295b2d27)); // 1.32066e-11f, 1.5954e+13f, 1.89339e-13f, 4.86669e-14f
6687path.lineTo(SkBits2Float(0x682d6829), SkBits2Float(0x29685555)); // 3.27556e+24f, 5.15884e-14f
6688path.close();
6689
6690 SkPath path2(path);
6691 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
6692}
6693
6694static void fuzz763_12(skiatest::Reporter* reporter, const char* filename) {
6695 SkPath path;
6696 path.setFillType((SkPath::FillType) 1);
6697path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6698path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a29082a)); // 0, 5.10868e+25f
6699path.conicTo(SkBits2Float(0x6a295ac3), SkBits2Float(0x61bb988e), SkBits2Float(0x6829682d), SkBits2Float(0x5f3ba76a), SkBits2Float(0x42730a87)); // 5.11843e+25f, 4.32567e+20f, 3.20001e+24f, 1.35219e+19f, 60.7603f
6700path.conicTo(SkBits2Float(0x67aedf99), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x3f801112)); // 1.65163e+24f, 0, 0, 0, 1.00052f
6701path.close();
6702path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6703path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 6.14991e+25f, 0, 0, 4.03114e+24f, 1.50617e+13f
6704path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f
6705path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x67d55b2a), SkBits2Float(0x67296a4b), SkBits2Float(0x67555b2a), SkBits2Float(0x677e1f70), SkBits2Float(0x66d55b2a)); // 0, 2.01509e+24f, 8.00041e+23f, 1.00755e+24f, 1.20006e+24f, 5.03773e+23f
6706path.cubicTo(SkBits2Float(0x678f0684), SkBits2Float(0x6684f008), SkBits2Float(0x6798f8ea), SkBits2Float(0x6625a942), SkBits2Float(0x67961914), SkBits2Float(0x65ce709a)); // 1.35084e+24f, 3.1389e+23f, 1.44478e+24f, 1.95578e+23f, 1.41764e+24f, 1.21861e+23f
6707path.cubicTo(SkBits2Float(0x679158b0), SkBits2Float(0x00000000), SkBits2Float(0x67531e34), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 1.37276e+24f, 0, 9.96976e+23f, 0, 0, 0
6708path.close();
6709
6710 SkPath path1(path);
6711 path.reset();
6712 path.setFillType((SkPath::FillType) 0);
6713path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6714path.conicTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003), SkBits2Float(0xed237a6a), SkBits2Float(0x2d682967), SkBits2Float(0x2a8c555b)); // 4.61198e-19f, 1.64987e+07f, -3.16213e+27f, 1.31969e-11f, 2.49282e-13f
6715path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6716path.close();
6717path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
6718path.lineTo(SkBits2Float(0x3a6821df), SkBits2Float(0x2a8c3a8a)); // 0.000885514f, 2.49096e-13f
6719path.moveTo(SkBits2Float(0x29272a1d), SkBits2Float(0xb03a2a55)); // 3.7118e-14f, -6.77266e-10f
6720path.moveTo(SkBits2Float(0x20213b1e), SkBits2Float(0xc5272927)); // 1.36568e-19f, -2674.57f
6721path.quadTo(SkBits2Float(0xc422373b), SkBits2Float(0xec2a201f), SkBits2Float(0x21c25d27), SkBits2Float(0x523a7059)); // -648.863f, -8.22676e+26f, 1.31706e-18f, 2.00187e+11f
6722path.cubicTo(SkBits2Float(0x12102a10), SkBits2Float(0xe73a28d9), SkBits2Float(0xc8092763), SkBits2Float(0x2927b029), SkBits2Float(0x295b2d27), SkBits2Float(0x2d685568)); // 4.54902e-28f, -8.79114e+23f, -140446, 3.72342e-14f, 4.86669e-14f, 1.32066e-11f
6723path.moveTo(SkBits2Float(0x68556809), SkBits2Float(0x555b2d29)); // 4.03113e+24f, 1.50617e+13f
6724path.moveTo(SkBits2Float(0x1f2a212a), SkBits2Float(0x2d032108)); // 3.60263e-20f, 7.45382e-12f
6725path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x2a552d29)); // 4.03114e+24f, 1.89339e-13f
6726path.cubicTo(SkBits2Float(0x21295b2d), SkBits2Float(0x2a528c5b), SkBits2Float(0x284f5b2d), SkBits2Float(0x218aa621), SkBits2Float(0x3f2d2db3), SkBits2Float(0x68293a2a)); // 5.73801e-19f, 1.87004e-13f, 1.15106e-14f, 9.39522e-19f, 0.676479f, 3.19661e+24f
6727
6728 SkPath path2(path);
6729 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
6730}
6731
6732static void fuzz763_13(skiatest::Reporter* reporter, const char* filename) {
6733 SkPath path;
6734 path.setFillType((SkPath::FillType) 1);
6735
6736 SkPath path1(path);
6737 path.reset();
6738 path.setFillType((SkPath::FillType) 0);
6739path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6740path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0x3adf2128), SkBits2Float(0x4f1a3a8a)); // 6.14991e+25f, 75739, 9.4495e-15f, 0.00170234f, 2.58753e+09f
6741path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6742path.close();
6743path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6744path.cubicTo(SkBits2Float(0x3ac2213a), SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a8128), SkBits2Float(0x3a2a5529), SkBits2Float(0x3b1e2ab0)); // 0.00148109f, 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f, 0.00241343f
6745path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6746path.close();
6747path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6748path.cubicTo(SkBits2Float(0x3b272927), SkBits2Float(0x381f203a), SkBits2Float(0x2ac422c5), SkBits2Float(0xc25d27ec), SkBits2Float(0x3a705921), SkBits2Float(0x2a105152)); // 0.00255067f, 3.79386e-05f, 3.48407e-13f, -55.289f, 0.000916855f, 1.2818e-13f
6749path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x68295b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.19905e+24f
6750path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f
6751path.conicTo(SkBits2Float(0xaa8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x5b2d0321), SkBits2Float(0x68556829), SkBits2Float(0x2a552d29)); // -2.49282e-13f, 4.78968e-34f, 4.86986e+16f, 4.03114e+24f, 1.89339e-13f
6752path.cubicTo(SkBits2Float(0x21295b2d), SkBits2Float(0x2a688c5b), SkBits2Float(0x6829292d), SkBits2Float(0x2d296855), SkBits2Float(0x8c08555b), SkBits2Float(0x2a2a291f)); // 5.73801e-19f, 2.06544e-13f, 3.19536e+24f, 9.6297e-12f, -1.05027e-31f, 1.51133e-13f
6753path.conicTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321)); // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f, 1.99397e+36f
6754path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6755path.close();
6756path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6757path.lineTo(SkBits2Float(0x5b2d6829), SkBits2Float(0x212a8c55)); // 4.88097e+16f, 5.7784e-19f
6758path.conicTo(SkBits2Float(0x8ced7aba), SkBits2Float(0x3f2a212a), SkBits2Float(0x2d212d08), SkBits2Float(0x5568295b), SkBits2Float(0x29685b2d)); // -3.65895e-31f, 0.664569f, 9.16179e-12f, 1.5954e+13f, 5.15934e-14f
6759path.lineTo(SkBits2Float(0x68295b68), SkBits2Float(0x2d296855)); // 3.19906e+24f, 9.6297e-12f
6760path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
6761path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x6aba7b03), SkBits2Float(0x2147ed7a)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 1.12721e+26f, 6.77381e-19f
6762path.quadTo(SkBits2Float(0x6028282a), SkBits2Float(0x68292ddf), SkBits2Float(0x5b2d555b), SkBits2Float(0x68556829)); // 4.84679e+19f, 3.1957e+24f, 4.8789e+16f, 4.03114e+24f
6763
6764 SkPath path2(path);
6765 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
6766}
6767
6768static void fuzz763_14(skiatest::Reporter* reporter, const char* filename) {
6769 SkPath path;
6770 path.setFillType((SkPath::FillType) 0);
6771
6772 SkPath path1(path);
6773 path.reset();
6774 path.setFillType((SkPath::FillType) 0);
6775path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0xf45b2d29)); // 4.03114e+24f, -6.94598e+31f
6776path.moveTo(SkBits2Float(0x1f2a302a), SkBits2Float(0xc8032108)); // 3.60387e-20f, -134276
6777path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf0db684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x302a5b25), SkBits2Float(0xf0685568)); // 3.4979e+24f, -5.43226e+29f, -1.64207e-31f, 5.76527e-19f, 6.19752e-10f, -2.87615e+29f
6778
6779 SkPath path2(path);
6780 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
6781}
6782
6783static void fuzz763_15(skiatest::Reporter* reporter, const char* filename) {
6784 SkPath path;
6785 path.setFillType((SkPath::FillType) 1);
6786
6787 SkPath path1(path);
6788 path.reset();
6789 path.setFillType((SkPath::FillType) 0);
6790path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55)); // 4.76191e+16f, 5.7784e-19f
6791path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f
6792path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x2c6829c0), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a29)); // 5.77848e-19f, 4.7323e-37f, 3.29924e-12f, 2.49282e-13f, 4.78969e-34f
6793path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f
6794path.close();
6795path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f
6796path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0xdf218a28), SkBits2Float(0x4f1a3a3a)); // 6.14991e+25f, 75739, 9.4495e-15f, -1.16402e+19f, 2.58751e+09f
6797path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x283ac221), SkBits2Float(0xe6432a29), SkBits2Float(0x2a96812b)); // 0.00136978f, 1.03672e-14f, -2.3041e+23f, 2.6735e-13f
6798path.lineTo(SkBits2Float(0x5529272a), SkBits2Float(0x1eb03a2a)); // 1.16241e+13f, 1.86588e-20f
6799path.conicTo(SkBits2Float(0x2a272021), SkBits2Float(0x3ac52729), SkBits2Float(0xc422313b), SkBits2Float(0xec2a201f), SkBits2Float(0x21c25d27)); // 1.48437e-13f, 0.00150416f, -648.769f, -8.22676e+26f, 1.31706e-18f
6800path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f
6801path.close();
6802path.moveTo(SkBits2Float(0x1051523a), SkBits2Float(0xd912102a)); // 4.12813e-29f, -2.56957e+15f
6803path.close();
6804path.moveTo(SkBits2Float(0x1051523a), SkBits2Float(0xd912102a)); // 4.12813e-29f, -2.56957e+15f
6805path.quadTo(SkBits2Float(0xc82763e7), SkBits2Float(0x2927b029), SkBits2Float(0x295b2d27), SkBits2Float(0x2d685568)); // -171408, 3.72342e-14f, 4.86669e-14f, 1.32066e-11f
6806path.moveTo(SkBits2Float(0x68556809), SkBits2Float(0x8c555b2d)); // 4.03113e+24f, -1.64364e-31f
6807path.moveTo(SkBits2Float(0x081f2a21), SkBits2Float(0x252d0321)); // 4.78968e-34f, 1.50064e-16f
6808path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x5b2df068)); // 1.59583e+13f, 4.89595e+16f
6809path.quadTo(SkBits2Float(0x2a1f2a8c), SkBits2Float(0x21482a21), SkBits2Float(0x4b7bc003), SkBits2Float(0x8ced3a6a)); // 1.41368e-13f, 6.78184e-19f, 1.64987e+07f, -3.65508e-31f
6810path.moveTo(SkBits2Float(0x21481f21), SkBits2Float(0x4b7bc003)); // 6.78038e-19f, 1.64987e+07f
6811path.conicTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d155b2d), SkBits2Float(0x5568295b), SkBits2Float(0x5b2d2968), SkBits2Float(0x2a8c8f55)); // 3.20982e+24f, 8.48991e-12f, 1.5954e+13f, 4.87407e+16f, 2.49685e-13f
6812path.lineTo(SkBits2Float(0x21481f21), SkBits2Float(0x4b7bc003)); // 6.78038e-19f, 1.64987e+07f
6813path.close();
6814path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
6815path.conicTo(SkBits2Float(0x682d2fed), SkBits2Float(0x755b6829), SkBits2Float(0x5b292d2b), SkBits2Float(0xc92a8c55), SkBits2Float(0x081f2a21)); // 3.27141e+24f, 2.78131e+32f, 4.76189e+16f, -698565, 4.78968e-34f
6816path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
6817path.close();
6818path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
6819path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x212aed7a), SkBits2Float(0x0321081f), SkBits2Float(0x293a7bc0), SkBits2Float(0x2147ed7a)); // 6.14991e+25f, 5.79125e-19f, 4.7323e-37f, 4.14076e-14f, 6.77381e-19f
6820path.quadTo(SkBits2Float(0x6829682d), SkBits2Float(0x292d555b), SkBits2Float(0x292a8c55), SkBits2Float(0x21081f2a)); // 3.20001e+24f, 3.84878e-14f, 3.78693e-14f, 4.61198e-19f
6821path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x218ced7a), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x47ed3a7a)); // 6.14991e+25f, 9.54963e-19f, 4.7323e-37f, 5.63611e+25f, 121461
6822path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
6823path.close();
6824path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
6825path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3a21df), SkBits2Float(0x2728282a), SkBits2Float(0x8a3a21df)); // 9.4456e-15f, -8.96194e-33f, 2.33365e-15f, -8.96194e-33f
6826path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3a3ac2b3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.000712435f, 1.50241e-13f, -1.38859e-25f
6827path.lineTo(SkBits2Float(0x272a802a), SkBits2Float(0x2a8c2d29)); // 2.36617e-15f, 2.49003e-13f
6828path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
6829path.close();
6830path.moveTo(SkBits2Float(0x4f9a3a29), SkBits2Float(0x3ab38a28)); // 5.17501e+09f, 0.00136978f
6831path.quadTo(SkBits2Float(0xc368305b), SkBits2Float(0x5b296855), SkBits2Float(0x2d8c5568), SkBits2Float(0x1f2a2172)); // -232.189f, 4.7684e+16f, 1.59541e-11f, 3.60266e-20f
6832path.lineTo(SkBits2Float(0x29c00321), SkBits2Float(0x5b4b7b13)); // 8.52706e-14f, 5.72747e+16f
6833
6834 SkPath path2(path);
6835 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
6836}
6837
6838static void fuzz763_16(skiatest::Reporter* reporter, const char* filename) {
6839 SkPath path;
6840 path.setFillType((SkPath::FillType) 0);
6841
6842 SkPath path1(path);
6843 path.reset();
6844 path.setFillType((SkPath::FillType) 0);
6845path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
6846path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
6847path.cubicTo(SkBits2Float(0x68372d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c552775), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.46012e+24f, -2.71613e+29f, -1.64208e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
6848path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f
6849path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
6850path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f
6851path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
6852path.close();
6853path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
6854path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
6855path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6856path.conicTo(SkBits2Float(0x68385b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.48239e+24f, 1.51141e+13f, 1.41368e-13f, 4.7362e-37f, 1.43189e+16f
6857path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f
6858path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
6859path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 1.31626e+28f, 4.7323e-37f, 6.14991e+25f, 75739
6860path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
6861path.close();
6862path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
6863path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f
6864path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
6865path.close();
6866path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
6867path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
6868path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
6869path.close();
6870path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
6871path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x681aed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 2.92648e+24f, 1.46617e+13f, 9.01175e-21f
6872path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2769), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21512727)); // 2.22225e-15f, 0.000713936f, -732.486f, -1.90686e+27f, 7.08638e-19f
6873path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
6874path.close();
6875path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
6876path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
6877path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0xc0032108)); // 3.60404e-20f, -2.04889f
6878path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05bd24b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0xed4b7bc0)); // 4.06458e+24f, -2.72126e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, -3.93594e+27f
6879path.conicTo(SkBits2Float(0x212a8c6a), SkBits2Float(0x0329081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77841e-19f, 4.9674e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
6880path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
6881path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f
6882path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
6883path.close();
6884path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
6885path.lineTo(SkBits2Float(0x555b6829), SkBits2Float(0x6c212a8c)); // 1.50775e+13f, 7.79352e+26f
6886path.conicTo(SkBits2Float(0x084b0321), SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a), SkBits2Float(0x5bf05568), SkBits2Float(0x212a3a8c)); // 6.10918e-34f, 1.16348e+26f, 0.000209024f, 1.35296e+17f, 5.76757e-19f
6887path.lineTo(SkBits2Float(0x8c558c55), SkBits2Float(0x212a1f2a)); // -1.64512e-31f, 5.76395e-19f
6888
6889 SkPath path2(path);
6890 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
6891}
6892
6893static void fuzz763_17(skiatest::Reporter* reporter, const char* filename) {
6894 SkPath path;
6895 path.setFillType((SkPath::FillType) 0);
6896
6897 SkPath path1(path);
6898 path.reset();
6899 path.setFillType((SkPath::FillType) 0);
6900path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
6901path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
6902path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
6903path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f
6904path.moveTo(SkBits2Float(0x6835282d), SkBits2Float(0xf0682955)); // 3.42196e+24f, -2.87402e+29f
6905path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef552a), SkBits2Float(0x68295b2d), SkBits2Float(0x08682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 4.2514e-13f, 3.19905e+24f, 6.98538e-34f, 1.64988e+07f
6906path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
6907path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6908path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, 1.51141e+13f, 1.41368e-13f, 4.7362e-37f, 1.43189e+16f
6909path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f
6910path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
6911path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x212a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x254793ed)); // 2.49282e-13f, 5.76399e-19f, 4.7323e-37f, 6.14991e+25f, 1.73106e-16f
6912path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
6913path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
6914path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
6915path.close();
6916path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
6917path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f
6918path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0x16c52a22), SkBits2Float(0x515d27ec)); // 2.22225e-15f, 0.000713932f, -732.486f, 3.18537e-25f, 5.93661e+10f
6919path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
6920path.close();
6921path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
6922path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
6923path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
6924path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
6925path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
6926path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
6927path.lineTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x2a212a1f)); // 2.49282e-13f, 1.43143e-13f
6928path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
6929path.close();
6930path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
6931path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x2a1f08c0)); // -1.31678e-31f, 1.41251e-13f
6932path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
6933path.close();
6934path.moveTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f
6935path.conicTo(SkBits2Float(0x55086821), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x5b2c6829), SkBits2Float(0x21218c55), SkBits2Float(0x2a6c1f03)); // 9.3738e+12f, 6.14991e+25f, 4.85282e+16f, 5.47346e-19f, 2.09718e-13f
6936path.lineTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f
6937path.close();
6938path.moveTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f
6939path.lineTo(SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a)); // 1.16348e+26f, 0.000209024f
6940
6941 SkPath path2(path);
6942 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
6943}
6944
6945static void fuzz763_18(skiatest::Reporter* reporter, const char* filename) {
6946 SkPath path;
6947 path.setFillType((SkPath::FillType) 0);
6948
6949 SkPath path1(path);
6950 path.reset();
6951 path.setFillType((SkPath::FillType) 0);
6952path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
6953path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
6954path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
6955path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f
6956path.moveTo(SkBits2Float(0x6835282d), SkBits2Float(0xf0682955)); // 3.42196e+24f, -2.87402e+29f
6957path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef552a), SkBits2Float(0x68295b2d), SkBits2Float(0x08682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 4.2514e-13f, 3.19905e+24f, 6.98538e-34f, 1.64988e+07f
6958path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
6959path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
6960path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, 1.51141e+13f, 1.41368e-13f, 4.7362e-37f, 1.43189e+16f
6961path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f
6962path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
6963path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x212a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x254793ed)); // 2.49282e-13f, 5.76399e-19f, 4.7323e-37f, 6.14991e+25f, 1.73106e-16f
6964path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
6965path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
6966path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
6967path.close();
6968path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
6969path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f
6970path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0x16c52a22), SkBits2Float(0x515d27ec)); // 2.22225e-15f, 0.000713932f, -732.486f, 3.18537e-25f, 5.93661e+10f
6971path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
6972path.close();
6973path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
6974path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
6975path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
6976path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
6977path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
6978path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
6979path.lineTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x2a212a1f)); // 2.49282e-13f, 1.43143e-13f
6980path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
6981path.close();
6982path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
6983path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x2a1f08c0)); // -1.31678e-31f, 1.41251e-13f
6984
6985path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
6986path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
6987path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
6988path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
6989path.conicTo(SkBits2Float(0x2a8c54ed), SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003), SkBits2Float(0x29ed846a), SkBits2Float(0x555b2d28)); // 2.49279e-13f, 4.61198e-19f, 1.64987e+07f, 1.05479e-13f, 1.50617e+13f
6990path.conicTo(SkBits2Float(0x68392d5b), SkBits2Float(0xf0682955), SkBits2Float(0x2a1f5b2d), SkBits2Float(0xef552a21), SkBits2Float(0x5b2d2a8c)); // 3.4979e+24f, -2.87402e+29f, 1.41537e-13f, -6.59712e+28f, 4.8742e+16f
6991
6992 SkPath path2(path);
6993 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
6994}
6995
6996static void fuzz763_19(skiatest::Reporter* reporter, const char* filename) {
6997 SkPath path;
6998 path.setFillType((SkPath::FillType) 1);
6999
7000 SkPath path1(path);
7001 path.reset();
7002 path.setFillType((SkPath::FillType) 0);
7003path.moveTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003)); // 4.61198e-19f, 1.64987e+07f
7004path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 9.43289e-15f, 1.61207e+25f
7005path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
7006path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef552a), SkBits2Float(0x68295b2d), SkBits2Float(0x08682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 4.2514e-13f, 3.19905e+24f, 6.98538e-34f, 1.64988e+07f
7007path.moveTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7008path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7009path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x8c5bf055), SkBits2Float(0x2a1f2a55), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, -1.69435e-31f, 1.41367e-13f, 4.7362e-37f, 1.43189e+16f
7010path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f
7011path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7012path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x212a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2547937a)); // 2.49282e-13f, 5.76399e-19f, 4.7323e-37f, 6.14991e+25f, 1.73105e-16f
7013path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
7014path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
7015path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7016path.close();
7017path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7018path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f
7019path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21515d27)); // 2.22225e-15f, 0.000713932f, -732.486f, -1.90686e+27f, 7.09352e-19f
7020path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7021path.close();
7022path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
7023path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7024path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7025path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7026path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
7027path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7028path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f
7029path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7030path.close();
7031path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7032path.lineTo(SkBits2Float(0x555b2c29), SkBits2Float(0x6c212a8c)); // 1.50614e+13f, 7.79352e+26f
7033path.conicTo(SkBits2Float(0x084b0321), SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a), SkBits2Float(0xf05b5568), SkBits2Float(0x212a3a8c)); // 6.10918e-34f, 1.16348e+26f, 0.000209024f, -2.71522e+29f, 5.76757e-19f
7034path.conicTo(SkBits2Float(0x290321d9), SkBits2Float(0x555b2d68), SkBits2Float(0x2a8c558c), SkBits2Float(0x2abe2a1f), SkBits2Float(0x7bc00321)); // 2.91172e-14f, 1.50618e+13f, 2.49284e-13f, 3.378e-13f, 1.99397e+36f
7035path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7036path.close();
7037path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7038path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x1f2128c0)); // -1.31678e-31f, 3.41268e-20f
7039path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7040path.close();
7041
7042 SkPath path2(path);
7043 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
7044}
7045
7046static void fuzz763_20(skiatest::Reporter* reporter, const char* filename) {
7047 SkPath path;
7048 path.setFillType((SkPath::FillType) 0);
7049
7050 SkPath path1(path);
7051 path.reset();
7052 path.setFillType((SkPath::FillType) 0);
7053path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7054path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7055path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7056path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f
7057path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
7058path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2a8c552a), SkBits2Float(0x68295b2d), SkBits2Float(0x08682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 2.49281e-13f, 3.19905e+24f, 6.98538e-34f, 1.64988e+07f
7059path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7060path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7061path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, 1.51141e+13f, 1.41368e-13f, 4.7362e-37f, 1.43189e+16f
7062path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f
7063path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7064path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321182a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 1.31626e+28f, 4.73414e-37f, 6.14991e+25f, 75739
7065path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7066path.close();
7067path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7068path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f
7069path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7070path.close();
7071path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7072path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
7073path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7074path.close();
7075path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7076path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f
7077path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2769), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x51282727)); // 2.22225e-15f, 0.000713936f, -732.486f, -1.90686e+27f, 4.51382e+10f
7078path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7079path.close();
7080path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
7081path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x8c555b2d)); // 4.03114e+24f, -1.64364e-31f
7082path.moveTo(SkBits2Float(0x081f2a31), SkBits2Float(0xc0032921)); // 4.78969e-34f, -2.04939f
7083path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05bd24b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0xed4b7bc0)); // 4.06458e+24f, -2.72126e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, -3.93594e+27f
7084path.conicTo(SkBits2Float(0x212a8c6a), SkBits2Float(0x4329081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 5.77841e-19f, 169.032f, 6.14991e+25f, 9.43289e-15f, 4.8745e+16f
7085path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7086path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x3a210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 0.000614217f, 1.99729e+36f
7087path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7088path.close();
7089path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7090path.lineTo(SkBits2Float(0x555b6829), SkBits2Float(0x6c212a8c)); // 1.50775e+13f, 7.79352e+26f
7091path.lineTo(SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556830)); // 4.88298e+16f, -2.64185e+29f
7092path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7093path.close();
7094path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7095path.conicTo(SkBits2Float(0x0321d90a), SkBits2Float(0x555b2d68), SkBits2Float(0x2a8c558c), SkBits2Float(0x212a2a1f), SkBits2Float(0x4b7bc003)); // 4.75628e-37f, 1.50618e+13f, 2.49284e-13f, 5.7654e-19f, 1.64987e+07f
7096path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x212128c0)); // -1.31678e-31f, 5.46029e-19f
7097path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
7098path.close();
7099
7100 SkPath path2(path);
7101 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
7102}
7103
7104static void fuzz763_21(skiatest::Reporter* reporter, const char* filename) {
7105 SkPath path;
7106 path.setFillType((SkPath::FillType) 1);
7107path.moveTo(SkBits2Float(0x6828c6f9), SkBits2Float(0x6614dc9e)); // 3.18811e+24f, 1.75745e+23f
7108path.cubicTo(SkBits2Float(0x68303469), SkBits2Float(0x661f92fc), SkBits2Float(0x6837d3c3), SkBits2Float(0x662b0eb2), SkBits2Float(0x683fa268), SkBits2Float(0x663759e1)); // 3.32841e+24f, 1.88392e+23f, 3.4724e+24f, 2.01949e+23f, 3.61987e+24f, 2.16463e+23f
7109path.cubicTo(SkBits2Float(0x68c4391f), SkBits2Float(0x672c5c9f), SkBits2Float(0x688b20ab), SkBits2Float(0x6804b825), SkBits2Float(0x681ddb5e), SkBits2Float(0x6838dc00)); // 7.4131e+24f, 8.13956e+23f, 5.25609e+24f, 2.507e+24f, 2.98183e+24f, 3.49189e+24f
7110path.lineTo(SkBits2Float(0x6828c6f9), SkBits2Float(0x6614dc9e)); // 3.18811e+24f, 1.75745e+23f
7111path.close();
7112path.moveTo(SkBits2Float(0x68226c73), SkBits2Float(0x660bd15e)); // 3.0681e+24f, 1.65068e+23f
7113path.cubicTo(SkBits2Float(0x6823b0e1), SkBits2Float(0x660d990f), SkBits2Float(0x6824f6d5), SkBits2Float(0x660f668c), SkBits2Float(0x68263e4e), SkBits2Float(0x66113632)); // 3.09203e+24f, 1.67169e+23f, 3.11609e+24f, 1.69298e+23f, 3.14025e+24f, 1.71436e+23f
7114path.cubicTo(SkBits2Float(0x682715e4), SkBits2Float(0x6612676d), SkBits2Float(0x6827ee22), SkBits2Float(0x66139997), SkBits2Float(0x6828c709), SkBits2Float(0x6614cba5)); // 3.15616e+24f, 1.72843e+23f, 3.17211e+24f, 1.74255e+23f, 3.18812e+24f, 1.75667e+23f
7115path.lineTo(SkBits2Float(0x6828d720), SkBits2Float(0x6604a1a2)); // 3.1893e+24f, 1.56583e+23f
7116path.cubicTo(SkBits2Float(0x68270421), SkBits2Float(0x6601102c), SkBits2Float(0x68252b97), SkBits2Float(0x65fb1edd), SkBits2Float(0x68234ce5), SkBits2Float(0x65f4367f)); // 3.15485e+24f, 1.52371e+23f, 3.11998e+24f, 1.48235e+23f, 3.08466e+24f, 1.44158e+23f
7117path.conicTo(SkBits2Float(0x6822e012), SkBits2Float(0x6602acc5), SkBits2Float(0x68226c73), SkBits2Float(0x660bd15e), SkBits2Float(0x3f7ffa04)); // 3.07663e+24f, 1.54274e+23f, 3.0681e+24f, 1.65068e+23f, 0.999909f
7118path.close();
7119path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f
7120path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f
7121path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x68617414), SkBits2Float(0x66af1c42), SkBits2Float(0x68624f96), SkBits2Float(0x6757755b), SkBits2Float(0x685b93f2)); // 0, 4.25869e+24f, 4.13468e+23f, 4.27489e+24f, 1.01747e+24f, 4.14771e+24f
7122path.cubicTo(SkBits2Float(0x67a63a84), SkBits2Float(0x68fe1c37), SkBits2Float(0x67c05eed), SkBits2Float(0x69930962), SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 1.56998e+24f, 9.60001e+24f, 1.81689e+24f, 2.22196e+25f, 0, 5.14279e+25f
7123path.close();
7124path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f
7125path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f
7126path.cubicTo(SkBits2Float(0x6a2c8798), SkBits2Float(0x68f7a144), SkBits2Float(0x6951f5ea), SkBits2Float(0x6796ad55), SkBits2Float(0x683fa268), SkBits2Float(0x663759e1)); // 5.21439e+25f, 9.35519e+24f, 1.58642e+25f, 1.4231e+24f, 3.61987e+24f, 2.16463e+23f
7127path.cubicTo(SkBits2Float(0x683871e3), SkBits2Float(0x66253b4f), SkBits2Float(0x6830da01), SkBits2Float(0x66144d3e), SkBits2Float(0x6828d720), SkBits2Float(0x6604a1a2)); // 3.48407e+24f, 1.95071e+23f, 3.34063e+24f, 1.75084e+23f, 3.1893e+24f, 1.56583e+23f
7128path.conicTo(SkBits2Float(0x68295b21), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x492bb324)); // 3.19904e+24f, 0, 0, 0, 703282
7129path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x677b84f0), SkBits2Float(0x00000000), SkBits2Float(0x68226c73), SkBits2Float(0x660bd15e)); // 0, 0, 1.18777e+24f, 0, 3.0681e+24f, 1.65068e+23f
7130path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68156829)); // 0, 2.82222e+24f
7131path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f
7132path.lineTo(SkBits2Float(0x673918f3), SkBits2Float(0x681b0f5f)); // 8.74098e+23f, 2.929e+24f
7133path.lineTo(SkBits2Float(0x67391759), SkBits2Float(0x681b0fae)); // 8.74068e+23f, 2.92902e+24f
7134path.cubicTo(SkBits2Float(0x674384e7), SkBits2Float(0x682e2068), SkBits2Float(0x674db698), SkBits2Float(0x6843893b), SkBits2Float(0x6757755b), SkBits2Float(0x685b93f2)); // 9.23313e+23f, 3.28916e+24f, 9.71453e+23f, 3.69357e+24f, 1.01747e+24f, 4.14771e+24f
7135path.cubicTo(SkBits2Float(0x67a63484), SkBits2Float(0x68556bdd), SkBits2Float(0x67f18c5f), SkBits2Float(0x6848eb25), SkBits2Float(0x681ddb5e), SkBits2Float(0x6838dc00)); // 1.56976e+24f, 4.03142e+24f, 2.28136e+24f, 3.79524e+24f, 2.98183e+24f, 3.49189e+24f
7136path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f
7137path.close();
7138
7139 SkPath path1(path);
7140 path.reset();
7141 path.setFillType((SkPath::FillType) 0);
7142
7143 SkPath path2(path);
7144 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
7145}
7146
7147static void fuzz763_22(skiatest::Reporter* reporter, const char* filename) {
7148 SkPath path;
7149 path.setFillType((SkPath::FillType) 1);
7150path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x68295b2d)); // 0, 3.19905e+24f
7151path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7152path.lineTo(SkBits2Float(0x6a3a7bc0), SkBits2Float(0x00000000)); // 5.63611e+25f, 0
7153path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a034b21)); // 0, 3.9681e+25f
7154path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68295b2d)); // 0, 3.19905e+24f
7155path.close();
7156path.moveTo(SkBits2Float(0x6617da56), SkBits2Float(0x00000000)); // 1.79276e+23f, 0
7157path.conicTo(SkBits2Float(0x5e704d09), SkBits2Float(0x5e3a4dfd), SkBits2Float(0x00000000), SkBits2Float(0x65eb62ef), SkBits2Float(0x430fa5e6)); // 4.32888e+18f, 3.35617e+18f, 0, 1.38948e+23f, 143.648f
7158path.conicTo(SkBits2Float(0x5e798b32), SkBits2Float(0x627a95c0), SkBits2Float(0x61f5014c), SkBits2Float(0x61fba0fd), SkBits2Float(0x40f8a1a1)); // 4.49538e+18f, 1.15562e+21f, 5.64943e+20f, 5.80217e+20f, 7.76973f
7159path.conicTo(SkBits2Float(0x62743d2d), SkBits2Float(0x5e49b862), SkBits2Float(0x6617da56), SkBits2Float(0x00000000), SkBits2Float(0x410ef54c)); // 1.12635e+21f, 3.63387e+18f, 1.79276e+23f, 0, 8.93489f
7160path.close();
7161
7162 SkPath path1(path);
7163 path.reset();
7164 path.setFillType((SkPath::FillType) 0);
7165path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7166path.quadTo(SkBits2Float(0x4f9a3a8a), SkBits2Float(0xc28a0d28), SkBits2Float(0x273a3ab3), SkBits2Float(0x8b2a2928)); // 5.17506e+09f, -69.0257f, 2.58445e-15f, -3.27718e-32f
7167path.lineTo(SkBits2Float(0x63283ae6), SkBits2Float(0x27282a81)); // 3.1033e+21f, 2.33377e-15f
7168
7169 SkPath path2(path);
7170 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
7171}
7172
7173static void fuzz763_23(skiatest::Reporter* reporter, const char* filename) {
7174 SkPath path;
7175 path.setFillType((SkPath::FillType) 0);
7176
7177 SkPath path1(path);
7178 path.reset();
7179 path.setFillType((SkPath::FillType) 0);
7180path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7181path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7182path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x03210c2a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.73276e-37f, 6.14991e+25f
7183path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f
7184path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
7185path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef552a), SkBits2Float(0x29295b2d), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, 4.2514e-13f, 3.76046e-14f, 3.04146e+24f, 1.99729e+36f
7186path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
7187path.close();
7188path.moveTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7189path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7190path.conicTo(SkBits2Float(0x68395b2d), SkBits2Float(0x8c5bf055), SkBits2Float(0x2a1f2a55), SkBits2Float(0x03212a21), SkBits2Float(0x5a4b7bc0)); // 3.50128e+24f, -1.69435e-31f, 1.41367e-13f, 4.7362e-37f, 1.43189e+16f
7191path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f
7192path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7193path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x08211f72), SkBits2Float(0x032a2a21), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2547937a)); // 2.49282e-13f, 4.84861e-34f, 5.00069e-37f, 6.14991e+25f, 1.73105e-16f
7194path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
7195path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
7196path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7197path.close();
7198path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7199path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f
7200path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21515d27)); // 2.22225e-15f, 0.000713932f, -732.486f, -1.90686e+27f, 7.09352e-19f
7201path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
7202path.close();
7203path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
7204path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7205path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7206path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 4.06458e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7207path.conicTo(SkBits2Float(0x2a8c54ed), SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003), SkBits2Float(0x29ed846a), SkBits2Float(0x555b2d28)); // 2.49279e-13f, 4.61198e-19f, 1.64987e+07f, 1.05479e-13f, 1.50617e+13f
7208path.conicTo(SkBits2Float(0x68392d5b), SkBits2Float(0xf0682955), SkBits2Float(0x2a1f5b2d), SkBits2Float(0xef552a21), SkBits2Float(0x5b2d2a8c)); // 3.4979e+24f, -2.87402e+29f, 1.41537e-13f, -6.59712e+28f, 4.8742e+16f
7209
7210 SkPath path2(path);
7211 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
7212}
7213
7214static void fuzz763_24(skiatest::Reporter* reporter, const char* filename) {
7215 SkPath path;
7216 path.setFillType((SkPath::FillType) 1);
7217
7218 SkPath path1(path);
7219 path.reset();
7220 path.setFillType((SkPath::FillType) 0);
7221path.moveTo(SkBits2Float(0xededed02), SkBits2Float(0xedededed)); // -9.20431e+27f, -9.20445e+27f
7222path.close();
7223path.moveTo(SkBits2Float(0xededed02), SkBits2Float(0xedededed)); // -9.20431e+27f, -9.20445e+27f
7224path.quadTo(SkBits2Float(0x9fb9c16e), SkBits2Float(0x27737375), SkBits2Float(0xb7c5ff00), SkBits2Float(0x00ff9908)); // -7.86706e-20f, 3.37856e-15f, -2.3603e-05f, 2.34729e-38f
7225path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7226path.cubicTo(SkBits2Float(0x1616ecec), SkBits2Float(0x2c321616), SkBits2Float(0x3516c616), SkBits2Float(0x6e161616), SkBits2Float(0x4c416033), SkBits2Float(0xf6000000)); // 1.21917e-25f, 2.53076e-12f, 5.61676e-07f, 1.16124e+28f, 5.06923e+07f, -6.49037e+32f
7227path.quadTo(SkBits2Float(0x04007f41), SkBits2Float(0xecececec), SkBits2Float(0xecececec), SkBits2Float(0xecec41ec)); // 1.51048e-36f, -2.2914e+27f, -2.2914e+27f, -2.28494e+27f
7228path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7229path.close();
7230path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7231path.quadTo(SkBits2Float(0x000000ec), SkBits2Float(0xececcc00), SkBits2Float(0x48ececec), SkBits2Float(0x0278806e)); // 3.30706e-43f, -2.29016e+27f, 485223, 1.8257e-37f
7232path.lineTo(SkBits2Float(0x72ececec), SkBits2Float(0xecec02ec)); // 9.38559e+30f, -2.28256e+27f
7233path.quadTo(SkBits2Float(0xec04007f), SkBits2Float(0xecececec), SkBits2Float(0xecececec), SkBits2Float(0xecec0400)); // -6.38322e+26f, -2.2914e+27f, -2.2914e+27f, -2.2826e+27f
7234path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7235path.close();
7236path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7237path.quadTo(SkBits2Float(0x000040ec), SkBits2Float(0x3a333300), SkBits2Float(0xecec3333), SkBits2Float(0xececdbec)); // 2.32896e-41f, 0.000683591f, -2.28439e+27f, -2.29076e+27f
7238path.lineTo(SkBits2Float(0x3300007f), SkBits2Float(0x33d83333)); // 2.98028e-08f, 1.00676e-07f
7239path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7240path.close();
7241path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7242path.quadTo(SkBits2Float(0x9e9ea900), SkBits2Float(0x33ececec), SkBits2Float(0xececec33), SkBits2Float(0xec336e6e)); // -1.67988e-20f, 1.10327e-07f, -2.29138e+27f, -8.67677e+26f
7243path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7244path.close();
7245path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7246path.lineTo(SkBits2Float(0xedededed), SkBits2Float(0xedededed)); // -9.20445e+27f, -9.20445e+27f
7247path.lineTo(SkBits2Float(0xecececec), SkBits2Float(0xecececec)); // -2.2914e+27f, -2.2914e+27f
7248path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7249path.close();
7250path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7251path.lineTo(SkBits2Float(0x01003300), SkBits2Float(0x33d83333)); // 2.35465e-38f, 1.00676e-07f
7252path.quadTo(SkBits2Float(0xecec3333), SkBits2Float(0x04eeedec), SkBits2Float(0xe0e0e0e0), SkBits2Float(0x9ee0e0e0)); // -2.28439e+27f, 5.6172e-36f, -1.29634e+20f, -2.38099e-20f
7253path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7254path.close();
7255path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
7256path.cubicTo(SkBits2Float(0x299e9e9e), SkBits2Float(0xecececec), SkBits2Float(0xececb6ec), SkBits2Float(0xf0ececec), SkBits2Float(0x0000ecec), SkBits2Float(0x9ebe6e6e)); // 7.04413e-14f, -2.2914e+27f, -2.28936e+27f, -5.86599e+29f, 8.49916e-41f, -2.01627e-20f
7257path.cubicTo(SkBits2Float(0x9e9e9e9e), SkBits2Float(0xe8009e9e), SkBits2Float(0x9e9e9e9e), SkBits2Float(0xecec9e9e), SkBits2Float(0xec3333ec), SkBits2Float(0xececf0ec)); // -1.67945e-20f, -2.42956e+24f, -1.67945e-20f, -2.28844e+27f, -8.66572e+26f, -2.29155e+27f
7258
7259 SkPath path2(path);
7260 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
7261}
7262
7263static void fuzz763_25(skiatest::Reporter* reporter, const char* filename) {
7264 SkPath path;
7265 path.setFillType((SkPath::FillType) 1);
7266path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f
7267path.conicTo(SkBits2Float(0x653140d9), SkBits2Float(0x6a4b4f74), SkBits2Float(0x65906630), SkBits2Float(0x6a25a070), SkBits2Float(0x3f6728a2)); // 5.23159e+22f, 6.14468e+25f, 8.52382e+22f, 5.00576e+25f, 0.902964f
7268path.cubicTo(SkBits2Float(0x68295bc5), SkBits2Float(0x00000000), SkBits2Float(0x682958ff), SkBits2Float(0x00000000), SkBits2Float(0x68286829), SkBits2Float(0x00000000)); // 3.19909e+24f, 0, 3.19889e+24f, 0, 3.18112e+24f, 0
7269path.lineTo(SkBits2Float(0x68555b29), SkBits2Float(0x00000000)); // 4.03018e+24f, 0
7270path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x682d2927), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6829686f)); // 0, 3.27091e+24f, 0, 0, 3.20003e+24f
7271path.lineTo(SkBits2Float(0xdf218a28), SkBits2Float(0x00000000)); // -1.16402e+19f, 0
7272path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f
7273path.close();
7274path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7275path.conicTo(SkBits2Float(0x6642c40c), SkBits2Float(0x00000000), SkBits2Float(0x65906630), SkBits2Float(0x6a25a070), SkBits2Float(0x3edcd74d)); // 2.29939e+23f, 0, 8.52382e+22f, 5.00576e+25f, 0.43133f
7276path.conicTo(SkBits2Float(0x68295afa), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x4277a57b)); // 3.19903e+24f, 0, 0, 0, 61.9116f
7277path.close();
7278
7279 SkPath path1(path);
7280 path.reset();
7281 path.setFillType((SkPath::FillType) 0);
7282
7283 SkPath path2(path);
7284 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
7285}
7286
7287
7288static void fuzz763_26(skiatest::Reporter* reporter, const char* filename) {
7289 SkPath path;
7290 path.setFillType((SkPath::FillType) 0);
7291
7292 SkPath path1(path);
7293 path.reset();
7294 path.setFillType((SkPath::FillType) 0);
7295path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7296path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc003210a)); // 3.60396e-20f, -2.04889f
7297path.cubicTo(SkBits2Float(0x68372d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.46012e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7298path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.61207e+25f
7299path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
7300path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f
7301path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
7302path.close();
7303path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
7304path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7305path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7306path.conicTo(SkBits2Float(0x68385b2d), SkBits2Float(0x555bf055), SkBits2Float(0x2a1f2a8c), SkBits2Float(0x03212121), SkBits2Float(0x5a4b7bc0)); // 3.48239e+24f, 1.51141e+13f, 1.41368e-13f, 4.73517e-37f, 1.43189e+16f
7307path.conicTo(SkBits2Float(0xc08c2aed), SkBits2Float(0x211f2108), SkBits2Float(0x6a4b7b03), SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // -4.38024f, 5.3915e-19f, 6.14982e+25f, 3.20982e+24f, 1.21279e-11f
7308path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
7309path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 1.31626e+28f, 4.7323e-37f, 6.14991e+25f, 75739
7310path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
7311path.close();
7312path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
7313path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f
7314path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
7315path.close();
7316path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
7317path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2127ed29)); // 2.25206e-21f, 300.343f, 0.000650423f, 5.68957e-19f
7318path.conicTo(SkBits2Float(0x03210831), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x6829ed27), SkBits2Float(0x55555b2d), SkBits2Float(0x1e2a3a2a)); // 4.73231e-37f, 6.14991e+25f, 3.20982e+24f, 1.46617e+13f, 9.01175e-21f
7319path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2769), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21512727)); // 2.22225e-15f, 0.000713936f, -732.486f, -1.90686e+27f, 7.08638e-19f
7320path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
7321path.close();
7322path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
7323path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x5b2d5529)); // 4.03114e+24f, 4.87888e+16f
7324path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0xc0032108)); // 3.60404e-20f, -2.04889f
7325path.cubicTo(SkBits2Float(0x68572d55), SkBits2Float(0xf05bd24b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0xed4b7bc0)); // 4.06458e+24f, -2.72126e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, -3.93594e+27f
7326path.conicTo(SkBits2Float(0x212a8c6a), SkBits2Float(0x0329081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77841e-19f, 4.9674e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
7327path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
7328path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f
7329path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
7330path.close();
7331path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
7332path.lineTo(SkBits2Float(0x555b1b29), SkBits2Float(0x6c212a8c)); // 1.50569e+13f, 7.79352e+26f
7333path.conicTo(SkBits2Float(0x084b0321), SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a), SkBits2Float(0x8c5bf055), SkBits2Float(0x1f212a3a)); // 6.10918e-34f, 1.16348e+26f, 0.000209024f, -1.69435e-31f, 3.4128e-20f
7334path.conicTo(SkBits2Float(0x290321d9), SkBits2Float(0x555b2d68), SkBits2Float(0x2a8c558c), SkBits2Float(0x2a212a1f), SkBits2Float(0x7bc00321)); // 2.91172e-14f, 1.50618e+13f, 2.49284e-13f, 1.43143e-13f, 1.99397e+36f
7335path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
7336path.close();
7337path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
7338path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x1f2128c0)); // -1.31678e-31f, 3.41268e-20f
7339path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
7340path.close();
7341
7342 SkPath path2(path);
7343 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
7344}
7345
7346static void fuzz763_28(skiatest::Reporter* reporter, const char* filename) {
7347 SkPath path;
7348 path.setFillType((SkPath::FillType) 0);
7349
7350 SkPath path1(path);
7351 path.reset();
7352 path.setFillType((SkPath::FillType) 0);
7353path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7354path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7355path.cubicTo(SkBits2Float(0x68302d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a1f2a), SkBits2Float(0x0321082a), SkBits2Float(0x6aa37bc0)); // 3.32789e+24f, -2.71613e+29f, -1.64207e-31f, 5.76395e-19f, 4.7323e-37f, 9.88197e+25f
7356path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2d28ed84), SkBits2Float(0x5b2d2955)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.60243e-12f, 4.87406e+16f
7357path.moveTo(SkBits2Float(0x6c395b2d), SkBits2Float(0xf0682955)); // 8.96327e+26f, -2.87402e+29f
7358path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2aef8c55), SkBits2Float(0x68295b2d), SkBits2Float(0x21086855), SkBits2Float(0x4b7bc003)); // 5.76397e-19f, 4.25523e-13f, 3.19905e+24f, 4.62167e-19f, 1.64987e+07f
7359path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7360path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7361path.lineTo(SkBits2Float(0x8a283a28), SkBits2Float(0x284f1a3a)); // -8.09984e-33f, 1.14965e-14f
7362path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f
7363path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f
7364path.conicTo(SkBits2Float(0x381f203a), SkBits2Float(0x2ac422c5), SkBits2Float(0xc25d27ec), SkBits2Float(0x3a705921), SkBits2Float(0x2a105152)); // 3.79386e-05f, 3.48407e-13f, -55.289f, 0.000916855f, 1.2818e-13f
7365path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x683a5b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.52017e+24f
7366path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f
7367path.conicTo(SkBits2Float(0xaa8c555b), SkBits2Float(0x081f2a21), SkBits2Float(0x5b2d0321), SkBits2Float(0x68556829), SkBits2Float(0x2a552d29)); // -2.49282e-13f, 4.78968e-34f, 4.86986e+16f, 4.03114e+24f, 1.89339e-13f
7368path.cubicTo(SkBits2Float(0x21295b2d), SkBits2Float(0x2a688c5b), SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x8c08555b), SkBits2Float(0x2a2a29ca)); // 5.73801e-19f, 2.06544e-13f, 3.19905e+24f, 9.6297e-12f, -1.05027e-31f, 1.51135e-13f
7369path.quadTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f
7370path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7371path.close();
7372path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7373path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x5b2d6829), SkBits2Float(0x1f212a55), SkBits2Float(0x8ced7aba), SkBits2Float(0x3f2a212a)); // 6.14991e+25f, 4.88097e+16f, 3.41281e-20f, -3.65895e-31f, 0.664569f
7374path.lineTo(SkBits2Float(0x5b2d212d), SkBits2Float(0x2d556829)); // 4.87316e+16f, 1.21308e-11f
7375path.moveTo(SkBits2Float(0x68552968), SkBits2Float(0x5568295b)); // 4.02651e+24f, 1.5954e+13f
7376path.moveTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55)); // 4.87407e+16f, 5.7784e-19f
7377path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
7378path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x2147ed7a), SkBits2Float(0x28282a3a)); // 5.77848e-19f, 4.7323e-37f, 5.63611e+25f, 6.77381e-19f, 9.33503e-15f
7379
7380 SkPath path2(path);
7381 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
7382}
7383
7384static void fuzz763_27(skiatest::Reporter* reporter, const char* filename) {
7385 SkPath path;
7386 path.setFillType((SkPath::FillType) 0);
7387
7388 SkPath path1(path);
7389 path.reset();
7390 path.setFillType((SkPath::FillType) 0);
7391path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7392path.quadTo(SkBits2Float(0x30309ab8), SkBits2Float(0x305b3030), SkBits2Float(0x00f53030), SkBits2Float(0x3a3a0000)); // 6.42483e-10f, 7.97402e-10f, 2.2517e-38f, 0.000709534f
7393path.quadTo(SkBits2Float(0xb8b8d5b8), SkBits2Float(0x0b0b0b03), SkBits2Float(0x0b0b0b0b), SkBits2Float(0x3a3a0b0b)); // -8.81361e-05f, 2.67787e-32f, 2.67787e-32f, 0.000709698f
7394path.quadTo(SkBits2Float(0xb8b8b8b8), SkBits2Float(0x0b1203b8), SkBits2Float(0x0b0b0b0b), SkBits2Float(0x3a3a2110)); // -8.80821e-05f, 2.81214e-32f, 2.67787e-32f, 0.000710026f
7395
7396 SkPath path2(path);
7397 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
7398}
7399
7400static void fuzz763_29(skiatest::Reporter* reporter, const char* filename) {
7401 SkPath path;
7402 path.setFillType((SkPath::FillType) 1);
7403path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7404path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x743e0000)); // 0, 6.02134e+31f
7405path.cubicTo(SkBits2Float(0x74083cf1), SkBits2Float(0x74536e73), SkBits2Float(0x742ac4e4), SkBits2Float(0x7415f5be), SkBits2Float(0x7433ee3c), SkBits2Float(0x7405a69a)); // 4.31756e+31f, 6.70053e+31f, 5.41189e+31f, 4.75242e+31f, 5.70223e+31f, 4.23556e+31f
7406path.quadTo(SkBits2Float(0x74360ca0), SkBits2Float(0x7401e10c), SkBits2Float(0x7436a382), SkBits2Float(0x7401cc18)); // 5.76937e+31f, 4.11603e+31f, 5.78805e+31f, 4.11344e+31f
7407path.cubicTo(SkBits2Float(0x74374a91), SkBits2Float(0x7401ef19), SkBits2Float(0x74375c84), SkBits2Float(0x7404d9b9), SkBits2Float(0x7437868f), SkBits2Float(0x740bae8a)); // 5.80873e+31f, 4.11777e+31f, 5.81095e+31f, 4.2102e+31f, 5.81616e+31f, 4.42669e+31f
7408path.cubicTo(SkBits2Float(0x7437d6c1), SkBits2Float(0x7418b629), SkBits2Float(0x74387e9b), SkBits2Float(0x7433fbc5), SkBits2Float(0x743e2ff7), SkBits2Float(0x74655fa2)); // 5.82609e+31f, 4.83962e+31f, 5.84687e+31f, 5.7039e+31f, 6.02728e+31f, 7.26914e+31f
7409path.cubicTo(SkBits2Float(0x741ada75), SkBits2Float(0x74745717), SkBits2Float(0x73c106b4), SkBits2Float(0x74744e64), SkBits2Float(0x00000000), SkBits2Float(0x74744006)); // 4.9075e+31f, 7.74345e+31f, 3.05862e+31f, 7.74237e+31f, 0, 7.74059e+31f
7410path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x74746c7c), SkBits2Float(0x74244dce), SkBits2Float(0x7474733e), SkBits2Float(0x74400000), SkBits2Float(0x74747445)); // 0, 7.7461e+31f, 5.207e+31f, 7.74693e+31f, 6.08472e+31f, 7.74706e+31f
7411path.cubicTo(SkBits2Float(0x743f5854), SkBits2Float(0x746f3659), SkBits2Float(0x743ebe05), SkBits2Float(0x746a3017), SkBits2Float(0x743e2ff7), SkBits2Float(0x74655fa2)); // 6.06397e+31f, 7.58094e+31f, 6.04486e+31f, 7.42171e+31f, 6.02728e+31f, 7.26914e+31f
7412path.cubicTo(SkBits2Float(0x7447a582), SkBits2Float(0x74615dee), SkBits2Float(0x744f74f6), SkBits2Float(0x745c4903), SkBits2Float(0x7455e7e6), SkBits2Float(0x7455d751)); // 6.32705e+31f, 7.14216e+31f, 6.57457e+31f, 6.98112e+31f, 6.77895e+31f, 6.77689e+31f
7413path.cubicTo(SkBits2Float(0x74747474), SkBits2Float(0x743750a4), SkBits2Float(0x74747474), SkBits2Float(0x73f46f0d), SkBits2Float(0x74747474), SkBits2Float(0x00000000)); // 7.74708e+31f, 5.80948e+31f, 7.74708e+31f, 3.87321e+31f, 7.74708e+31f, 0
7414path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7415path.close();
7416
7417 SkPath path1(path);
7418 path.reset();
7419 path.setFillType((SkPath::FillType) 0);
7420path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7421path.lineTo(SkBits2Float(0xf0682955), SkBits2Float(0x211f5b2d)); // -2.87402e+29f, 5.3992e-19f
7422path.moveTo(SkBits2Float(0x2d2aff2d), SkBits2Float(0x74747474)); // 9.72004e-12f, 7.74708e+31f
7423path.cubicTo(SkBits2Float(0x7474748e), SkBits2Float(0x74747490), SkBits2Float(0x8c722174), SkBits2Float(0x181f0080), SkBits2Float(0x74c0e520), SkBits2Float(0x747d7463)); // 7.7471e+31f, 7.7471e+31f, -1.86531e-31f, 2.05505e-24f, 1.22262e+32f, 8.0323e+31f
7424path.cubicTo(SkBits2Float(0x7b005e4b), SkBits2Float(0xdf3a6a3a), SkBits2Float(0x2a3a2848), SkBits2Float(0x2d2d7821), SkBits2Float(0x8c55212d), SkBits2Float(0x2d2d2d24)); // 6.66526e+35f, -1.34326e+19f, 1.65341e-13f, 9.86059e-12f, -1.64189e-31f, 9.84393e-12f
7425path.conicTo(SkBits2Float(0xde28804c), SkBits2Float(0x28e03721), SkBits2Float(0x3329df28), SkBits2Float(0x2d291515), SkBits2Float(0x0568295b)); // -3.03545e+18f, 2.48929e-14f, 3.95513e-08f, 9.61122e-12f, 1.09162e-35f
7426path.conicTo(SkBits2Float(0x556a2d21), SkBits2Float(0x21088c2a), SkBits2Float(0x3a333303), SkBits2Float(0x5b293a8a), SkBits2Float(0x6855683b)); // 1.60925e+13f, 4.62641e-19f, 0.000683591f, 4.76336e+16f, 4.03115e+24f
7427
7428 SkPath path2(path);
7429 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
7430}
7431
7432static void fuzz763_30(skiatest::Reporter* reporter, const char* filename) {
7433 SkPath path;
7434 path.setFillType((SkPath::FillType) 1);
7435
7436 SkPath path1(path);
7437 path.reset();
7438 path.setFillType((SkPath::FillType) 0);
7439path.moveTo(SkBits2Float(0x1f2108c0), SkBits2Float(0x4b7b0321)); // 3.41003e-20f, 1.64503e+07f
7440path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f
7441path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
7442path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x2a4b7bc0), SkBits2Float(0x68295b2d)); // 2.49282e-13f, 1.31626e+28f, 4.7323e-37f, 1.8073e-13f, 3.19905e+24f
7443path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55)); // 4.87407e+16f, 5.7784e-19f
7444path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x4b7b28c0)); // 4.7323e-37f, 1.646e+07f
7445path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x2d081f21)); // 2.50338e-13f, 7.73762e-12f
7446path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7447path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7448path.cubicTo(SkBits2Float(0x69392d55), SkBits2Float(0x2d5b684b), SkBits2Float(0x8c5527f0), SkBits2Float(0x212a1f2a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 1.39916e+25f, 1.24719e-11f, -1.64209e-31f, 5.76395e-19f, 4.7323e-37f, 6.14991e+25f
7449path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0xed7a6a1f), SkBits2Float(0x3a214793), SkBits2Float(0x3328282a), SkBits2Float(0x3a8a3adf)); // 5.77848e-19f, -4.84372e+27f, 0.000615233f, 3.91521e-08f, 0.00105461f
7450path.conicTo(SkBits2Float(0x4be80304), SkBits2Float(0xdcdcdc15), SkBits2Float(0xdcdcdcdc), SkBits2Float(0x71dcdcdc), SkBits2Float(0x6c107164)); // 3.04102e+07f, -4.97332e+17f, -4.97339e+17f, 2.18732e+30f, 6.98483e+26f
7451path.conicTo(SkBits2Float(0x6c0f1d6c), SkBits2Float(0x8e406c6e), SkBits2Float(0x6c6c0200), SkBits2Float(0x6c6ce46c), SkBits2Float(0x6c6c6c6c)); // 6.92061e+26f, -2.3718e-30f, 1.14126e+27f, 1.14554e+27f, 1.14327e+27f
7452path.lineTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7453path.close();
7454path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7455path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x3ac22c21), SkBits2Float(0x6c401057), SkBits2Float(0x6d6d6b64)); // 0.00136978f, 0.00148142f, 9.28764e+26f, 4.59236e+27f
7456path.cubicTo(SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x286d6d6d), SkBits2Float(0x081d2a29), SkBits2Float(0x6d690321), SkBits2Float(0x6b6b026d)); // 4.59251e+27f, 4.59251e+27f, 1.31799e-14f, 4.7295e-34f, 4.50711e+27f, 2.84109e+26f
7457
7458 SkPath path2(path);
7459 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
7460}
7461
7462static void fuzz763_31(skiatest::Reporter* reporter, const char* filename) {
7463 SkPath path;
7464 path.setFillType((SkPath::FillType) 1);
7465
7466 SkPath path1(path);
7467 path.reset();
7468 path.setFillType((SkPath::FillType) 0);
7469path.moveTo(SkBits2Float(0xd72a8c55), SkBits2Float(0x61081f2a)); // -1.8752e+14f, 1.56938e+20f
7470path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0xdf3a2128), SkBits2Float(0x471ac575)); // 6.14991e+25f, 75739, 9.4495e-15f, -1.3412e+19f, 39621.5f
7471path.lineTo(SkBits2Float(0x28404040), SkBits2Float(0x552a298a)); // 1.06721e-14f, 1.16935e+13f
7472path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
7473path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x80ed7a3a), SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828), SkBits2Float(0x4f1a3a3a)); // 6.14991e+25f, -2.18089e-38f, 1.65317e-13f, -1.16126e+19f, 2.58751e+09f
7474path.lineTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
7475path.close();
7476path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
7477path.cubicTo(SkBits2Float(0x3ac2213a), SkBits2Float(0x432a2928), SkBits2Float(0x96812be6), SkBits2Float(0x272a1d2a), SkBits2Float(0x3a2a3529), SkBits2Float(0x3b1e2ab0)); // 0.00148109f, 170.161f, -2.08688e-25f, 2.3608e-15f, 0.000649291f, 0.00241343f
7478path.lineTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
7479path.close();
7480path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
7481path.cubicTo(SkBits2Float(0xc5272927), SkBits2Float(0x22383b39), SkBits2Float(0x1051523a), SkBits2Float(0x2927b029), SkBits2Float(0x685b2d27), SkBits2Float(0x5b2d6855)); // -2674.57f, 2.4968e-18f, 4.12813e-29f, 3.72342e-14f, 4.14012e+24f, 4.88099e+16f
7482
7483 SkPath path2(path);
7484 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
7485}
7486
7487static void fuzz763_33(skiatest::Reporter* reporter, const char* filename) {
7488 SkPath path;
7489 path.setFillType((SkPath::FillType) 1);
7490path.moveTo(SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 7.66623e+30f, 7.66608e+30f
7491path.quadTo(SkBits2Float(0x724341bf), SkBits2Float(0x72433fc4), SkBits2Float(0x6d757575), SkBits2Float(0x6d6d6d6d)); // 3.86746e+30f, 3.86731e+30f, 4.74786e+27f, 4.59251e+27f
7492path.cubicTo(SkBits2Float(0x6d18b5e5), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6cbe03bd), SkBits2Float(0x6d4b455b), SkBits2Float(0x6c6c69d8), SkBits2Float(0x6d20df31)); // 2.95385e+27f, 4.59251e+27f, 1.83771e+27f, 3.93183e+27f, 1.14323e+27f, 3.11171e+27f
7493path.conicTo(SkBits2Float(0x6c6c8b72), SkBits2Float(0x00000000), SkBits2Float(0x6c6c6c6c), SkBits2Float(0x00000000), SkBits2Float(0x400812df)); // 1.14386e+27f, 0, 1.14327e+27f, 0, 2.12615f
7494path.quadTo(SkBits2Float(0x72432acb), SkBits2Float(0x72432295), SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 3.86568e+30f, 3.86505e+30f, 7.66623e+30f, 7.66608e+30f
7495path.close();
7496path.moveTo(SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 7.66623e+30f, 7.66608e+30f
7497path.cubicTo(SkBits2Float(0x74f97d76), SkBits2Float(0x74f97d90), SkBits2Float(0x75381628), SkBits2Float(0x7538182c), SkBits2Float(0x7538153b), SkBits2Float(0x75381835)); // 1.58133e+32f, 1.58133e+32f, 2.33357e+32f, 2.33367e+32f, 2.33353e+32f, 2.33368e+32f
7498path.cubicTo(SkBits2Float(0x7538144e), SkBits2Float(0x7538183f), SkBits2Float(0x74f9760f), SkBits2Float(0x74f97ddd), SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 2.33348e+32f, 2.33368e+32f, 1.58115e+32f, 1.58134e+32f, 7.66623e+30f, 7.66608e+30f
7499path.close();
7500path.moveTo(SkBits2Float(0x6c6c69d8), SkBits2Float(0x6d20df31)); // 1.14323e+27f, 3.11171e+27f
7501path.conicTo(SkBits2Float(0x6c6c55ae), SkBits2Float(0x6d80b520), SkBits2Float(0x6c6c1071), SkBits2Float(0x6e0f1d6c), SkBits2Float(0x3f96e656)); // 1.14284e+27f, 4.97913e+27f, 1.14154e+27f, 1.1073e+28f, 1.1789f
7502path.lineTo(SkBits2Float(0x6a674231), SkBits2Float(0x6c0c3394)); // 6.98936e+25f, 6.77973e+26f
7503path.cubicTo(SkBits2Float(0x6b12c63f), SkBits2Float(0x6c881439), SkBits2Float(0x6bba4ae5), SkBits2Float(0x6ced1e23), SkBits2Float(0x6c6c69d8), SkBits2Float(0x6d20df31)); // 1.77439e+26f, 1.31608e+27f, 4.50428e+26f, 2.29326e+27f, 1.14323e+27f, 3.11171e+27f
7504path.close();
7505
7506 SkPath path1(path);
7507 path.reset();
7508 path.setFillType((SkPath::FillType) 0);
7509path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7510path.lineTo(SkBits2Float(0x6c6b6ba7), SkBits2Float(0x886b6b6b)); // 1.13842e+27f, -7.0844e-34f
7511path.quadTo(SkBits2Float(0x0000206b), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d)); // 1.16294e-41f, 4.59251e+27f, 4.59251e+27f, 4.59251e+27f
7512path.conicTo(SkBits2Float(0x3e3e3e3e), SkBits2Float(0xafbcad20), SkBits2Float(0x78787878), SkBits2Float(0x78787829), SkBits2Float(0x78787878)); // 0.185784f, -3.432e-10f, 2.01583e+34f, 2.01582e+34f, 2.01583e+34f
7513path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x95066b78)); // 2.01583e+34f, -2.71459e-26f
7514path.lineTo(SkBits2Float(0x6c6b6ba7), SkBits2Float(0x886b6b6b)); // 1.13842e+27f, -7.0844e-34f
7515path.quadTo(SkBits2Float(0x0000206b), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d)); // 1.16294e-41f, 4.59251e+27f, 4.59251e+27f, 4.59251e+27f
7516path.conicTo(SkBits2Float(0x3e3e3e3e), SkBits2Float(0xafbcad20), SkBits2Float(0x78787878), SkBits2Float(0x78787829), SkBits2Float(0x78787878)); // 0.185784f, -3.432e-10f, 2.01583e+34f, 2.01582e+34f, 2.01583e+34f
7517path.lineTo(SkBits2Float(0x8787878f), SkBits2Float(0x87878787)); // -2.03922e-34f, -2.03922e-34f
7518path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
7519path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
7520path.lineTo(SkBits2Float(0x6c105778), SkBits2Float(0x6d406b64)); // 6.97994e+26f, 3.72193e+27f
7521path.cubicTo(SkBits2Float(0x7575756d), SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x6d6d7575), SkBits2Float(0x6d6d6d6d)); // 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 4.59312e+27f, 4.59251e+27f
7522path.cubicTo(SkBits2Float(0x6d696d6d), SkBits2Float(0x026d6d6d), SkBits2Float(0x80bc6b6b), SkBits2Float(0xaebcdfd0), SkBits2Float(0x7878bcac), SkBits2Float(0x78787878)); // 4.51514e+27f, 1.74434e-37f, -1.73036e-38f, -8.58901e-11f, 2.01799e+34f, 2.01583e+34f
7523path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
7524path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
7525path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
7526path.lineTo(SkBits2Float(0xb4bcacbc), SkBits2Float(0xbcadbcbc)); // -3.51434e-07f, -0.0212082f
7527path.moveTo(SkBits2Float(0xa03aacbc), SkBits2Float(0x757575a0)); // -1.5812e-19f, 3.11157e+32f
7528path.close();
7529
7530 SkPath path2(path);
7531 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
7532}
7533
7534static void fuzz763_32(skiatest::Reporter* reporter, const char* filename) {
7535 SkPath path;
7536 path.setFillType((SkPath::FillType) 1);
7537
7538 SkPath path1(path);
7539 path.reset();
7540 path.setFillType((SkPath::FillType) 0);
7541path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7542path.cubicTo(SkBits2Float(0xdedcdcdc), SkBits2Float(0xdcdcdcdc), SkBits2Float(0xdcdcdcdc), SkBits2Float(0xdcdcdcdc), SkBits2Float(0x55dcdcdc), SkBits2Float(0x29407d7f)); // -7.95742e+18f, -4.97339e+17f, -4.97339e+17f, -4.97339e+17f, 3.03551e+13f, 4.27414e-14f
7543path.cubicTo(SkBits2Float(0x7b93ed4b), SkBits2Float(0x29521472), SkBits2Float(0xdfc83c28), SkBits2Float(0x1a3a834e), SkBits2Float(0x6855e84f), SkBits2Float(0xf2f22a80)); // 1.53616e+36f, 4.66471e-14f, -2.88569e+19f, 3.857e-23f, 4.0406e+24f, -9.59318e+30f
7544path.moveTo(SkBits2Float(0xe0f2f210), SkBits2Float(0xc3f2eef2)); // -1.40049e+20f, -485.867f
7545path.cubicTo(SkBits2Float(0x108ced7a), SkBits2Float(0x7bc00308), SkBits2Float(0x287a6a3a), SkBits2Float(0x242847ed), SkBits2Float(0x2bcb302a), SkBits2Float(0xf21003e8)); // 5.55862e-29f, 1.99396e+36f, 1.39008e-14f, 3.64901e-17f, 1.44374e-12f, -2.85252e+30f
7546path.moveTo(SkBits2Float(0x556c0010), SkBits2Float(0x002a8768)); // 1.62178e+13f, 3.90567e-39f
7547path.quadTo(SkBits2Float(0xf2f22021), SkBits2Float(0xf2f2f56e), SkBits2Float(0xf2f2f2f2), SkBits2Float(0xf22040d9)); // -9.59158e+30f, -9.62459e+30f, -9.6242e+30f, -3.17414e+30f
7548path.lineTo(SkBits2Float(0xc013f2f2), SkBits2Float(0x0000294d)); // -2.3117f, 1.48159e-41f
7549
7550 SkPath path2(path);
7551 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
7552}
7553
7554static void fuzz763_34(skiatest::Reporter* reporter, const char* filename) {
7555 SkPath path;
7556 path.setFillType((SkPath::FillType) 1);
7557path.moveTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f
7558path.quadTo(SkBits2Float(0x63690f37), SkBits2Float(0x6d0a3d9b), SkBits2Float(0x00000000), SkBits2Float(0x6d3e3e3e)); // 4.29919e+21f, 2.67396e+27f, 0, 3.67984e+27f
7559path.conicTo(SkBits2Float(0x6b9253fc), SkBits2Float(0x6c956a8b), SkBits2Float(0x6c6ac798), SkBits2Float(0x692a5d27), SkBits2Float(0x3e56eb72)); // 3.538e+26f, 1.44506e+27f, 1.13532e+27f, 1.28723e+25f, 0.209883f
7560path.lineTo(SkBits2Float(0x6c6c586c), SkBits2Float(0x00000000)); // 1.1429e+27f, 0
7561path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7562path.conicTo(SkBits2Float(0x6c8c6c6c), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6cc8e82a), SkBits2Float(0x5b684b68)); // 1.35809e+27f, 0, 0, 1.94305e+27f, 6.53851e+16f
7563path.lineTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f
7564path.close();
7565path.moveTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f
7566path.quadTo(SkBits2Float(0x641ae35f), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 1.14287e+22f, 0, 0, 0
7567path.lineTo(SkBits2Float(0x6c6c586c), SkBits2Float(0x00000000)); // 1.1429e+27f, 0
7568path.conicTo(SkBits2Float(0x6c6ba1fc), SkBits2Float(0x688c9eb1), SkBits2Float(0x6c6ac798), SkBits2Float(0x692a5d27), SkBits2Float(0x3f7fec32)); // 1.13945e+27f, 5.31247e+24f, 1.13532e+27f, 1.28723e+25f, 0.999698f
7569path.lineTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f
7570path.close();
7571
7572 SkPath path1(path);
7573 path.reset();
7574 path.setFillType((SkPath::FillType) 0);
7575path.moveTo(SkBits2Float(0x6c3e3e3e), SkBits2Float(0x586c79ff)); // 9.19959e+26f, 1.04003e+15f
7576path.quadTo(SkBits2Float(0x6c6c4a6c), SkBits2Float(0x6c6c6c6c), SkBits2Float(0xc83e6c6c), SkBits2Float(0x3e313e3e)); // 1.14263e+27f, 1.14327e+27f, -194994, 0.173089f
7577
7578 SkPath path2(path);
7579 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
7580}
7581
7582static void fuzz763_36(skiatest::Reporter* reporter, const char* filename) {
7583 SkPath path;
7584 path.setFillType((SkPath::FillType) 0);
7585
7586 SkPath path1(path);
7587 path.reset();
7588 path.setFillType((SkPath::FillType) 0);
7589path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
7590path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
7591path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 6.14991e+25f
7592path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x2d555b2d)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 1.21279e-11f
7593path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
7594path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x8cef552a), SkBits2Float(0x295b2d2a), SkBits2Float(0x68210368), SkBits2Float(0x7bc05508)); // 5.76397e-19f, -3.6875e-31f, 4.86669e-14f, 3.04146e+24f, 1.99729e+36f
7595path.lineTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
7596path.close();
7597path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
7598path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7599path.conicTo(SkBits2Float(0x212a081f), SkBits2Float(0x4b7bc003), SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556839), SkBits2Float(0x2a8c555b)); // 5.7609e-19f, 1.64987e+07f, 4.88298e+16f, -2.64185e+29f, 2.49282e-13f
7600path.conicTo(SkBits2Float(0xf42a212a), SkBits2Float(0x4b7bc003), SkBits2Float(0x2aed7a39), SkBits2Float(0x2108c08c), SkBits2Float(0x7b03211f)); // -5.39162e+31f, 1.64987e+07f, 4.21845e-13f, 4.63334e-19f, 6.80863e+35f
7601path.lineTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
7602path.close();
7603path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
7604path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f
7605path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7606path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x212a1f72), SkBits2Float(0x03210807), SkBits2Float(0x6a4b7b28), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 5.76399e-19f, 4.73229e-37f, 6.14984e+25f, 75739
7607path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7608path.close();
7609path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7610path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3adf21), SkBits2Float(0x284f1a3a), SkBits2Float(0x213ab38a)); // 9.4456e-15f, -8.99754e-33f, 1.14965e-14f, 6.32569e-19f
7611path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7612path.close();
7613path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7614path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a20002a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000610354f, 2.50336e-13f
7615path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7616path.close();
7617path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7618path.conicTo(SkBits2Float(0xed210830), SkBits2Float(0xc04b6a03), SkBits2Float(0x68297b27), SkBits2Float(0x55555b2d), SkBits2Float(0x2ab03a2a)); // -3.11481e+27f, -3.17835f, 3.20141e+24f, 1.46617e+13f, 3.13042e-13f
7619path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4341f20), SkBits2Float(0xecc52a22)); // 2.22225e-15f, 0.000713932f, -720.486f, -1.90686e+27f
7620path.cubicTo(SkBits2Float(0x5921c25d), SkBits2Float(0x29523a70), SkBits2Float(0x555b2d68), SkBits2Float(0x1f212a8c), SkBits2Float(0x0321d90a), SkBits2Float(0x5b2d6829)); // 2.8457e+15f, 4.66801e-14f, 1.50618e+13f, 3.41283e-20f, 4.75628e-37f, 4.88097e+16f
7621path.lineTo(SkBits2Float(0x1f2a2a8c), SkBits2Float(0x03210821)); // 3.60341e-20f, 4.7323e-37f
7622path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7623path.close();
7624path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7625path.conicTo(SkBits2Float(0x2eed6a7a), SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28), SkBits2Float(0x4f1a3a8a), SkBits2Float(0x3ab38a28)); // 1.07964e-10f, 9.4495e-15f, 0.000617492f, 2.58753e+09f, 0.00136978f
7626path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7627path.close();
7628path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7629path.quadTo(SkBits2Float(0xe61d2a28), SkBits2Float(0x2a43962b), SkBits2Float(0x29272a81), SkBits2Float(0x2bb02a55)); // -1.85547e+23f, 1.73716e-13f, 3.71183e-14f, 1.25173e-12f
7630path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3ac52729), SkBits2Float(0xc4223b32), SkBits2Float(0x6c2a201f)); // 2.22225e-15f, 0.00150416f, -648.925f, 8.22676e+26f
7631
7632 SkPath path2(path);
7633 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
7634}
7635
7636static void fuzz763_35(skiatest::Reporter* reporter, const char* filename) {
7637 SkPath path;
7638 path.setFillType((SkPath::FillType) 1);
7639
7640 SkPath path1(path);
7641 path.reset();
7642 path.setFillType((SkPath::FillType) 0);
7643path.moveTo(SkBits2Float(0x2aed2a8c), SkBits2Float(0x03210a1f)); // 4.21292e-13f, 4.73253e-37f
7644path.conicTo(SkBits2Float(0x0000007b), SkBits2Float(0x7474747f), SkBits2Float(0x74747474), SkBits2Float(0x747474c4), SkBits2Float(0x74747474)); // 1.7236e-43f, 7.74709e+31f, 7.74708e+31f, 7.74712e+31f, 7.74708e+31f
7645path.quadTo(SkBits2Float(0x74747474), SkBits2Float(0x74747474), SkBits2Float(0x20437474), SkBits2Float(0x43a52b02)); // 7.74708e+31f, 7.74708e+31f, 1.65557e-19f, 330.336f
7646path.moveTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f
7647path.lineTo(SkBits2Float(0x4b7bd603), SkBits2Float(0x6cf33b6a)); // 1.65043e+07f, 2.3524e+27f
7648path.conicTo(SkBits2Float(0x35778caa), SkBits2Float(0x0000002a), SkBits2Float(0x74742164), SkBits2Float(0x2a3a7474), SkBits2Float(0x4cc22157)); // 9.22194e-07f, 5.88545e-44f, 7.7368e+31f, 1.65605e-13f, 1.0178e+08f
7649path.cubicTo(SkBits2Float(0x21479321), SkBits2Float(0x23434cc2), SkBits2Float(0x3a214793), SkBits2Float(0x2128282a), SkBits2Float(0x323adf81), SkBits2Float(0x77291a3a)); // 6.76185e-19f, 1.05872e-17f, 0.000615233f, 5.69738e-19f, 1.08774e-08f, 3.42981e+33f
7650path.conicTo(SkBits2Float(0x0000002a), SkBits2Float(0x7474743e), SkBits2Float(0x74747474), SkBits2Float(0x74746474), SkBits2Float(0x74747474)); // 5.88545e-44f, 7.74706e+31f, 7.74708e+31f, 7.7451e+31f, 7.74708e+31f
7651path.cubicTo(SkBits2Float(0x21e7fc06), SkBits2Float(0x2a212a59), SkBits2Float(0x0321081f), SkBits2Float(0x00002a35), SkBits2Float(0x74744000), SkBits2Float(0x2974e874)); // 1.57199e-18f, 1.43144e-13f, 4.7323e-37f, 1.5141e-41f, 7.74059e+31f, 5.43805e-14f
7652path.cubicTo(SkBits2Float(0x74647474), SkBits2Float(0x74747474), SkBits2Float(0x12ec7474), SkBits2Float(0x4cc22147), SkBits2Float(0x47932343), SkBits2Float(0x282a3a21)); // 7.24002e+31f, 7.74708e+31f, 1.49224e-27f, 1.0178e+08f, 75334.5f, 9.4495e-15f
7653path.lineTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f
7654path.close();
7655path.moveTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f
7656path.conicTo(SkBits2Float(0x3a323adf), SkBits2Float(0x4977291a), SkBits2Float(0x0000002a), SkBits2Float(0x7474743e), SkBits2Float(0x74747474)); // 0.000679893f, 1.01237e+06f, 5.88545e-44f, 7.74706e+31f, 7.74708e+31f
7657path.cubicTo(SkBits2Float(0x74747464), SkBits2Float(0x74747474), SkBits2Float(0x21e7fc06), SkBits2Float(0x2a212a59), SkBits2Float(0x0321081f), SkBits2Float(0x00002a35)); // 7.74708e+31f, 7.74708e+31f, 1.57199e-18f, 1.43144e-13f, 4.7323e-37f, 1.5141e-41f
7658path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x742974e8)); // 7.74706e+31f, 5.3703e+31f
7659path.cubicTo(SkBits2Float(0x74746474), SkBits2Float(0x74747474), SkBits2Float(0xd912ec74), SkBits2Float(0x553a3728), SkBits2Float(0x29202a8c), SkBits2Float(0x5555201b)); // 7.7451e+31f, 7.74708e+31f, -2.58471e+15f, 1.27966e+13f, 3.5564e-14f, 1.46459e+13f
7660path.moveTo(SkBits2Float(0x31292768), SkBits2Float(0x212d2aff)); // 2.46151e-09f, 5.86716e-19f
7661path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x323adf81), SkBits2Float(0x77291a3a), SkBits2Float(0x00002a49)); // 5.69738e-19f, 1.08774e-08f, 3.42981e+33f, 1.51691e-41f
7662path.moveTo(SkBits2Float(0x7474743e), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f
7663path.cubicTo(SkBits2Float(0x74747464), SkBits2Float(0x74747474), SkBits2Float(0x21e7fc06), SkBits2Float(0x2a212a59), SkBits2Float(0x0321081f), SkBits2Float(0x00002a35)); // 7.74708e+31f, 7.74708e+31f, 1.57199e-18f, 1.43144e-13f, 4.7323e-37f, 1.5141e-41f
7664path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f
7665path.cubicTo(SkBits2Float(0x74747464), SkBits2Float(0x74747474), SkBits2Float(0x43747474), SkBits2Float(0xa52b0220), SkBits2Float(0x47812a43), SkBits2Float(0x282a3a21)); // 7.74708e+31f, 7.74708e+31f, 244.455f, -1.48326e-16f, 66132.5f, 9.4495e-15f
7666path.lineTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f
7667path.close();
7668path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f
7669path.conicTo(SkBits2Float(0x3a323adf), SkBits2Float(0x19433b1a), SkBits2Float(0x5921e7fc), SkBits2Float(0x1f2a212a), SkBits2Float(0x35032108)); // 0.000679893f, 1.00932e-23f, 2.84828e+15f, 3.60263e-20f, 4.88494e-07f
7670
7671 SkPath path2(path);
7672 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
7673}
7674
7675static void fuzz763_37(skiatest::Reporter* reporter, const char* filename) {
7676 SkPath path;
7677 path.setFillType((SkPath::FillType) 0);
7678path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x5b2d3368)); // 1.59583e+13f, 4.87517e+16f
7679path.conicTo(SkBits2Float(0x5b2d555b), SkBits2Float(0x68275b2d), SkBits2Float(0x21685527), SkBits2Float(0x0321082a), SkBits2Float(0x6ab485c0)); // 4.8789e+16f, 3.16127e+24f, 7.87174e-19f, 4.7323e-37f, 1.09119e+26f
7680path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 4.8745e+16f
7681path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
7682path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2a8cef2a), SkBits2Float(0x682d2953), SkBits2Float(0xee682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 2.50349e-13f, 3.27093e+24f, -1.79601e+28f, 1.64988e+07f
7683path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
7684path.conicTo(SkBits2Float(0x4b03213b), SkBits2Float(0xc07b2a08), SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556830), SkBits2Float(0x2a8c555b)); // 8.59372e+06f, -3.92444f, 4.88298e+16f, -2.64185e+29f, 2.49282e-13f
7685path.conicTo(SkBits2Float(0x0321212a), SkBits2Float(0x4b7bd2c0), SkBits2Float(0xed7ac039), SkBits2Float(0x2f218c08), SkBits2Float(0x1f037b2a)); // 4.73517e-37f, 1.65035e+07f, -4.85023e+27f, 1.46926e-10f, 2.78422e-20f
7686path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
7687path.close();
7688path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
7689path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f
7690path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7691path.conicTo(SkBits2Float(0x721f2a5b), SkBits2Float(0x212a8c55), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7b28), SkBits2Float(0x4793ed7a)); // 3.1526e+30f, 5.7784e-19f, 4.7323e-37f, 6.14984e+25f, 75739
7692path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7693path.close();
7694path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7695path.quadTo(SkBits2Float(0x28282a2a), SkBits2Float(0x2c682921), SkBits2Float(0x8c555bf6), SkBits2Float(0x6d03de30)); // 9.33502e-15f, 3.2992e-12f, -1.64366e-31f, 2.5507e+27f
7696path.cubicTo(SkBits2Float(0x68392d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x081f2a21)); // 3.4979e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 4.78968e-34f
7697path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7698path.close();
7699path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7700path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0xdf93ed7a), SkBits2Float(0x1a3a803a), SkBits2Float(0xb38a294f), SkBits2Float(0x3ac2213a)); // 6.14991e+25f, -2.13186e+19f, 3.85675e-23f, -6.43364e-08f, 0.00148109f
7701path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7702path.close();
7703path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7704path.conicTo(SkBits2Float(0xe62b291d), SkBits2Float(0x2a812a43), SkBits2Float(0x8ced093a), SkBits2Float(0xb38a5c5c), SkBits2Float(0x3ac2213a)); // -2.02071e+23f, 2.29443e-13f, -3.65212e-31f, -6.44293e-08f, 0.00148109f
7705path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7706path.close();
7707path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
7708path.lineTo(SkBits2Float(0x8ced293a), SkBits2Float(0x5c5c5c5c)); // -3.65404e-31f, 2.48104e+17f
7709path.moveTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003)); // 4.61198e-19f, 1.64987e+07f
7710path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 9.43289e-15f, 4.8745e+16f
7711path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f
7712path.lineTo(SkBits2Float(0x682d2952), SkBits2Float(0xee682103)); // 3.27093e+24f, -1.79601e+28f
7713path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x2a3b0355)); // 4.85282e+16f, 1.66101e-13f
7714path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f
7715path.close();
7716path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f
7717path.conicTo(SkBits2Float(0x084b218c), SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a), SkBits2Float(0x5bf05568), SkBits2Float(0x1f2a8c55)); // 6.11275e-34f, 1.16348e+26f, 0.000209024f, 1.35296e+17f, 3.6115e-20f
7718
7719 SkPath path1(path);
7720 path.reset();
7721 path.setFillType((SkPath::FillType) 0);
7722path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7723path.cubicTo(SkBits2Float(0xbcb4bcac), SkBits2Float(0x000029ff), SkBits2Float(0x010000bc), SkBits2Float(0x00bcbc00), SkBits2Float(0xbebcbcbc), SkBits2Float(0xb6aebcae)); // -0.0220626f, 1.50654e-41f, 2.35104e-38f, 1.73325e-38f, -0.368627f, -5.20757e-06f
7724
7725 SkPath path2(path);
7726 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
7727}
7728
7729static void fuzz763_38(skiatest::Reporter* reporter, const char* filename) {
7730 SkPath path;
7731 path.setFillType((SkPath::FillType) 0);
7732path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7733path.conicTo(SkBits2Float(0x5b682968), SkBits2Float(0x5b292d11), SkBits2Float(0x212a8c55), SkBits2Float(0x555b2d2d), SkBits2Float(0x52525268)); // 6.53477e+16f, 4.76188e+16f, 5.7784e-19f, 1.50617e+13f, 2.25831e+11f
7734path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7735path.close();
7736path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
7737path.close();
7738path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
7739path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x2ac05252), SkBits2Float(0x727fb721)); // 4.80216e+30f, 2.25832e+11f, 3.41632e-13f, 5.06496e+30f
7740path.lineTo(SkBits2Float(0x73727322), SkBits2Float(0x555b2d29)); // 1.92088e+31f, 1.50617e+13f
7741path.lineTo(SkBits2Float(0xab2a212e), SkBits2Float(0x7a27872a)); // -6.04422e-13f, 2.17464e+35f
7742path.moveTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f
7743path.quadTo(SkBits2Float(0x52524852), SkBits2Float(0x72525228), SkBits2Float(0x72727272), SkBits2Float(0x3a727272)); // 2.25789e+11f, 4.16584e+30f, 4.80216e+30f, 0.000924862f
7744path.lineTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f
7745path.close();
7746path.moveTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f
7747path.quadTo(SkBits2Float(0x2a292827), SkBits2Float(0x962b0080), SkBits2Float(0x5252752a), SkBits2Float(0x72725252)); // 1.50241e-13f, -1.38134e-25f, 2.25977e+11f, 4.79967e+30f
7748path.quadTo(SkBits2Float(0x72725252), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.79967e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
7749path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda000072), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.00732e+15f, 2.25867e+11f, 2.25831e+11f
7750path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525272), SkBits2Float(0x72525248), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16584e+30f, 4.80216e+30f
7751path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 2.25831e+11f
7752path.quadTo(SkBits2Float(0x86727272), SkBits2Float(0x5252528d), SkBits2Float(0x72525252), SkBits2Float(0x72727227)); // -4.55992e-35f, 2.25832e+11f, 4.16585e+30f, 4.80214e+30f
7753path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x29217272), SkBits2Float(0xc003211c), SkBits2Float(0x556a4b7b)); // 4.80216e+30f, 3.58484e-14f, -2.0489f, 1.61006e+13f
7754path.moveTo(SkBits2Float(0x72557272), SkBits2Float(0x00727272)); // 4.22775e+30f, 1.05103e-38f
7755path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
7756path.close();
7757path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
7758path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x3a727272), SkBits2Float(0x28273ac2), SkBits2Float(0x00802a29)); // 4.80216e+30f, 0.000924862f, 9.2831e-15f, 1.17701e-38f
7759path.lineTo(SkBits2Float(0x52752a96), SkBits2Float(0x72525252)); // 2.63245e+11f, 4.16585e+30f
7760path.quadTo(SkBits2Float(0x72525272), SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72727272)); // 4.16586e+30f, 2.25966e+11f, 2.25831e+11f, 4.80216e+30f
7761path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f
7762path.lineTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
7763path.close();
7764path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
7765path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525272), SkBits2Float(0x72525248), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16584e+30f, 4.80216e+30f
7766path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x72525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 4.16585e+30f
7767path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x72727252), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada)); // 4.80216e+30f, 4.80215e+30f, -9.04113e+15f, 2.25867e+11f
7768path.lineTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
7769path.close();
7770path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
7771path.quadTo(SkBits2Float(0x86727272), SkBits2Float(0x5252528d), SkBits2Float(0x72525252), SkBits2Float(0x72727227)); // -4.55992e-35f, 2.25832e+11f, 4.16585e+30f, 4.80214e+30f
7772path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x29217272), SkBits2Float(0xc003211c), SkBits2Float(0x556a4b7b)); // 4.80216e+30f, 3.58484e-14f, -2.0489f, 1.61006e+13f
7773path.moveTo(SkBits2Float(0x72557272), SkBits2Float(0x00727272)); // 4.22775e+30f, 1.05103e-38f
7774path.moveTo(SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 2.34994e+11f, 2.25831e+11f
7775path.close();
7776path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
7777path.close();
7778path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
7779path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
7780path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 2.25831e+11f
7781path.quadTo(SkBits2Float(0x52525272), SkBits2Float(0x3b3b0052), SkBits2Float(0x5b2d553a), SkBits2Float(0x68556829)); // 2.25832e+11f, 0.00285341f, 4.87889e+16f, 4.03114e+24f
7782
7783 SkPath path1(path);
7784 path.reset();
7785 path.setFillType((SkPath::FillType) 0);
7786path.moveTo(SkBits2Float(0x52528c55), SkBits2Float(0x29215252)); // 2.26074e+11f, 3.58206e-14f
7787
7788 SkPath path2(path);
7789 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
7790}
7791
7792static void fuzz763_41(skiatest::Reporter* reporter, const char* filename) {
7793 SkPath path;
7794 path.setFillType((SkPath::FillType) 0);
7795
7796 SkPath path1(path);
7797 path.reset();
7798 path.setFillType((SkPath::FillType) 0);
7799path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7800path.quadTo(SkBits2Float(0x7a057c72), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x055f0089)); // 1.73275e+35f, 4.80216e+30f, 4.34505e+30f, 1.04855e-35f
7801path.quadTo(SkBits2Float(0x00057272), SkBits2Float(0x72ff0000), SkBits2Float(0xba405e72), SkBits2Float(0x031b0074)); // 5.00233e-40f, 1.01016e+31f, -0.000733829f, 4.55509e-37f
7802path.lineTo(SkBits2Float(0x664af700), SkBits2Float(0x56397d39)); // 2.39619e+23f, 5.09869e+13f
7803path.quadTo(SkBits2Float(0x7a057273), SkBits2Float(0x057300e4), SkBits2Float(0x257c0c9f), SkBits2Float(0x72400006)); // 1.73224e+35f, 1.1426e-35f, 2.18618e-16f, 3.80295e+30f
7804path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x030000ff), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8ec4000)); // -0.000836826f, 3.7617e-37f, 1.17894e+32f, -8.92527e+24f
7805path.moveTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d)); // 0.000231069f, 2.53975e+30f
7806path.quadTo(SkBits2Float(0x827a0572), SkBits2Float(0x08727272), SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // -1.83687e-37f, 7.29588e-34f, 4.09355e-34f, 4.09355e-34f
7807path.lineTo(SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // 4.09355e-34f, 4.09355e-34f
7808path.lineTo(SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // 4.09355e-34f, 4.09355e-34f
7809path.conicTo(SkBits2Float(0x72728c08), SkBits2Float(0x5b5e7272), SkBits2Float(0x000074ba), SkBits2Float(0x03f8e300), SkBits2Float(0x5aff00e8)); // 4.80414e+30f, 6.26133e+16f, 4.18736e-41f, 1.46282e-36f, 3.58886e+16f
7810path.quadTo(SkBits2Float(0x00800039), SkBits2Float(0x72100039), SkBits2Float(0x727a0572), SkBits2Float(0x7a727272)); // 1.1755e-38f, 2.85223e+30f, 4.95218e+30f, 3.14714e+35f
7811path.lineTo(SkBits2Float(0x7272727a), SkBits2Float(0xdb5e6472)); // 4.80216e+30f, -6.25979e+16f
7812path.moveTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f
7813path.lineTo(SkBits2Float(0x666d0100), SkBits2Float(0x726efe62)); // 2.79805e+23f, 4.73376e+30f
7814path.lineTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f
7815path.close();
7816path.moveTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f
7817path.conicTo(SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x475afc16), SkBits2Float(0x170100ad), SkBits2Float(0x01008000)); // 4.80216e+30f, -3.47604e+31f, 56060.1f, 4.1683e-25f, 2.36017e-38f
7818path.quadTo(SkBits2Float(0x72057272), SkBits2Float(0x8c7a3472), SkBits2Float(0x72727272), SkBits2Float(0x00f6475e)); // 2.64319e+30f, -1.92751e-31f, 4.80216e+30f, 2.26171e-38f
7819path.moveTo(SkBits2Float(0x6d106d43), SkBits2Float(0x6efe6266)); // 2.79362e+27f, 3.93641e+28f
7820path.quadTo(SkBits2Float(0x72727a05), SkBits2Float(0xba5b7272), SkBits2Float(0x03000074), SkBits2Float(0x5aff00e8)); // 4.80274e+30f, -0.000837124f, 3.76163e-37f, 3.58886e+16f
7821path.quadTo(SkBits2Float(0x00da0039), SkBits2Float(0x72100039), SkBits2Float(0x727a0572), SkBits2Float(0x7a727272)); // 2.00202e-38f, 2.85223e+30f, 4.95218e+30f, 3.14714e+35f
7822path.lineTo(SkBits2Float(0x7272727a), SkBits2Float(0xdb5e6472)); // 4.80216e+30f, -6.25979e+16f
7823path.lineTo(SkBits2Float(0xfc5b97fc), SkBits2Float(0x47440039)); // -4.56078e+36f, 50176.2f
7824path.lineTo(SkBits2Float(0x00710000), SkBits2Float(0x62766d01)); // 1.03774e-38f, 1.13644e+21f
7825path.quadTo(SkBits2Float(0x7a05726e), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f
7826
7827 SkPath path2(path);
7828 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
7829}
7830
7831static void fuzz763_40(skiatest::Reporter* reporter, const char* filename) {
7832 SkPath path;
7833 path.setFillType((SkPath::FillType) 1);
7834
7835 SkPath path1(path);
7836 path.reset();
7837 path.setFillType((SkPath::FillType) 0);
7838path.moveTo(SkBits2Float(0x10190004), SkBits2Float(0x7272727a)); // 3.01739e-29f, 4.80216e+30f
7839path.quadTo(SkBits2Float(0xf3db5e64), SkBits2Float(0x5b97fc16), SkBits2Float(0x000039fc), SkBits2Float(0x01008000)); // -3.47604e+31f, 8.55598e+16f, 2.08009e-41f, 2.36017e-38f
7840path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x41720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 15.1251f
7841path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f
7842path.lineTo(SkBits2Float(0x01000000), SkBits2Float(0x10010004)); // 2.35099e-38f, 2.54408e-29f
7843path.conicTo(SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16), SkBits2Float(0x0000d07d), SkBits2Float(0x01008000)); // 4.80216e+30f, -3.47604e+31f, 3.58785e+06f, 7.47915e-41f, 2.36017e-38f
7844path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x63720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 4.46415e+21f
7845path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f
7846path.lineTo(SkBits2Float(0x72000000), SkBits2Float(0x5b5e72b4)); // 2.5353e+30f, 6.26136e+16f
7847path.quadTo(SkBits2Float(0x05720089), SkBits2Float(0x05727272), SkBits2Float(0x7272727a), SkBits2Float(0x5b5e7272)); // 1.13789e-35f, 1.13998e-35f, 4.80216e+30f, 6.26133e+16f
7848path.cubicTo(SkBits2Float(0x03000074), SkBits2Float(0x4aff00e8), SkBits2Float(0x397d3972), SkBits2Float(0x01727200), SkBits2Float(0x72727a00), SkBits2Float(0x5e8d7272)); // 3.76163e-37f, 8.35596e+06f, 0.000241494f, 4.45302e-38f, 4.80274e+30f, 5.09617e+18f
7849path.moveTo(SkBits2Float(0x72008972), SkBits2Float(0x458fe705)); // 2.54594e+30f, 4604.88f
7850path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0xe8727272), SkBits2Float(0xba5b5e03), SkBits2Float(0x03000074)); // 1.73224e+35f, -4.5797e+24f, -0.00083682f, 3.76163e-37f
7851path.lineTo(SkBits2Float(0xf3dbff00), SkBits2Float(0x00397d16)); // -3.48598e+31f, 5.2795e-39f
7852path.cubicTo(SkBits2Float(0x7a101900), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x0197fc16), SkBits2Float(0x200c2010), SkBits2Float(0x20203620)); // 1.87049e+35f, 4.80216e+30f, -3.47604e+31f, 5.58304e-38f, 1.18691e-19f, 1.35704e-19f
7853
7854 SkPath path2(path);
7855 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
7856}
7857
7858static void fuzz763_39(skiatest::Reporter* reporter, const char* filename) {
7859 SkPath path;
7860 path.setFillType((SkPath::FillType) 0);
7861
7862 SkPath path1(path);
7863 path.reset();
7864 path.setFillType((SkPath::FillType) 0);
7865path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7866path.quadTo(SkBits2Float(0x7a057c72), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x055f0089)); // 1.73275e+35f, 4.80216e+30f, 4.34505e+30f, 1.04855e-35f
7867path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xba405e72), SkBits2Float(0x03000074)); // 1.73224e+35f, 4.80216e+30f, -0.000733829f, 3.76163e-37f
7868path.lineTo(SkBits2Float(0x664aff00), SkBits2Float(0x56397d39)); // 2.39655e+23f, 5.09869e+13f
7869path.quadTo(SkBits2Float(0x7a057273), SkBits2Float(0x057300ff), SkBits2Float(0x257c0c9f), SkBits2Float(0x72787257)); // 1.73224e+35f, 1.1426e-35f, 2.18618e-16f, 4.92099e+30f
7870path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x03000093), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8ecff00)); // -0.000836826f, 3.76165e-37f, 1.17894e+32f, -8.95346e+24f
7871path.moveTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d)); // 0.000231069f, 2.53975e+30f
7872path.quadTo(SkBits2Float(0x827a0572), SkBits2Float(0x72727272), SkBits2Float(0x724adf00), SkBits2Float(0x00397d39)); // -1.83687e-37f, 4.80216e+30f, 4.01828e+30f, 5.27954e-39f
7873path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x16f3abab), SkBits2Float(0xfc5b97fc), SkBits2Float(0x47440039)); // 1.73224e+35f, 3.93671e-25f, -4.56078e+36f, 50176.2f
7874path.lineTo(SkBits2Float(0x00710000), SkBits2Float(0x62767201)); // 1.03774e-38f, 1.13653e+21f
7875path.quadTo(SkBits2Float(0x7a05726e), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f
7876
7877 SkPath path2(path);
7878 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
7879}
7880
7881
7882static void fuzz763_42(skiatest::Reporter* reporter, const char* filename) {
7883 SkPath path;
7884 path.setFillType((SkPath::FillType) 0);
7885
7886 SkPath path1(path);
7887 path.reset();
7888 path.setFillType((SkPath::FillType) 0);
7889path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7890path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x05720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 1.13789e-35f
7891path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xba405e72), SkBits2Float(0x03000074)); // 1.73224e+35f, 4.80216e+30f, -0.000733829f, 3.76163e-37f
7892path.lineTo(SkBits2Float(0x724aff00), SkBits2Float(0x56397d39)); // 4.02075e+30f, 5.09869e+13f
7893path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0xfa8d00ff), SkBits2Float(0x25727272), SkBits2Float(0x7272727a)); // 1.73224e+35f, -3.66067e+35f, 2.10289e-16f, 4.80216e+30f
7894path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x03000093), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8e0ff00)); // -0.000836826f, 3.76165e-37f, 1.17894e+32f, -8.50011e+24f
7895path.conicTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d), SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x4aff0072)); // 0.000231069f, 2.53975e+30f, 1.73224e+35f, 4.80216e+30f, 8.3559e+06f
7896path.quadTo(SkBits2Float(0x00397d39), SkBits2Float(0x05727272), SkBits2Float(0x7272727a), SkBits2Float(0x385e7272)); // 5.27954e-39f, 1.13998e-35f, 4.80216e+30f, 5.30355e-05f
7897path.quadTo(SkBits2Float(0x057200ff), SkBits2Float(0x25727272), SkBits2Float(0x7272727a), SkBits2Float(0x5b5e7272)); // 1.1379e-35f, 2.10289e-16f, 4.80216e+30f, 6.26133e+16f
7898path.cubicTo(SkBits2Float(0x03000074), SkBits2Float(0x4aff00e8), SkBits2Float(0x397d3972), SkBits2Float(0x01000400), SkBits2Float(0x72727a10), SkBits2Float(0x5e647272)); // 3.76163e-37f, 8.35596e+06f, 0.000241494f, 2.35128e-38f, 4.80275e+30f, 4.11534e+18f
7899path.quadTo(SkBits2Float(0x2b2d16f3), SkBits2Float(0x0039fc4d), SkBits2Float(0x68800000), SkBits2Float(0x0100fafa)); // 6.14938e-13f, 5.32513e-39f, 4.8357e+24f, 2.369e-38f
7900path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x63720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 4.46415e+21f
7901path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f
7902path.lineTo(SkBits2Float(0x72720000), SkBits2Float(0xff725b5e)); // 4.7933e+30f, -3.22148e+38f
7903path.moveTo(SkBits2Float(0x72720572), SkBits2Float(0x5b5e2572)); // 4.79373e+30f, 6.25286e+16f
7904path.quadTo(SkBits2Float(0x05720089), SkBits2Float(0x25727272), SkBits2Float(0x72728c7a), SkBits2Float(0x5b5e7272)); // 1.13789e-35f, 2.10289e-16f, 4.80417e+30f, 6.26133e+16f
7905path.cubicTo(SkBits2Float(0x03000074), SkBits2Float(0x4aff00e8), SkBits2Float(0x397d3972), SkBits2Float(0x01000400), SkBits2Float(0x72727a10), SkBits2Float(0x5e827272)); // 3.76163e-37f, 8.35596e+06f, 0.000241494f, 2.35128e-38f, 4.80275e+30f, 4.69985e+18f
7906path.quadTo(SkBits2Float(0x97fc16f3), SkBits2Float(0x0039fc5b), SkBits2Float(0x00f6472e), SkBits2Float(0x01008000)); // -1.62909e-24f, 5.32515e-39f, 2.26171e-38f, 2.36017e-38f
7907path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f
7908
7909 SkPath path2(path);
7910 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
7911}
7912
7913static void fuzz763_43(skiatest::Reporter* reporter, const char* filename) {
7914 SkPath path;
7915 path.setFillType((SkPath::FillType) 1);
7916
7917 SkPath path1(path);
7918 path.reset();
7919 path.setFillType((SkPath::FillType) 0);
7920path.moveTo(SkBits2Float(0x5c386c3a), SkBits2Float(0x4e691a3e)); // 2.07642e+17f, 9.77703e+08f
7921path.cubicTo(SkBits2Float(0x6f69f9f5), SkBits2Float(0x18ff8791), SkBits2Float(0x2492263c), SkBits2Float(0xbc6fdb48), SkBits2Float(0xc2f82107), SkBits2Float(0x729a18e1)); // 7.24122e+28f, 6.60528e-24f, 6.33822e-17f, -0.0146397f, -124.065f, 6.10442e+30f
7922path.cubicTo(SkBits2Float(0x07d729d1), SkBits2Float(0xdea6db48), SkBits2Float(0xcd1dfb88), SkBits2Float(0x90826769), SkBits2Float(0x1c20e5a4), SkBits2Float(0xa4c3ba9b)); // 3.23742e-34f, -6.01164e+18f, -1.65657e+08f, -5.14353e-29f, 5.32364e-22f, -8.48839e-17f
7923path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f
7924path.close();
7925path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f
7926path.cubicTo(SkBits2Float(0xdeea1d6e), SkBits2Float(0xc7774804), SkBits2Float(0x27cf0dcf), SkBits2Float(0x6ae8b99f), SkBits2Float(0x24ac3260), SkBits2Float(0x062fa93c)); // -8.43488e+18f, -63304, 5.7469e-15f, 1.40674e+26f, 7.46784e-17f, 3.30382e-35f
7927path.lineTo(SkBits2Float(0x438a0b9c), SkBits2Float(0x60a1d2c8)); // 276.091f, 9.32848e+19f
7928path.quadTo(SkBits2Float(0xe13fb902), SkBits2Float(0x07ee536f), SkBits2Float(0x971d8ac1), SkBits2Float(0x2f9f174b)); // -2.21041e+20f, 3.58593e-34f, -5.09046e-25f, 2.89385e-10f
7929path.lineTo(SkBits2Float(0x0f2cf5d8), SkBits2Float(0xe271654c)); // 8.5276e-30f, -1.11324e+21f
7930path.lineTo(SkBits2Float(0xe6cf24d2), SkBits2Float(0xd9537742)); // -4.89105e+23f, -3.72015e+15f
7931path.cubicTo(SkBits2Float(0x1aaaee04), SkBits2Float(0x9e3b804c), SkBits2Float(0x84cba87d), SkBits2Float(0x4e0e8ccc), SkBits2Float(0x2aec611a), SkBits2Float(0x7ae4b639)); // 7.06949e-23f, -9.92623e-21f, -4.78798e-36f, 5.97898e+08f, 4.19894e-13f, 5.9377e+35f
7932path.conicTo(SkBits2Float(0x73357921), SkBits2Float(0x6f163021), SkBits2Float(0x70ea542c), SkBits2Float(0xe008f404), SkBits2Float(0x1f6c5e52)); // 1.43778e+31f, 4.64809e+28f, 5.8017e+29f, -3.94741e+19f, 5.0053e-20f
7933path.lineTo(SkBits2Float(0xda45ad4e), SkBits2Float(0xedce4a04)); // -1.39103e+16f, -7.98042e+27f
7934path.lineTo(SkBits2Float(0xac0e45da), SkBits2Float(0x8f632841)); // -2.02182e-12f, -1.11997e-29f
7935path.lineTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f
7936path.close();
7937path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f
7938path.quadTo(SkBits2Float(0xf35c4ad5), SkBits2Float(0x0692f251), SkBits2Float(0x69632126), SkBits2Float(0xb927af67)); // -1.74534e+31f, 5.52751e-35f, 1.71614e+25f, -0.000159917f
7939path.moveTo(SkBits2Float(0x6534bff9), SkBits2Float(0x434a9986)); // 5.3348e+22f, 202.6f
7940path.quadTo(SkBits2Float(0x37c603e5), SkBits2Float(0xa0683953), SkBits2Float(0x751915e4), SkBits2Float(0x831c911a)); // 2.36053e-05f, -1.96701e-19f, 1.94059e+32f, -4.60108e-37f
7941path.cubicTo(SkBits2Float(0xba4f10f1), SkBits2Float(0x5a7571df), SkBits2Float(0x4ec67459), SkBits2Float(0x33c58827), SkBits2Float(0x10b78ccb), SkBits2Float(0xedbd2748)); // -0.000789895f, 1.72716e+16f, 1.66476e+09f, 9.19829e-08f, 7.23977e-29f, -7.31752e+27f
7942path.cubicTo(SkBits2Float(0x6d06f06a), SkBits2Float(0xe30465cf), SkBits2Float(0xc5458fe7), SkBits2Float(0xca488dc4), SkBits2Float(0x38f9021c), SkBits2Float(0x3e8d58db)); // 2.6101e+27f, -2.44231e+21f, -3160.99f, -3.28587e+06f, 0.000118736f, 0.276069f
7943
7944 SkPath path2(path);
7945 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
7946}
7947
7948static void fuzz763_44(skiatest::Reporter* reporter, const char* filename) {
7949 SkPath path;
7950 path.setFillType((SkPath::FillType) 1);
7951path.moveTo(SkBits2Float(0x7c223bab), SkBits2Float(0x7cf35966)); // 3.36945e+36f, 1.01083e+37f
7952path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0x7ccaca6d), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 8.4236e+36f, 0, 0
7953path.lineTo(SkBits2Float(0x7d7d7d7d), SkBits2Float(0x00000000)); // 2.10591e+37f, 0
7954path.quadTo(SkBits2Float(0x7ccacab0), SkBits2Float(0x7d1817f4), SkBits2Float(0x7c223bab), SkBits2Float(0x7cf35966)); // 8.42364e+36f, 1.26354e+37f, 3.36945e+36f, 1.01083e+37f
7955path.close();
7956
7957 SkPath path1(path);
7958 path.reset();
7959 path.setFillType((SkPath::FillType) 0);
7960path.moveTo(SkBits2Float(0x109d0000), SkBits2Float(0xff7bc000)); // 6.19256e-29f, -3.34633e+38f
7961path.conicTo(SkBits2Float(0x979797ed), SkBits2Float(0x3a214797), SkBits2Float(0x28aa217a), SkBits2Float(0x01007272), SkBits2Float(0x00000072)); // -9.7965e-25f, 0.000615233f, 1.88883e-14f, 2.3592e-38f, 1.59748e-43f
7962path.quadTo(SkBits2Float(0x72728302), SkBits2Float(0x8b727272), SkBits2Float(0x72727272), SkBits2Float(0xc00308f6)); // 4.80344e+30f, -4.66936e-32f, 4.80216e+30f, -2.04742f
7963path.conicTo(SkBits2Float(0x7f52753a), SkBits2Float(0x8072ffff), SkBits2Float(0x67af2103), SkBits2Float(0x7d2a6847), SkBits2Float(0x7d7d7d7d)); // 2.79747e+38f, -1.05611e-38f, 1.65405e+24f, 1.41569e+37f, 2.10591e+37f
7964
7965 SkPath path2(path);
7966 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
7967}
7968
7969static void fuzz763_45(skiatest::Reporter* reporter, const char* filename) {
7970 SkPath path;
7971 path.setFillType((SkPath::FillType) 0);
7972
7973 SkPath path1(path);
7974 path.reset();
7975 path.setFillType((SkPath::FillType) 0);
7976path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
7977path.cubicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a303030), SkBits2Float(0x7a303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 2.28705e+35f, 2.28705e+35f, 6.40969e-10f
7978path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x74303030), SkBits2Float(0x74303030), SkBits2Float(0x30303030), SkBits2Float(0x74303030)); // 6.40969e-10f, 5.58363e+31f, 5.58363e+31f, 6.40969e-10f, 5.58363e+31f
7979path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
7980path.moveTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
7981path.moveTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f
7982path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a743030), SkBits2Float(0x74303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 3.16974e+35f, 5.58363e+31f, 6.40969e-10f
7983path.lineTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f
7984path.close();
7985path.moveTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f
7986path.lineTo(SkBits2Float(0x7f303030), SkBits2Float(0x7a303030)); // 2.34194e+38f, 2.28705e+35f
7987path.conicTo(SkBits2Float(0x77303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0xf9303030), SkBits2Float(0x7a303030)); // 3.57352e+33f, 6.40969e-10f, 6.40969e-10f, -5.71764e+34f, 2.28705e+35f
7988path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
7989path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
7990path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
7991path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
7992path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 2.28705e+35f, 6.40969e-10f
7993path.cubicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 2.28705e+35f, 6.40969e-10f
7994path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
7995path.moveTo(SkBits2Float(0x77303030), SkBits2Float(0xff303030)); // 3.57352e+33f, -2.34194e+38f
7996path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7f773030), SkBits2Float(0x7a7a3030), SkBits2Float(0x7a303030)); // 6.40969e-10f, 6.40969e-10f, 3.2857e+38f, 3.24763e+35f, 2.28705e+35f
7997path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x77303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 3.57352e+33f, 6.40969e-10f
7998path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7b303030), SkBits2Float(0x73303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 9.14822e+35f, 1.39591e+31f, 6.40969e-10f
7999path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a7a3030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 3.24763e+35f
8000 SkPath path2(path);
8001 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
8002}
8003
8004static void fuzz763_46(skiatest::Reporter* reporter, const char* filename) {
8005 SkPath path;
8006 path.setFillType((SkPath::FillType) 0);
8007
8008 SkPath path1(path);
8009 path.reset();
8010 path.setFillType((SkPath::FillType) 0);
8011path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8012 path.conicTo(SkBits2Float(0x44444444), SkBits2Float(0x44444444), SkBits2Float(0x44263030), SkBits2Float(0x44304430), SkBits2Float(0x4c444430)); // 785.067f, 785.067f, 664.753f, 705.065f, 5.145e+07f
8013path.moveTo(SkBits2Float(0x44444444), SkBits2Float(0x44444444)); // 785.067f, 785.067f
8014path.cubicTo(SkBits2Float(0x30303030), SkBits2Float(0x44444444), SkBits2Float(0x30303030), SkBits2Float(0x44444444), SkBits2Float(0x44444444), SkBits2Float(0x4444444c)); // 6.40969e-10f, 785.067f, 6.40969e-10f, 785.067f, 785.067f, 785.067f
8015 SkPath path2(path);
8016 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
8017}
8018
8019static void fuzz763_47(skiatest::Reporter* reporter, const char* filename) {
8020 SkPath path;
8021 path.setFillType((SkPath::FillType) 1);
8022
8023 SkPath path1(path);
8024 path.reset();
8025 path.setFillType((SkPath::FillType) 0);
8026path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8027path.cubicTo(SkBits2Float(0x7272728e), SkBits2Float(0x52527272), SkBits2Float(0x2d555252), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29), SkBits2Float(0x2a212a8c)); // 4.80217e+30f, 2.25966e+11f, 1.21259e-11f, 4.03114e+24f, 1.50617e+13f, 1.43144e-13f
8028path.conicTo(SkBits2Float(0x00296808), SkBits2Float(0x00000002), SkBits2Float(0x52525252), SkBits2Float(0x72007272), SkBits2Float(0x52527272)); // 3.80257e-39f, 2.8026e-45f, 2.25831e+11f, 2.54416e+30f, 2.25966e+11f
8029path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8030path.close();
8031path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8032path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x7272081f)); // 1.43144e-13f, 4.79393e+30f
8033path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x5974fa80), SkBits2Float(0x00747474), SkBits2Float(0x59585264)); // 4.80216e+30f, 4.30971e+15f, 1.06947e-38f, 3.80557e+15f
8034path.cubicTo(SkBits2Float(0x64007474), SkBits2Float(0x088c5852), SkBits2Float(0x80808021), SkBits2Float(0x8c808080), SkBits2Float(0x80802108), SkBits2Float(0x80808080)); // 9.4783e+21f, 8.44671e-34f, -1.18009e-38f, -1.97989e-31f, -1.17668e-38f, -1.1801e-38f
8035path.quadTo(SkBits2Float(0x80807d80), SkBits2Float(0x80808080), SkBits2Float(0xff7f0000), SkBits2Float(0x80808080)); // -1.18e-38f, -1.1801e-38f, -3.38953e+38f, -1.1801e-38f
8036path.quadTo(SkBits2Float(0x80808080), SkBits2Float(0x80808080), SkBits2Float(0xed842b00), SkBits2Float(0x7252ff6d)); // -1.1801e-38f, -1.1801e-38f, -5.113e+27f, 4.17924e+30f
8037path.quadTo(SkBits2Float(0x72577200), SkBits2Float(0x55525352), SkBits2Float(0x2a212a8c), SkBits2Float(0x7272081f)); // 4.26733e+30f, 1.44535e+13f, 1.43144e-13f, 4.79393e+30f
8038path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x6f740080), SkBits2Float(0x8c556874), SkBits2Float(0x2982ffff)); // 4.80216e+30f, 7.55149e+28f, -1.64404e-31f, 5.81757e-14f
8039
8040 SkPath path2(path);
8041 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
8042}
8043
8044static void fuzz763_48(skiatest::Reporter* reporter, const char* filename) {
8045 SkPath path;
8046 path.setFillType((SkPath::FillType) 1);
8047
8048 SkPath path1(path);
8049 path.reset();
8050 path.setFillType((SkPath::FillType) 0);
8051path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8052path.lineTo(SkBits2Float(0xed0081bc), SkBits2Float(0x1b2d8040)); // -2.48568e+27f, 1.43517e-22f
8053path.moveTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f
8054path.close();
8055path.moveTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f
8056path.conicTo(SkBits2Float(0x662d5576), SkBits2Float(0x2d804066), SkBits2Float(0x8068291b), SkBits2Float(0x740315ff), SkBits2Float(0x74747474)); // 2.04636e+23f, 1.45805e-11f, -9.56564e-39f, 4.15428e+31f, 7.74708e+31f
8057path.cubicTo(SkBits2Float(0x762d0529), SkBits2Float(0x72525252), SkBits2Float(0x007b7272), SkBits2Float(0x525adada), SkBits2Float(0x52525252), SkBits2Float(0x52727252)); // 8.77316e+32f, 4.16585e+30f, 1.13368e-38f, 2.34994e+11f, 2.25831e+11f, 2.60325e+11f
8058path.lineTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f
8059path.close();
8060path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
8061path.close();
8062path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
8063path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52524872), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.2579e+11f, 4.16585e+30f, 4.80216e+30f
8064path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0x80406666), SkBits2Float(0x68291b2d), SkBits2Float(0x0315ff80)); // 4.80215e+30f, -5.91421e-39f, 3.19432e+24f, 4.40805e-37f
8065path.cubicTo(SkBits2Float(0x74747474), SkBits2Float(0x7b722974), SkBits2Float(0x5adada00), SkBits2Float(0x52525252), SkBits2Float(0x72720052), SkBits2Float(0x72727272)); // 7.74708e+31f, 1.25738e+36f, 3.08006e+16f, 2.25831e+11f, 4.79333e+30f, 4.80216e+30f
8066path.lineTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
8067path.close();
8068path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
8069path.quadTo(SkBits2Float(0x72727227), SkBits2Float(0x72727272), SkBits2Float(0x74727272), SkBits2Float(0x55747421)); // 4.80214e+30f, 4.80216e+30f, 7.68345e+31f, 1.67987e+13f
8070path.lineTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
8071path.close();
8072path.moveTo(SkBits2Float(0x724b0000), SkBits2Float(0x00725f72)); // 4.02083e+30f, 1.05035e-38f
8073path.lineTo(SkBits2Float(0x52525252), SkBits2Float(0x72725252)); // 2.25831e+11f, 4.79967e+30f
8074path.quadTo(SkBits2Float(0x26727272), SkBits2Float(0x0303a525), SkBits2Float(0x52005c03), SkBits2Float(0x72525252)); // 8.41157e-16f, 3.8687e-37f, 1.37825e+11f, 4.16585e+30f
8075path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x1ff07255), SkBits2Float(0x2a8c5572), SkBits2Float(0x21082a21)); // 4.80216e+30f, 1.01833e-19f, 2.49283e-13f, 4.61343e-19f
8076path.lineTo(SkBits2Float(0x2a2a3a21), SkBits2Float(0x29212828)); // 1.51192e-13f, 3.5784e-14f
8077
8078 SkPath path2(path);
8079 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
8080}
8081
8082static void fuzz763_49(skiatest::Reporter* reporter, const char* filename) {
8083 SkPath path;
8084 path.setFillType((SkPath::FillType) 0);
8085
8086 SkPath path1(path);
8087 path.reset();
8088 path.setFillType((SkPath::FillType) 0);
8089path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8090path.conicTo(SkBits2Float(0x30303030), SkBits2Float(0x78303030), SkBits2Float(0x78787881), SkBits2Float(0x78787878), SkBits2Float(0x30303030)); // 6.40969e-10f, 1.42941e+34f, 2.01583e+34f, 2.01583e+34f, 6.40969e-10f
8091path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
8092path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
8093path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
8094path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x78787878), SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 6.40969e-10f, 2.01583e+34f, 2.01583e+34f, 2.01583e+34f
8095path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8096path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8097path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8098path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8099path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8100path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8101path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8102path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8103path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8104path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8105path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8106path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8107path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
8108path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x7878788d)); // 2.01583e+34f, 2.01584e+34f
8109path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x30303030)); // 2.01583e+34f, 6.40969e-10f
8110
8111 SkPath path2(path);
8112 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
8113}
8114
8115static void fuzz763_50(skiatest::Reporter* reporter, const char* filename) {
8116 SkPath path;
8117 path.setFillType((SkPath::FillType) 1);
8118path.moveTo(SkBits2Float(0x70621ede), SkBits2Float(0x00000000)); // 2.79924e+29f, 0
8119path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x74fc5b97), SkBits2Float(0x7d458fe4)); // 0, 0, 0, 1.59951e+32f, 1.64128e+37f
8120path.lineTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0
8121path.lineTo(SkBits2Float(0x70621ede), SkBits2Float(0x00000000)); // 2.79924e+29f, 0
8122path.close();
8123path.moveTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0
8124path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8125path.lineTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0
8126path.close();
8127
8128 SkPath path1(path);
8129 path.reset();
8130 path.setFillType((SkPath::FillType) 0);
8131
8132 SkPath path2(path);
8133 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
8134}
8135
8136static void fuzz763_51(skiatest::Reporter* reporter, const char* filename) {
8137 SkPath path;
8138 path.setFillType((SkPath::FillType) 1);
8139
8140 SkPath path1(path);
8141 path.reset();
8142 path.setFillType((SkPath::FillType) 0);
8143path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8144path.quadTo(SkBits2Float(0x868b5aae), SkBits2Float(0x626c45ab), SkBits2Float(0xefea1ffe), SkBits2Float(0x0029fc76)); // -5.24192e-35f, 1.08961e+21f, -1.44916e+29f, 3.85582e-39f
8145path.moveTo(SkBits2Float(0xfacbff01), SkBits2Float(0x56fc5b97)); // -5.29604e+35f, 1.38735e+14f
8146path.cubicTo(SkBits2Float(0x7d4559c9), SkBits2Float(0xad801c39), SkBits2Float(0xfbe2091a), SkBits2Float(0x7268e394), SkBits2Float(0x7c800079), SkBits2Float(0xa1d75590)); // 1.63953e+37f, -1.45644e-11f, -2.34729e+36f, 4.61284e+30f, 5.31699e+36f, -1.45916e-18f
8147
8148 SkPath path2(path);
8149 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
8150}
8151
8152static void fuzz763_52(skiatest::Reporter* reporter, const char* filename) {
8153 SkPath path;
8154 path.setFillType((SkPath::FillType) 1);
8155
8156 SkPath path1(path);
8157 path.reset();
8158 path.setFillType((SkPath::FillType) 0);
8159path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8160path.quadTo(SkBits2Float(0x29ff4bae), SkBits2Float(0xa1d75590), SkBits2Float(0x9fd6f6c3), SkBits2Float(0x70621ede)); // 1.13374e-13f, -1.45916e-18f, -9.10408e-20f, 2.79924e+29f
8161path.quadTo(SkBits2Float(0x57a839d3), SkBits2Float(0x1a80d34b), SkBits2Float(0x0147a31b), SkBits2Float(0xff7fffff)); // 3.69933e+14f, 5.32809e-23f, 3.66675e-38f, -3.40282e+38f
8162path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8163path.close();
8164path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
8165path.conicTo(SkBits2Float(0x75757568), SkBits2Float(0x7575755e), SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x75756575)); // 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 3.11077e+32f
8166path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
8167path.close();
8168path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
8169path.conicTo(SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x75757575), SkBits2Float(0x75917575), SkBits2Float(0x75757575)); // 3.11156e+32f, 3.11156e+32f, 3.11156e+32f, 3.68782e+32f, 3.11156e+32f
8170path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
8171path.close();
8172path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
8173path.conicTo(SkBits2Float(0x75757575), SkBits2Float(0x7575758f), SkBits2Float(0x7f757575), SkBits2Float(0x75757575), SkBits2Float(0x75757575)); // 3.11156e+32f, 3.11157e+32f, 3.26271e+38f, 3.11156e+32f, 3.11156e+32f
8174path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
8175path.close();
8176
8177 SkPath path2(path);
8178 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
8179}
8180
8181static void fuzz763_53(skiatest::Reporter* reporter, const char* filename) {
8182 SkPath path;
8183 path.setFillType((SkPath::FillType) 1);
8184path.moveTo(SkBits2Float(0x7644b829), SkBits2Float(0x00000000)); // 9.97486e+32f, 0
8185path.lineTo(SkBits2Float(0x74fc5b97), SkBits2Float(0x77df944a)); // 1.59951e+32f, 9.06945e+33f
8186path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf8fbe3ff)); // 0, -4.08716e+34f
8187path.lineTo(SkBits2Float(0x7644b829), SkBits2Float(0x00000000)); // 9.97486e+32f, 0
8188path.close();
8189
8190 SkPath path1(path);
8191 path.reset();
8192 path.setFillType((SkPath::FillType) 0);
8193path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8194path.quadTo(SkBits2Float(0x45ab86ae), SkBits2Float(0xd6d6626c), SkBits2Float(0xd6d6d6d6), SkBits2Float(0x7644d6d6)); // 5488.83f, -1.17859e+14f, -1.18109e+14f, 9.98093e+32f
8195path.moveTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0xd6d6d6d6)); // -1.18109e+14f, -1.18109e+14f
8196path.cubicTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0x64fed6d6), SkBits2Float(0x7644ef40), SkBits2Float(0x290877fc), SkBits2Float(0x447644b8), SkBits2Float(0x80fafc76)); // -1.18109e+14f, 3.76076e+22f, 9.98577e+32f, 3.03021e-14f, 985.074f, -2.30494e-38f
8197path.conicTo(SkBits2Float(0x87808080), SkBits2Float(0x764400ae), SkBits2Float(0x764400fc), SkBits2Float(0x450080fc), SkBits2Float(0x3636366c)); // -1.93348e-34f, 9.93852e+32f, 9.93858e+32f, 2056.06f, 2.71518e-06f
8198path.lineTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0xd6d6d6d6)); // -1.18109e+14f, -1.18109e+14f
8199path.close();
8200path.moveTo(SkBits2Float(0xef08a412), SkBits2Float(0x5aaeff7f)); // -4.22883e+28f, 2.46288e+16f
8201path.conicTo(SkBits2Float(0x7644626c), SkBits2Float(0x088912fc), SkBits2Float(0xae8744ef), SkBits2Float(0x76571f5a), SkBits2Float(0x45ab86fc)); // 9.95788e+32f, 8.24985e-34f, -6.15133e-11f, 1.0908e+33f, 5488.87f
8202path.conicTo(SkBits2Float(0x4064fe62), SkBits2Float(0x290877ef), SkBits2Float(0x780080b8), SkBits2Float(0x553c7644), SkBits2Float(0x644eae87)); // 3.57803f, 3.03021e-14f, 1.04254e+34f, 1.2951e+13f, 1.52504e+22f
8203path.lineTo(SkBits2Float(0xef08a412), SkBits2Float(0x5aaeff7f)); // -4.22883e+28f, 2.46288e+16f
8204path.close();
8205
8206 SkPath path2(path);
8207 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
8208}
8209
8210// hangs 654939
8211static void fuzz763_54(skiatest::Reporter* reporter, const char* filename) {
8212 SkPath path;
8213 path.setFillType((SkPath::FillType) 0);
8214path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8215path.conicTo(SkBits2Float(0x5b682968), SkBits2Float(0xb3b32d11), SkBits2Float(0xb3b3b3b3), SkBits2Float(0x5b29b3b3), SkBits2Float(0x212a8c55)); // 6.53477e+16f, -8.34353e-08f, -8.36802e-08f, 4.77669e+16f, 5.7784e-19f
8216path.conicTo(SkBits2Float(0x68555b2d), SkBits2Float(0x28296869), SkBits2Float(0x5b252a08), SkBits2Float(0x5d68392a), SkBits2Float(0x29282780)); // 4.03018e+24f, 9.40402e-15f, 4.64896e+16f, 1.04584e+18f, 3.73378e-14f
8217path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8218path.close();
8219path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8220path.cubicTo(SkBits2Float(0x52727272), SkBits2Float(0x72727252), SkBits2Float(0x525252c7), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255)); // 2.60326e+11f, 4.80215e+30f, 2.25833e+11f, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f
8221path.quadTo(SkBits2Float(0xd7da0000), SkBits2Float(0x5252525a), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // -4.79387e+14f, 2.25831e+11f, 4.16585e+30f, 4.80216e+30f
8222path.quadTo(SkBits2Float(0x48525252), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255)); // 215369, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f
8223path.quadTo(SkBits2Float(0xdada007b), SkBits2Float(0x5252525a), SkBits2Float(0x72675252), SkBits2Float(0x72727272)); // -3.0681e+16f, 2.25831e+11f, 4.5818e+30f, 4.80216e+30f
8224path.quadTo(SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272), SkBits2Float(0x72727272)); // 2.25831e+11f, 3.36289e-15f, 4.80216e+30f, 4.80216e+30f
8225path.quadTo(SkBits2Float(0x1c292172), SkBits2Float(0x7bc00321), SkBits2Float(0x9aaaaaaa), SkBits2Float(0x8c556a4b)); // 5.59606e-22f, 1.99397e+36f, -7.05861e-23f, -1.64409e-31f
8226path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f
8227path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8228path.close();
8229path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
8230path.close();
8231path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
8232path.quadTo(SkBits2Float(0x72725570), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.79991e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
8233path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0x555bb672), SkBits2Float(0x29686968), SkBits2Float(0x252a081f)); // 4.80215e+30f, 1.50985e+13f, 5.16058e-14f, 1.47479e-16f
8234path.moveTo(SkBits2Float(0x5d68392a), SkBits2Float(0x01002780)); // 1.04584e+18f, 2.35382e-38f
8235path.moveTo(SkBits2Float(0x72727200), SkBits2Float(0x72725252)); // 4.80212e+30f, 4.79967e+30f
8236path.quadTo(SkBits2Float(0x5adada00), SkBits2Float(0xa5252652), SkBits2Float(0x727272ad), SkBits2Float(0xda007b72)); // 3.08006e+16f, -1.43245e-16f, 4.80218e+30f, -9.04113e+15f
8237path.lineTo(SkBits2Float(0x5252525a), SkBits2Float(0x72525252)); // 2.25831e+11f, 4.16585e+30f
8238path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
8239path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x74217472), SkBits2Float(0x005b5574), SkBits2Float(0x72680000)); // 4.80216e+30f, 5.11671e+31f, 8.38768e-39f, 4.59523e+30f
8240path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x007b7272), SkBits2Float(0x525adada)); // 4.80216e+30f, 2.25831e+11f, 1.13368e-38f, 2.34994e+11f
8241path.lineTo(SkBits2Float(0x72727200), SkBits2Float(0x72725252)); // 4.80212e+30f, 4.79967e+30f
8242path.close();
8243
8244 SkPath path1(path);
8245 path.reset();
8246 path.setFillType((SkPath::FillType) 0);
8247
8248 SkPath path2(path);
8249 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
8250}
8251
8252
8253// afl crash
8254static void fuzz763_55(skiatest::Reporter* reporter, const char* filename) {
8255 SkPath path;
8256 path.setFillType((SkPath::FillType) 0);
8257path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f
8258path.lineTo(SkBits2Float(0x55555568), SkBits2Float(0x55555555)); // 1.46602e+13f, 1.46602e+13f
8259path.lineTo(SkBits2Float(0x98989898), SkBits2Float(0x55989898)); // -3.94452e-24f, 2.09726e+13f
8260path.lineTo(SkBits2Float(0xf6f65555), SkBits2Float(0x101006f6)); // -2.49812e+33f, 2.84044e-29f
8261path.quadTo(SkBits2Float(0xdca33f10), SkBits2Float(0xf6f6f6f6), SkBits2Float(0xf621f6f6), SkBits2Float(0xf70ff6f6)); // -3.67598e+17f, -2.50452e+33f, -8.21259e+32f, -2.91995e+33f
8262path.lineTo(SkBits2Float(0x9400f6f6), SkBits2Float(0x10530000)); // -6.51105e-27f, 4.16124e-29f
8263path.quadTo(SkBits2Float(0x0f101010), SkBits2Float(0x00101010), SkBits2Float(0xf610f720), SkBits2Float(0xf6f6f6f6)); // 7.10284e-30f, 1.47513e-39f, -7.35062e+32f, -2.50452e+33f
8264path.lineTo(SkBits2Float(0x105352f6), SkBits2Float(0x1cf6ff10)); // 4.16763e-29f, 1.63448e-21f
8265path.lineTo(SkBits2Float(0xf6f6220a), SkBits2Float(0x003700f6)); // -2.49608e+33f, 5.0513e-39f
8266path.cubicTo(SkBits2Float(0x0000001e), SkBits2Float(0x00fff4f6), SkBits2Float(0xff101064), SkBits2Float(0xf6b6ac7f), SkBits2Float(0xf6f629f6), SkBits2Float(0x10f6f6f6)); // 4.2039e-44f, 2.35059e-38f, -1.91494e+38f, -1.85253e+33f, -2.4964e+33f, 9.74104e-29f
8267path.quadTo(SkBits2Float(0x10101007), SkBits2Float(0x10f7fd10), SkBits2Float(0xf6f6f6f6), SkBits2Float(0xf6f645e0)); // 2.84113e-29f, 9.78142e-29f, -2.50452e+33f, -2.4975e+33f
8268path.lineTo(SkBits2Float(0xed9ef6f6), SkBits2Float(0x53535353)); // -6.14965e+27f, 9.07636e+11f
8269path.lineTo(SkBits2Float(0x53006cf6), SkBits2Float(0x53295353)); // 5.51584e+11f, 7.27247e+11f
8270path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f
8271path.close();
8272path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f
8273path.lineTo(SkBits2Float(0xf6f6f6f6), SkBits2Float(0x5353d9f6)); // -2.50452e+33f, 9.09895e+11f
8274
8275 SkPath path1(path);
8276 path.reset();
8277 path.setFillType((SkPath::FillType) 0);
8278
8279 SkPath path2(path);
8280 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
8281}
8282
8283// 656149
8284static void fuzz763_56(skiatest::Reporter* reporter, const char* filename) {
8285 SkPath path;
8286 path.setFillType((SkPath::FillType) 0);
8287path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8288path.conicTo(SkBits2Float(0x5b682968), SkBits2Float(0xb3b32d11), SkBits2Float(0xb3b3b3b3), SkBits2Float(0x5b29b3b3), SkBits2Float(0x72725255)); // 6.53477e+16f, -8.34353e-08f, -8.36802e-08f, 4.77669e+16f, 4.79967e+30f
8289path.quadTo(SkBits2Float(0x525252c7), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255)); // 2.25833e+11f, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f
8290path.quadTo(SkBits2Float(0xd7da0000), SkBits2Float(0x5adada00), SkBits2Float(0x52525252), SkBits2Float(0x00005252)); // -4.79387e+14f, 3.08006e+16f, 2.25831e+11f, 2.9531e-41f
8291path.conicTo(SkBits2Float(0xadada525), SkBits2Float(0x52525ab4), SkBits2Float(0x52525252), SkBits2Float(0x72727272), SkBits2Float(0x52527272)); // -1.97412e-11f, 2.25866e+11f, 2.25831e+11f, 4.80216e+30f, 2.25966e+11f
8292path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8293path.close();
8294path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8295path.quadTo(SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255), SkBits2Float(0xda007b72)); // 4.79967e+30f, 4.80216e+30f, 4.80215e+30f, -9.04113e+15f
8296path.lineTo(SkBits2Float(0x5252525a), SkBits2Float(0x72525252)); // 2.25831e+11f, 4.16585e+30f
8297path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
8298path.lineTo(SkBits2Float(0x7bc00321), SkBits2Float(0x9aaaaaaa)); // 1.99397e+36f, -7.05861e-23f
8299path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f
8300path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8301path.close();
8302path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
8303path.close();
8304path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
8305path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
8306path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x26525ada), SkBits2Float(0x72ada525)); // 4.80215e+30f, -9.04113e+15f, 7.29815e-16f, 6.87879e+30f
8307path.quadTo(SkBits2Float(0x007b7272), SkBits2Float(0x525adada), SkBits2Float(0x52525252), SkBits2Float(0x72727252)); // 1.13368e-38f, 2.34994e+11f, 2.25831e+11f, 4.80215e+30f
8308path.quadTo(SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72722772), SkBits2Float(0x72727272)); // 2.25966e+11f, 2.25831e+11f, 4.79636e+30f, 4.80216e+30f
8309path.quadTo(SkBits2Float(0x74727272), SkBits2Float(0x55747421), SkBits2Float(0x0000005b), SkBits2Float(0x72727268)); // 7.68345e+31f, 1.67987e+13f, 1.27518e-43f, 4.80216e+30f
8310path.quadTo(SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72727272), SkBits2Float(0x72557272)); // 2.25966e+11f, 2.25831e+11f, 4.80216e+30f, 4.22775e+30f
8311path.quadTo(SkBits2Float(0x5adada72), SkBits2Float(0x52525252), SkBits2Float(0x72725252), SkBits2Float(0x72727272)); // 3.08009e+16f, 2.25831e+11f, 4.79967e+30f, 4.80216e+30f
8312
8313 SkPath path1(path);
8314 path.reset();
8315 path.setFillType((SkPath::FillType) 0);
8316
8317 SkPath path2(path);
8318 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
8319}
8320
8321static void fuzz763_57(skiatest::Reporter* reporter, const char* filename) {
8322 SkPath path;
8323 path.setFillType((SkPath::FillType) 0);
8324
8325 SkPath path1(path);
8326 path.reset();
8327 path.setFillType((SkPath::FillType) 0);
8328path.moveTo(SkBits2Float(0x68546829), SkBits2Float(0x555b2d29)); // 4.01225e+24f, 1.50617e+13f
8329path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0x4b7b2108)); // 3.60404e-20f, 1.6458e+07f
8330path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 9.43289e-15f, 4.8745e+16f
8331path.moveTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f
8332path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x2a8cef2a), SkBits2Float(0x682d2953), SkBits2Float(0xce682103), SkBits2Float(0x4b7bc055)); // 5.76397e-19f, 2.50349e-13f, 3.27093e+24f, -9.73619e+08f, 1.64988e+07f
8333path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x3b2a8c55)); // 4.85282e+16f, 0.00260236f
8334path.lineTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f
8335path.close();
8336path.moveTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f
8337path.conicTo(SkBits2Float(0xd2c00321), SkBits2Float(0xc0394b7b), SkBits2Float(0x8c08ed7a), SkBits2Float(0x211f2f2a), SkBits2Float(0x704b7b03)); // -4.12343e+11f, -2.89523f, -1.05485e-31f, 5.39337e-19f, 2.51897e+29f
8338path.cubicTo(SkBits2Float(0x2d6829ed), SkBits2Float(0x5b2d555b), SkBits2Float(0x68275b2d), SkBits2Float(0x21685527), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0)); // 1.3197e-11f, 4.8789e+16f, 3.16127e+24f, 7.87174e-19f, 4.7323e-37f, 6.14991e+25f
8339path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 5.77848e-19f, 4.7323e-37f, 6.14991e+25f, 9.43289e-15f, 4.8745e+16f
8340path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
8341path.conicTo(SkBits2Float(0x212a1f5b), SkBits2Float(0x228cef2a), SkBits2Float(0x682d2953), SkBits2Float(0xee682103), SkBits2Float(0x287bc055)); // 5.76397e-19f, 3.82003e-18f, 3.27093e+24f, -1.79601e+28f, 1.3975e-14f
8342path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
8343path.conicTo(SkBits2Float(0x4b03213b), SkBits2Float(0xc07b2a08), SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556830), SkBits2Float(0x2a8c555b)); // 8.59372e+06f, -3.92444f, 4.88298e+16f, -2.64185e+29f, 2.49282e-13f
8344path.conicTo(SkBits2Float(0x0321212a), SkBits2Float(0x4b7bd2c0), SkBits2Float(0xed7ac039), SkBits2Float(0x2f2a8c08), SkBits2Float(0x7b03211f)); // 4.73517e-37f, 1.65035e+07f, -4.85023e+27f, 1.55112e-10f, 6.80863e+35f
8345path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
8346path.close();
8347path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
8348path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f
8349path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8350path.conicTo(SkBits2Float(0x721f2a5b), SkBits2Float(0x212a8c55), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7b28), SkBits2Float(0x4797ed7a)); // 3.1526e+30f, 5.7784e-19f, 4.7323e-37f, 6.14984e+25f, 77787
8351path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8352path.close();
8353path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8354path.quadTo(SkBits2Float(0x2828102a), SkBits2Float(0x2c682921), SkBits2Float(0x8c555bf6), SkBits2Float(0x6d03de30)); // 9.32938e-15f, 3.2992e-12f, -1.64366e-31f, 2.5507e+27f
8355path.cubicTo(SkBits2Float(0x683f2d55), SkBits2Float(0xf05b684b), SkBits2Float(0x8c55272d), SkBits2Float(0x212a292a), SkBits2Float(0x0321082a), SkBits2Float(0x211f2a21)); // 3.61123e+24f, -2.71613e+29f, -1.64207e-31f, 5.76527e-19f, 4.7323e-37f, 5.39271e-19f
8356path.lineTo(SkBits2Float(0x3a803adf), SkBits2Float(0x8a294f1a)); // 0.000978317f, -8.15193e-33f
8357path.quadTo(SkBits2Float(0x291d9628), SkBits2Float(0x2a43e62b), SkBits2Float(0x093a2a81), SkBits2Float(0x5c5c8ced)); // 3.49912e-14f, 1.73993e-13f, 2.24089e-33f, 2.48318e+17f
8358path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8359path.close();
8360path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
8361path.cubicTo(SkBits2Float(0x3ac2213a), SkBits2Float(0x291d9628), SkBits2Float(0x2a43e62b), SkBits2Float(0x293a2a81), SkBits2Float(0x5c5c8ced), SkBits2Float(0x5c5c6e5c)); // 0.00148109f, 3.49912e-14f, 1.73993e-13f, 4.13372e-14f, 2.48318e+17f, 2.48183e+17f
8362path.lineTo(SkBits2Float(0x1f212a8c), SkBits2Float(0xc0032108)); // 3.41283e-20f, -2.04889f
8363path.lineTo(SkBits2Float(0xed847b4b), SkBits2Float(0x2d552829)); // -5.12513e+27f, 1.21166e-11f
8364path.conicTo(SkBits2Float(0x552d5b5b), SkBits2Float(0x3b5a6839), SkBits2Float(0x5b2df068), SkBits2Float(0x2a212a1f), SkBits2Float(0x532a8cef)); // 1.1913e+13f, 0.00333263f, 4.89595e+16f, 1.43143e-13f, 7.32509e+11f
8365
8366 SkPath path2(path);
8367 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
8368}
8369
8370static void fuzzhang_1(skiatest::Reporter* reporter, const char* filename) {
8371 SkPath path;
8372 path.setFillType((SkPath::FillType) 1);
8373path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8374path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x668ece09), SkBits2Float(0x00000000), SkBits2Float(0x6751c81a), SkBits2Float(0x61c4b0fb)); // 0, 0, 3.37188e+23f, 0, 9.90666e+23f, 4.53539e+20f
8375path.conicTo(SkBits2Float(0x66f837a9), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x3f823406)); // 5.86087e+23f, 0, 0, 0, 1.01721f
8376path.close();
8377path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8378path.quadTo(SkBits2Float(0x675b1bfe), SkBits2Float(0x00000000), SkBits2Float(0x67d76c42), SkBits2Float(0x6292c469)); // 1.03471e+24f, 0, 2.03461e+24f, 1.35369e+21f
8379path.cubicTo(SkBits2Float(0x6a16df68), SkBits2Float(0x651a2f15), SkBits2Float(0x6c1e7f31), SkBits2Float(0x67a1f9b4), SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 4.55985e+25f, 4.55071e+22f, 7.66444e+26f, 1.52981e+24f, 0, 5.14279e+25f
8380path.conicTo(SkBits2Float(0x680dcb75), SkBits2Float(0x68dd898d), SkBits2Float(0x681a434a), SkBits2Float(0x6871046b), SkBits2Float(0x3fea0440)); // 2.67843e+24f, 8.36944e+24f, 2.91394e+24f, 4.55269e+24f, 1.82825f
8381path.quadTo(SkBits2Float(0x679e1b26), SkBits2Float(0x687703c4), SkBits2Float(0x00000000), SkBits2Float(0x687d2968)); // 1.49327e+24f, 4.66598e+24f, 0, 4.78209e+24f
8382path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8383path.close();
8384
8385 SkPath path1(path);
8386 path.reset();
8387 path.setFillType((SkPath::FillType) 0);
8388path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8389path.cubicTo(SkBits2Float(0x535353ec), SkBits2Float(0x98989898), SkBits2Float(0x98989898), SkBits2Float(0xf207f36e), SkBits2Float(0xf3f2f2f2), SkBits2Float(0xed3a9781)); // 9.07646e+11f, -3.94452e-24f, -3.94452e-24f, -2.69278e+30f, -3.84968e+31f, -3.60921e+27f
8390path.quadTo(SkBits2Float(0xf8f8c0ed), SkBits2Float(0xf8f8f8f8), SkBits2Float(0x9f9f9f9f), SkBits2Float(0x3014149f)); // -4.03626e+34f, -4.03981e+34f, -6.76032e-20f, 5.38714e-10f
8391
8392 SkPath path2(path);
8393 testPathOp(reporter, path1, path2, (SkPathOp) 0, filename);
8394}
8395
8396static void release_13(skiatest::Reporter* reporter, const char* filename) {
8397 SkPath path;
8398 path.setFillType((SkPath::FillType) 1);
8399path.setFillType(SkPath::kEvenOdd_FillType);
8400path.moveTo(SkBits2Float(0xd4438848), SkBits2Float(0xd488cf64)); // -3.35922e+12f, -4.70076e+12f
8401path.lineTo(SkBits2Float(0xd43a056e), SkBits2Float(0xd4851696)); // -3.19582e+12f, -4.57288e+12f
8402path.quadTo(SkBits2Float(0xd3d48e79), SkBits2Float(0xd49fb136), SkBits2Float(0x00000000), SkBits2Float(0xd4d4d4d4)); // -1.82585e+12f, -5.48698e+12f, 0, -7.31283e+12f
8403path.quadTo(SkBits2Float(0xd3d06670), SkBits2Float(0xd4a0bb38), SkBits2Float(0xd41d628f), SkBits2Float(0xd472c531)); // -1.79014e+12f, -5.52269e+12f, -2.70385e+12f, -4.17076e+12f
8404path.lineTo(SkBits2Float(0xd43a0559), SkBits2Float(0xd485168e)); // -3.19581e+12f, -4.57287e+12f
8405path.lineTo(SkBits2Float(0xd446958b), SkBits2Float(0xd4810278)); // -3.41165e+12f, -4.43274e+12f
8406path.lineTo(SkBits2Float(0xd443884a), SkBits2Float(0xd488cf65)); // -3.35922e+12f, -4.70076e+12f
8407path.quadTo(SkBits2Float(0xd47efa09), SkBits2Float(0xd49fd72a), SkBits2Float(0xd4a63f0f), SkBits2Float(0xd4b83ab3)); // -4.38047e+12f, -5.49208e+12f, -5.71218e+12f, -6.33007e+12f
8408path.lineTo(SkBits2Float(0xd497ca70), SkBits2Float(0xd4c4d4ae)); // -5.21549e+12f, -6.76305e+12f
8409path.lineTo(SkBits2Float(0xd459d4d4), SkBits2Float(0xd4c4d4d4)); // -3.74231e+12f, -6.76307e+12f
8410path.lineTo(SkBits2Float(0xd440daf9), SkBits2Float(0xd4c632d3)); // -3.31323e+12f, -6.81005e+12f
8411path.lineTo(SkBits2Float(0xd4438848), SkBits2Float(0xd488cf64)); // -3.35922e+12f, -4.70076e+12f
8412path.close();
8413path.moveTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f
8414path.lineTo(SkBits2Float(0xd4422174), SkBits2Float(0xd4d02069)); // -3.33514e+12f, -7.15118e+12f
8415path.lineTo(SkBits2Float(0xd440daa3), SkBits2Float(0xd4c632d9)); // -3.31321e+12f, -6.81005e+12f
8416path.lineTo(SkBits2Float(0xd41017bc), SkBits2Float(0xd4cb99b6)); // -2.47549e+12f, -6.99566e+12f
8417path.lineTo(SkBits2Float(0xd442213b), SkBits2Float(0xd4d02067)); // -3.33512e+12f, -7.15117e+12f
8418path.lineTo(SkBits2Float(0xd442d4d4), SkBits2Float(0xd4d4d4d4)); // -3.34718e+12f, -7.31283e+12f
8419path.lineTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f
8420path.close();
8421path.moveTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f
8422path.lineTo(SkBits2Float(0xd484e02c), SkBits2Float(0xd45fafcd)); // -4.56557e+12f, -3.84291e+12f
8423path.lineTo(SkBits2Float(0xd462c867), SkBits2Float(0xd45655f7)); // -3.8961e+12f, -3.68226e+12f
8424path.lineTo(SkBits2Float(0xd45ac463), SkBits2Float(0xd45ac505)); // -3.75839e+12f, -3.75843e+12f
8425path.lineTo(SkBits2Float(0xd43d2fa9), SkBits2Float(0xd43d2fb5)); // -3.25019e+12f, -3.2502e+12f
8426path.lineTo(SkBits2Float(0xd41d6287), SkBits2Float(0xd472c52a)); // -2.70385e+12f, -4.17076e+12f
8427path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0xd3db1b95), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, -1.88212e+12f, 0, 0
8428path.quadTo(SkBits2Float(0xd4b7efac), SkBits2Float(0x00000000), SkBits2Float(0xd4d0e88f), SkBits2Float(0xd40b8b46)); // -6.32e+12f, 0, -7.17804e+12f, -2.39735e+12f
8429path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0x00000000)); // -7.31283e+12f, 0
8430path.lineTo(SkBits2Float(0xdcdc154b), SkBits2Float(0x00000000)); // -4.95583e+17f, 0
8431path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4c4d477)); // -7.31283e+12f, -6.76303e+12f
8432path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d442)); // -7.31283e+12f, -7.31275e+12f
8433path.lineTo(SkBits2Float(0xd4d4a691), SkBits2Float(0xd4d4d442)); // -7.30662e+12f, -7.31275e+12f
8434path.lineTo(SkBits2Float(0xd454d4d4), SkBits2Float(0xd4d4aa30)); // -3.65641e+12f, -7.30711e+12f
8435path.lineTo(SkBits2Float(0xd4bd9def), SkBits2Float(0xd4d43df0)); // -6.51519e+12f, -7.29258e+12f
8436path.lineTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f
8437path.lineTo(SkBits2Float(0xd497ca70), SkBits2Float(0xd4c4d4ae)); // -5.21549e+12f, -6.76305e+12f
8438path.lineTo(SkBits2Float(0xd4bab953), SkBits2Float(0xd4c4d48e)); // -6.41579e+12f, -6.76304e+12f
8439path.lineTo(SkBits2Float(0xd4a63f0f), SkBits2Float(0xd4b83ab3)); // -5.71218e+12f, -6.33007e+12f
8440path.lineTo(SkBits2Float(0xd4ae61eb), SkBits2Float(0xd4ae61f4)); // -5.99174e+12f, -5.99174e+12f
8441path.lineTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f
8442path.close();
8443path.moveTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f
8444path.lineTo(SkBits2Float(0xd446965c), SkBits2Float(0xd4810237)); // -3.4117e+12f, -4.4327e+12f
8445path.lineTo(SkBits2Float(0xd45ac549), SkBits2Float(0xd45ac55f)); // -3.75845e+12f, -3.75846e+12f
8446path.lineTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f
8447path.close();
8448path.moveTo(SkBits2Float(0xd4b46028), SkBits2Float(0xd41e572a)); // -6.19766e+12f, -2.72027e+12f
8449path.lineTo(SkBits2Float(0xd4cde20a), SkBits2Float(0xd434bb57)); // -7.07408e+12f, -3.10495e+12f
8450path.lineTo(SkBits2Float(0xd4c75ffe), SkBits2Float(0xd46f215d)); // -6.85047e+12f, -4.10823e+12f
8451path.lineTo(SkBits2Float(0xd4b46028), SkBits2Float(0xd41e572a)); // -6.19766e+12f, -2.72027e+12f
8452path.close();
8453
8454 SkPath path1(path);
8455 path.reset();
8456 path.setFillType((SkPath::FillType) 0);
8457path.setFillType(SkPath::kWinding_FillType);
8458path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8459path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0xa5a50000), SkBits2Float(0xd4d4a5a5), SkBits2Float(0xd4d4d4d4)); // 0, -2.86229e-16f, -7.3065e+12f, -7.31283e+12f
8460path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4cfd4d4), SkBits2Float(0xd4d41dd4)); // -7.31283e+12f, -7.31283e+12f, -7.14103e+12f, -7.28827e+12f
8461path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d432d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4a5a5d4)); // -7.31283e+12f, -7.29109e+12f, -7.31283e+12f, -5.69161e+12f
8462path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0x00000000)); // -7.31283e+12f, -7.31283e+12f, -7.31283e+12f, 0
8463path.moveTo(SkBits2Float(0xa5a5a500), SkBits2Float(0xd4d4d4a5)); // -2.87347e-16f, -7.31281e+12f
8464path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0x2ad4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4cfd4d4)); // -7.31283e+12f, 3.78064e-13f, -7.31283e+12f, -7.14103e+12f
8465path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4)); // -7.31283e+12f, -7.31283e+12f, -7.31283e+12f, -7.31283e+12f
8466path.quadTo(SkBits2Float(0xd4d40000), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4)); // -7.28426e+12f, -7.31283e+12f, -7.31283e+12f, -7.31283e+12f
8467
8468 SkPath path2(path);
8469 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
8470}
8471
8472static void fuzzhang_2(skiatest::Reporter* reporter, const char* filename) {
8473 SkPath path;
8474 path.setFillType((SkPath::FillType) 0);
8475path.setFillType(SkPath::kWinding_FillType);
8476path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8477path.quadTo(SkBits2Float(0xe0e02972), SkBits2Float(0xe0e060e0), SkBits2Float(0x728e4603), SkBits2Float(0x72727272)); // -1.29221e+20f, -1.29345e+20f, 5.63603e+30f, 4.80216e+30f
8478path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8479path.close();
8480path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8481path.quadTo(SkBits2Float(0x68720052), SkBits2Float(0x52527372), SkBits2Float(0x00527252), SkBits2Float(0x728e4601)); // 4.57127e+24f, 2.2597e+11f, 7.57152e-39f, 5.63603e+30f
8482path.quadTo(SkBits2Float(0x52ec7272), SkBits2Float(0x6265527f), SkBits2Float(0x8e460152), SkBits2Float(0x72ff8072)); // 5.07766e+11f, 1.05756e+21f, -2.4406e-30f, 1.01215e+31f
8483path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8484path.close();
8485path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8486path.lineTo(SkBits2Float(0x52626552), SkBits2Float(0x72727272)); // 2.43091e+11f, 4.80216e+30f
8487path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x62727272), SkBits2Float(0x39393939), SkBits2Float(0x728bc739)); // 4.80216e+30f, 1.11809e+21f, 0.000176643f, 5.53719e+30f
8488path.cubicTo(SkBits2Float(0x72728092), SkBits2Float(0x72727260), SkBits2Float(0x4d727272), SkBits2Float(0x5252522a), SkBits2Float(0x72735252), SkBits2Float(0x72707272)); // 4.80325e+30f, 4.80215e+30f, 2.54224e+08f, 2.2583e+11f, 4.81948e+30f, 4.76254e+30f
8489path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x56727272), SkBits2Float(0x72720152), SkBits2Float(0x72727270)); // 4.80216e+30f, 6.66433e+13f, 4.79341e+30f, 4.80216e+30f
8490path.quadTo(SkBits2Float(0x52526172), SkBits2Float(0x8e460300), SkBits2Float(0x72727272), SkBits2Float(0x52525272)); // 2.25894e+11f, -2.44068e-30f, 4.80216e+30f, 2.25832e+11f
8491path.conicTo(SkBits2Float(0xb5727272), SkBits2Float(0x7f2b727f), SkBits2Float(0x607272ff), SkBits2Float(0x72727276), SkBits2Float(0x2a527272)); // -9.03186e-07f, 2.27892e+38f, 6.98812e+19f, 4.80216e+30f, 1.86915e-13f
8492path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8493path.close();
8494path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8495path.lineTo(SkBits2Float(0x72727272), SkBits2Float(0x52525f72)); // 4.80216e+30f, 2.25886e+11f
8496path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8497path.close();
8498path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
8499path.quadTo(SkBits2Float(0x52727272), SkBits2Float(0x64655252), SkBits2Float(0x72c1c152), SkBits2Float(0x72727272)); // 2.60326e+11f, 1.69209e+22f, 7.67543e+30f, 4.80216e+30f
8500
8501 SkPath path1(path);
8502 path.reset();
8503 path.setFillType((SkPath::FillType) 0);
8504path.setFillType(SkPath::kWinding_FillType);
8505
8506 SkPath path2(path);
8507 testPathOpFail(reporter, path1, path2, (SkPathOp) 1, filename);
8508}
8509
8510static void fuzzhang_3(skiatest::Reporter* reporter, const char* filename) {
8511 SkPath path;
8512 path.setFillType((SkPath::FillType) 0);
8513path.setFillType(SkPath::kWinding_FillType);
8514
8515 SkPath path1(path);
8516 path.reset();
8517 path.setFillType((SkPath::FillType) 0);
8518path.setFillType(SkPath::kWinding_FillType);
8519path.moveTo(SkBits2Float(0x46090052), SkBits2Float(0x7270726c)); // 8768.08f, 4.76254e+30f
8520path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
8521path.close();
8522path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
8523path.lineTo(SkBits2Float(0x77727272), SkBits2Float(0x52520072)); // 4.91741e+33f, 2.25488e+11f
8524path.lineTo(SkBits2Float(0x46090052), SkBits2Float(0x727272ce)); // 8768.08f, 4.80219e+30f
8525path.quadTo(SkBits2Float(0x725252ec), SkBits2Float(0x72727272), SkBits2Float(0x72727272), SkBits2Float(0x39393962)); // 4.16589e+30f, 4.80216e+30f, 4.80216e+30f, 0.000176644f
8526path.lineTo(SkBits2Float(0x6c460900), SkBits2Float(0x72727072)); // 9.57639e+26f, 4.802e+30f
8527path.cubicTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x72943603), SkBits2Float(0x72777272), SkBits2Float(0x5c525200), SkBits2Float(0x46090052), SkBits2Float(0x727272ce)); // -1.29345e+20f, 5.87124e+30f, 4.90119e+30f, 2.368e+17f, 8768.08f, 4.80219e+30f
8528path.quadTo(SkBits2Float(0x725252ec), SkBits2Float(0x72727272), SkBits2Float(0x72727272), SkBits2Float(0x39393962)); // 4.16589e+30f, 4.80216e+30f, 4.80216e+30f, 0.000176644f
8529path.lineTo(SkBits2Float(0x0052ca00), SkBits2Float(0x728e4603)); // 7.60297e-39f, 5.63603e+30f
8530path.quadTo(SkBits2Float(0xff727272), SkBits2Float(0x52527272), SkBits2Float(0x39392072), SkBits2Float(0xe0393939)); // -3.22267e+38f, 2.25966e+11f, 0.000176551f, -5.3387e+19f
8531path.lineTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
8532path.close();
8533path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
8534path.cubicTo(SkBits2Float(0xdada7272), SkBits2Float(0x2dff7272), SkBits2Float(0x767272f0), SkBits2Float(0x72727272), SkBits2Float(0x21727f72), SkBits2Float(0x0b210929)); // -3.07437e+16f, 2.9041e-11f, 1.22936e+33f, 4.80216e+30f, 8.21615e-19f, 3.10144e-32f
8535path.cubicTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0x72a5d6d6), SkBits2Float(0x72553872), SkBits2Float(0xdada7072), SkBits2Float(0x5252525a), SkBits2Float(0x72727252)); // -1.18109e+14f, 6.56957e+30f, 4.22327e+30f, -3.07426e+16f, 2.25831e+11f, 4.80215e+30f
8536path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0xdada0072), SkBits2Float(0x52524b5a), SkBits2Float(0x72528000)); // 4.79991e+30f, -3.0681e+16f, 2.25802e+11f, 4.16938e+30f
8537path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0xca005252), SkBits2Float(0x46030052), SkBits2Float(0x7272728e)); // 4.80216e+30f, -2.10242e+06f, 8384.08f, 4.80217e+30f
8538path.quadTo(SkBits2Float(0x7272ff72), SkBits2Float(0x20725252), SkBits2Float(0x39393939), SkBits2Float(0xd76ee039)); // 4.81307e+30f, 2.05254e-19f, 0.000176643f, -2.62647e+14f
8539path.cubicTo(SkBits2Float(0xdada7272), SkBits2Float(0x2dff7272), SkBits2Float(0x767272f0), SkBits2Float(0x72727272), SkBits2Float(0x21727f72), SkBits2Float(0x0b210929)); // -3.07437e+16f, 2.9041e-11f, 1.22936e+33f, 4.80216e+30f, 8.21615e-19f, 3.10144e-32f
8540path.cubicTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0x72a5d6d6), SkBits2Float(0x72553872), SkBits2Float(0xdada7072), SkBits2Float(0x5252525a), SkBits2Float(0x72727252)); // -1.18109e+14f, 6.56957e+30f, 4.22327e+30f, -3.07426e+16f, 2.25831e+11f, 4.80215e+30f
8541path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0xdada0072), SkBits2Float(0x52524b5a), SkBits2Float(0x72528000)); // 4.79991e+30f, -3.0681e+16f, 2.25802e+11f, 4.16938e+30f
8542path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
8543path.quadTo(SkBits2Float(0x72667254), SkBits2Float(0x00000040), SkBits2Float(0x00a70155), SkBits2Float(0x726800ff)); // 4.56447e+30f, 8.96831e-44f, 1.5337e-38f, 4.59531e+30f
8544path.quadTo(SkBits2Float(0x7b727272), SkBits2Float(0xad000c52), SkBits2Float(0x1c10adad), SkBits2Float(0x72728d8a)); // 1.25886e+36f, -7.27869e-12f, 4.78701e-22f, 4.80425e+30f
8545path.quadTo(SkBits2Float(0xff056546), SkBits2Float(0x727205ff), SkBits2Float(0x524b5aff), SkBits2Float(0x64005252)); // -1.77313e+38f, 4.79377e+30f, 2.18351e+11f, 9.46846e+21f
8546path.quadTo(SkBits2Float(0x72524872), SkBits2Float(0xdada7272), SkBits2Float(0x5252525a), SkBits2Float(0x72727252)); // 4.16508e+30f, -3.07437e+16f, 2.25831e+11f, 4.80215e+30f
8547path.quadTo(SkBits2Float(0x72724172), SkBits2Float(0xdad10072), SkBits2Float(0x52524b5a), SkBits2Float(0x725b8000)); // 4.79837e+30f, -2.94144e+16f, 2.25802e+11f, 4.34765e+30f
8548path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
8549path.quadTo(SkBits2Float(0x72728372), SkBits2Float(0x00000040), SkBits2Float(0xf6a70147), SkBits2Float(0xc2c2c256)); // 4.80347e+30f, 8.96831e-44f, -1.69363e+33f, -97.3796f
8550path.lineTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
8551path.close();
8552path.moveTo(SkBits2Float(0x7a787a7a), SkBits2Float(0x7a3a7a7a)); // 3.22543e+35f, 2.42063e+35f
8553path.lineTo(SkBits2Float(0x8f4603e0), SkBits2Float(0x72727272)); // -9.7629e-30f, 4.80216e+30f
8554path.quadTo(SkBits2Float(0x00807272), SkBits2Float(0x46090052), SkBits2Float(0x7270726c), SkBits2Float(0x60e04372)); // 1.1796e-38f, 8768.08f, 4.76254e+30f, 1.29279e+20f
8555path.moveTo(SkBits2Float(0x943603e0), SkBits2Float(0x77727272)); // -9.18942e-27f, 4.91741e+33f
8556path.quadTo(SkBits2Float(0x5c525200), SkBits2Float(0x46090052), SkBits2Float(0x727272ce), SkBits2Float(0x5252ec72)); // 2.368e+17f, 8768.08f, 4.80219e+30f, 2.26478e+11f
8557
8558 SkPath path2(path);
8559 testPathOpFail(reporter, path1, path2, (SkPathOp) 3, filename);
8560}
8561
8562static void fuzz754434_1(skiatest::Reporter* reporter, const char* filename) {
8563 SkPath path;
8564 path.setFillType((SkPath::FillType) 0);
8565path.setFillType(SkPath::kWinding_FillType);
8566
8567 SkPath path1(path);
8568 path.reset();
8569 path.setFillType((SkPath::FillType) 0);
8570path.setFillType(SkPath::kWinding_FillType);
8571path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8572path.cubicTo(SkBits2Float(0x535e5372), SkBits2Float(0x53536153), SkBits2Float(0x79530f53), SkBits2Float(0x101b6c88), SkBits2Float(0x5353735e), SkBits2Float(0x006df653)); // 9.54883e+11f, 9.07871e+11f, 6.84928e+34f, 3.0652e-29f, 9.08174e+11f, 1.00984e-38f
8573path.cubicTo(SkBits2Float(0xf26df46d), SkBits2Float(0xf6f6f6f6), SkBits2Float(0x5656f666), SkBits2Float(0x5a565656), SkBits2Float(0x00000056), SkBits2Float(0xf66e5600)); // -4.71318e+30f, -2.50452e+33f, 5.90884e+13f, 1.50826e+16f, 1.20512e-43f, -1.20851e+33f
8574path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00faf6f6)); // -1.71467e+38f, 2.30475e-38f
8575path.moveTo(SkBits2Float(0x60576bfa), SkBits2Float(0x006df653)); // 6.20911e+19f, 1.00984e-38f
8576path.cubicTo(SkBits2Float(0xf26df46d), SkBits2Float(0xf653f6f6), SkBits2Float(0x563ef666), SkBits2Float(0x56565656), SkBits2Float(0x65565656), SkBits2Float(0xf6765656)); // -4.71318e+30f, -1.07479e+33f, 5.24914e+13f, 5.89166e+13f, 6.32612e+22f, -1.24908e+33f
8577
8578 SkPath path2(path);
8579 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
8580}
8581
8582static void fuzz754434_2(skiatest::Reporter* reporter, const char* filename) {
8583 SkPath path;
8584 path.setFillType((SkPath::FillType) 1);
8585path.setFillType(SkPath::kEvenOdd_FillType);
8586path.moveTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0
8587path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf66e5600)); // 0, -1.20851e+33f
8588path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf629168b)); // 0, -8.57378e+32f
8589path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8590path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0
8591path.close();
8592
8593 SkPath path1(path);
8594 path.reset();
8595 path.setFillType((SkPath::FillType) 0);
8596path.setFillType(SkPath::kWinding_FillType);
8597path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8598path.lineTo(SkBits2Float(0x03e8f6f6), SkBits2Float(0xf7060000)); // 1.36924e-36f, -2.71784e+33f
8599path.lineTo(SkBits2Float(0x4ff6f6f6), SkBits2Float(0x3e3e3e2a)); // 8.28676e+09f, 0.185784f
8600path.conicTo(SkBits2Float(0x6c8879ff), SkBits2Float(0x08761b1b), SkBits2Float(0x7066662d), SkBits2Float(0x70707070), SkBits2Float(0x70707070)); // 1.31992e+27f, 7.40598e-34f, 2.8522e+29f, 2.97649e+29f, 2.97649e+29f
8601
8602 SkPath path2(path);
8603 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
8604}
8605
8606static void fuzz754434_3(skiatest::Reporter* reporter, const char* filename) {
8607 SkPath path;
8608 path.setFillType((SkPath::FillType) 0);
8609path.setFillType(SkPath::kWinding_FillType);
8610
8611 SkPath path1(path);
8612 path.reset();
8613 path.setFillType((SkPath::FillType) 0);
8614path.setFillType(SkPath::kWinding_FillType);
8615path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8616path.cubicTo(SkBits2Float(0x535e5372), SkBits2Float(0x53536153), SkBits2Float(0x79530f53), SkBits2Float(0x101b6c88), SkBits2Float(0x5353735e), SkBits2Float(0x006df653)); // 9.54883e+11f, 9.07871e+11f, 6.84928e+34f, 3.0652e-29f, 9.08174e+11f, 1.00984e-38f
8617path.cubicTo(SkBits2Float(0xf26df46d), SkBits2Float(0xf6f6f6f6), SkBits2Float(0x5656f666), SkBits2Float(0x5a565656), SkBits2Float(0x00000056), SkBits2Float(0xf66e5600)); // -4.71318e+30f, -2.50452e+33f, 5.90884e+13f, 1.50826e+16f, 1.20512e-43f, -1.20851e+33f
8618path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00faf6f6)); // -1.71467e+38f, 2.30475e-38f
8619path.moveTo(SkBits2Float(0x60576bfa), SkBits2Float(0x006df653)); // 6.20911e+19f, 1.00984e-38f
8620path.cubicTo(SkBits2Float(0xf26df46d), SkBits2Float(0xf653f6f6), SkBits2Float(0x563ef666), SkBits2Float(0x56565656), SkBits2Float(0x65565656), SkBits2Float(0xf6765656)); // -4.71318e+30f, -1.07479e+33f, 5.24914e+13f, 5.89166e+13f, 6.32612e+22f, -1.24908e+33f
8621
8622 SkPath path2(path);
8623 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
8624}
8625
8626static void fuzz754434_4(skiatest::Reporter* reporter, const char* filename) {
8627 SkPath path;
8628 path.setFillType((SkPath::FillType) 1);
8629path.setFillType(SkPath::kEvenOdd_FillType);
8630path.moveTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0
8631path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf66e5600)); // 0, -1.20851e+33f
8632path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf629168b)); // 0, -8.57378e+32f
8633path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8634path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0
8635path.close();
8636
8637 SkPath path1(path);
8638 path.reset();
8639 path.setFillType((SkPath::FillType) 0);
8640path.setFillType(SkPath::kWinding_FillType);
8641path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8642path.lineTo(SkBits2Float(0x03e8f6f6), SkBits2Float(0xf7060000)); // 1.36924e-36f, -2.71784e+33f
8643path.lineTo(SkBits2Float(0x4ff6f6f6), SkBits2Float(0x3e3e3e2a)); // 8.28676e+09f, 0.185784f
8644path.conicTo(SkBits2Float(0x6c8879ff), SkBits2Float(0x08761b1b), SkBits2Float(0x7066662d), SkBits2Float(0x70707070), SkBits2Float(0x70707070)); // 1.31992e+27f, 7.40598e-34f, 2.8522e+29f, 2.97649e+29f, 2.97649e+29f
8645
8646 SkPath path2(path);
8647 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
8648}
8649
8650static struct TestDesc failTests[] = {
8651 TEST(fuzz754434_1),
8652 TEST(fuzz754434_2),
8653 TEST(fuzz754434_3),
8654 TEST(fuzz754434_4),
8655 TEST(fuzzhang_3),
8656 TEST(fuzzhang_2),
8657 TEST(release_13),
8658 TEST(fuzzhang_1),
8659 TEST(fuzz763_57),
8660 TEST(fuzz763_56),
8661 TEST(fuzz763_55),
8662 TEST(fuzz763_54),
8663 TEST(fuzz763_53),
8664 TEST(fuzz763_52),
8665 TEST(fuzz763_51),
8666 TEST(fuzz763_50),
8667 TEST(fuzz763_49),
8668 TEST(fuzz763_48),
8669 TEST(fuzz763_47),
8670 TEST(fuzz763_46),
8671 TEST(fuzz763_45),
8672 TEST(fuzz763_44),
8673 TEST(fuzz763_43),
8674 TEST(fuzz763_42),
8675 TEST(fuzz763_41),
8676 TEST(fuzz763_40),
8677 TEST(fuzz763_39),
8678 TEST(fuzz763_38),
8679 TEST(fuzz763_37),
8680 TEST(fuzz763_36),
8681 TEST(fuzz763_35),
8682 TEST(fuzz763_34),
8683 TEST(fuzz763_33),
8684 TEST(fuzz763_32),
8685 TEST(fuzz763_31),
8686 TEST(fuzz763_30),
8687 TEST(fuzz763_29),
8688 TEST(fuzz763_28),
8689 TEST(fuzz763_27),
8690 TEST(fuzz763_26),
8691 TEST(fuzz763_25),
8692 TEST(fuzz763_24),
8693 TEST(fuzz763_23),
8694 TEST(fuzz763_22),
8695 TEST(fuzz763_21),
8696 TEST(fuzz763_20),
8697 TEST(fuzz763_19),
8698 TEST(fuzz763_18),
8699 TEST(fuzz763_17),
8700 TEST(fuzz763_16),
8701 TEST(fuzz763_15),
8702 TEST(fuzz763_14),
8703 TEST(fuzz763_13),
8704 TEST(fuzz763_12),
8705 TEST(fuzz763_11),
8706 TEST(fuzz763_10),
8707 TEST(kfuzz2),
8708 TEST(fuzz763_7),
8709 TEST(fuzz763_6),
8710 TEST(fuzz763_2c),
8711 TEST(fuzz763_2b),
8712 TEST(fuzz763_2a),
8713 TEST(fuzz763_5a),
8714 TEST(fuzz763_3a),
8715 TEST(fuzz763_1a),
8716 TEST(fuzz763_1b),
8717 TEST(fuzz763_1c),
8718 TEST(fuzz763_2),
8719 TEST(fuzz763_5),
8720 TEST(fuzz763_3),
8721 TEST(fuzz763_4),
8722 TEST(fuzz763_9),
8723 TEST(fuzz1450_1),
8724 TEST(fuzz1450_0),
8725 TEST(bug597926_0),
8726 TEST(fuzz535151),
8727 TEST(fuzz753_91),
8728 TEST(fuzz714),
8729 TEST(fuzz487a),
8730 TEST(fuzz433),
8731 TEST(fuzz1),
8732 TEST(fuzz487b),
8733 TEST(fuzz433b),
8734 TEST(bufferOverflow),
8735};
8736
8737static const size_t failTestCount = SK_ARRAY_COUNT(failTests);
8738
8739DEF_TEST(PathOpsFailOp, reporter) {
8740#if DEBUG_SHOW_TEST_NAME
8741 strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH);
8742#endif
8743 RunTestSet(reporter, failTests, failTestCount, nullptr, nullptr, nullptr, false);
8744}
8745
8746static struct TestDesc repTests[] = {
8747 TEST(fuzz763_5a),
8748};
8749
8750DEF_TEST(PathOpsRepOp, reporter) {
8751 for (int index = 0; index < 1; ++index)
8752 RunTestSet(reporter, repTests, SK_ARRAY_COUNT(repTests), nullptr, nullptr, nullptr, false);
8753}