Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
Classes | Macros | Functions | Variables
PathOpsOpTest.cpp File Reference
#include "include/core/SkPath.h"
#include "include/core/SkPathTypes.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkScalar.h"
#include "include/core/SkString.h"
#include "include/core/SkTypes.h"
#include "include/pathops/SkPathOps.h"
#include "include/private/base/SkDebug.h"
#include "include/utils/SkParsePath.h"
#include "src/base/SkFloatBits.h"
#include "src/core/SkGeometry.h"
#include "src/pathops/SkPathOpsCubic.h"
#include "src/pathops/SkPathOpsPoint.h"
#include "src/pathops/SkPathOpsQuad.h"
#include "tests/PathOpsDebug.h"
#include "tests/PathOpsExtendedTest.h"
#include "tests/PathOpsTestCommon.h"
#include "tests/Test.h"
#include <cstddef>
#include <iterator>

Go to the source code of this file.

Classes

class  PathTest_Private
 

Macros

#define TEST(name)   { name, #name }
 

Functions

static void path_edit (const SkPoint &from, const SkPoint &to, SkPath *path)
 
static void cubicOp1d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp2d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp3d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp5d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp6d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp7d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp8d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp9d (skiatest::Reporter *reporter, const char *filename)
 
static void quadOp9d (skiatest::Reporter *reporter, const char *filename)
 
static void lineOp9d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp1i (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp10d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp11d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp12d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp13d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp14d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp15d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp16d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp17d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp18d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp19i (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp20d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp21d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp22d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp23d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp24d (skiatest::Reporter *reporter, const char *filename)
 
static void testIntersect1 (skiatest::Reporter *reporter, const char *filename)
 
static void testUnion1 (skiatest::Reporter *reporter, const char *filename)
 
static void testDiff1 (skiatest::Reporter *reporter, const char *filename)
 
static void testXor1 (skiatest::Reporter *reporter, const char *filename)
 
static void testIntersect2 (skiatest::Reporter *reporter, const char *filename)
 
static void testUnion2 (skiatest::Reporter *reporter, const char *filename)
 
static void testDiff2 (skiatest::Reporter *reporter, const char *filename)
 
static void testXor2 (skiatest::Reporter *reporter, const char *filename)
 
static void testOp1d (skiatest::Reporter *reporter, const char *filename)
 
static void testOp2d (skiatest::Reporter *reporter, const char *filename)
 
static void testOp3d (skiatest::Reporter *reporter, const char *filename)
 
static void testOp1u (skiatest::Reporter *reporter, const char *filename)
 
static void testOp4d (skiatest::Reporter *reporter, const char *filename)
 
static void testOp5d (skiatest::Reporter *reporter, const char *filename)
 
static void testOp6d (skiatest::Reporter *reporter, const char *filename)
 
static void testOp7d (skiatest::Reporter *reporter, const char *filename)
 
static void testOp2u (skiatest::Reporter *reporter, const char *filename)
 
static void testOp8d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp25i (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp26d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp27d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp28u (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp29d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp30d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp31d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp31u (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp31x (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp32d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp33i (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp34d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp35d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp36u (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp37d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp38d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp39d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp40d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp41i (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp42d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp43d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp44d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp45d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp46d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp47d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp48d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp49d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp50d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp51d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp52d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp53d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp54d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp55d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp56d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp57d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp58d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp59d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp60d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp61d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp62d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp63d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp64d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp65d (skiatest::Reporter *reporter, const char *filename)
 
static void rectOp1d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp66u (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp67u (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp68u (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp69d (skiatest::Reporter *reporter, const char *filename)
 
static void rRect1 (skiatest::Reporter *reporter, const char *filename)
 
static void skp1 (skiatest::Reporter *reporter, const char *filename)
 
static void skp2 (skiatest::Reporter *reporter, const char *filename)
 
static void skp3 (skiatest::Reporter *reporter, const char *filename)
 
static void skp4 (skiatest::Reporter *reporter, const char *filename)
 
static void skp5 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp70d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp71d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp72i (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp73d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp74d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp75d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp76u (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp77i (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp78u (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp79u (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp80i (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp81d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp82i (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp83i (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp84d (skiatest::Reporter *reporter, const char *filename)
 
static void skpClip1 (skiatest::Reporter *reporter, const char *filename)
 
static void skpClip2 (skiatest::Reporter *reporter, const char *filename)
 
static void skp96prezzi1 (skiatest::Reporter *reporter, const char *filename)
 
static void skpancestry_com1 (skiatest::Reporter *reporter, const char *filename)
 
static void skpeldorado_com_ua1 (skiatest::Reporter *reporter, const char *filename)
 
static void skpbyte_com1 (skiatest::Reporter *reporter, const char *filename)
 
static void skphealth_com76 (skiatest::Reporter *reporter, const char *filename)
 
static void skpahrefs_com88 (skiatest::Reporter *reporter, const char *filename)
 
static void skpahrefs_com29 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp85d (skiatest::Reporter *reporter, const char *filename)
 
static void skpkkiste_to98 (skiatest::Reporter *reporter, const char *filename)
 
static void issue1417 (skiatest::Reporter *reporter, const char *filename)
 
static void issue1418 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp85i (skiatest::Reporter *reporter, const char *filename)
 
static void issue1418b (skiatest::Reporter *reporter, const char *filename)
 
static void rectOp1i (skiatest::Reporter *reporter, const char *filename)
 
static void rectOp2i (skiatest::Reporter *reporter, const char *filename)
 
static void rectOp3x (skiatest::Reporter *reporter, const char *filename)
 
static void issue1435 (skiatest::Reporter *reporter, const char *filename)
 
static void skpkkiste_to716 (skiatest::Reporter *reporter, const char *filename)
 
static void loopEdge1 (skiatest::Reporter *reporter, const char *filename)
 
static void loopEdge2 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp86i (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp87u (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp88u (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp89u (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp90u (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp91u (skiatest::Reporter *reporter, const char *filename)
 
static void skpaaalgarve_org53 (skiatest::Reporter *reporter, const char *filename)
 
static void skpabcspark_ca103 (skiatest::Reporter *reporter, const char *filename)
 
static void skpacesoftech_com47 (skiatest::Reporter *reporter, const char *filename)
 
static void skpact_com43 (skiatest::Reporter *reporter, const char *filename)
 
static void skpadbox_lt8 (skiatest::Reporter *reporter, const char *filename)
 
static void skpadindex_de4 (skiatest::Reporter *reporter, const char *filename)
 
static void skpadithya_putr4_blogspot_com551 (skiatest::Reporter *reporter, const char *filename)
 
static void skpadspert_de11 (skiatest::Reporter *reporter, const char *filename)
 
static void skpaiaigames_com870 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp92i (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp93d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp94u (skiatest::Reporter *reporter, const char *filename)
 
static void skpadbox_lt15 (skiatest::Reporter *reporter, const char *filename)
 
static void skpadoption_org196 (skiatest::Reporter *reporter, const char *filename)
 
static void skpadspert_net23 (skiatest::Reporter *reporter, const char *filename)
 
static void skpadventistmission_org572 (skiatest::Reporter *reporter, const char *filename)
 
static void skpagentxsites_com55 (skiatest::Reporter *reporter, const char *filename)
 
static void skpbakosoft_com10 (skiatest::Reporter *reporter, const char *filename)
 
static void skpbambootheme_com12 (skiatest::Reporter *reporter, const char *filename)
 
static void skpakmmos_ru100 (skiatest::Reporter *reporter, const char *filename)
 
static void skpcarpetplanet_ru22 (skiatest::Reporter *reporter, const char *filename)
 
static void skpcarrot_is24 (skiatest::Reporter *reporter, const char *filename)
 
static void skpbangalorenest_com4 (skiatest::Reporter *reporter, const char *filename)
 
static void skpbenzoteh_ru152 (skiatest::Reporter *reporter, const char *filename)
 
static void skpbestred_ru37 (skiatest::Reporter *reporter, const char *filename)
 
static void skpbingoentertainment_net189 (skiatest::Reporter *reporter, const char *filename)
 
static void skpcarrefour_ro62 (skiatest::Reporter *reporter, const char *filename)
 
static void skpcaffelavazzait_com_ua21 (skiatest::Reporter *reporter, const char *filename)
 
static void skpcamcorder_kz21 (skiatest::Reporter *reporter, const char *filename)
 
static void skpcavablar_net563 (skiatest::Reporter *reporter, const char *filename)
 
static void skpinsomnia_gr72 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp95u (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp96d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp97x (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp98x (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp99 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp100 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp101 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp102 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp103 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp104 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp105 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp106 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp107 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp108 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp109 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp110 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp111 (skiatest::Reporter *reporter, const char *filename)
 
static void xOp1u (skiatest::Reporter *reporter, const char *filename)
 
static void xOp1i (skiatest::Reporter *reporter, const char *filename)
 
static void xOp2i (skiatest::Reporter *reporter, const char *filename)
 
static void xOp3i (skiatest::Reporter *reporter, const char *filename)
 
static void findFirst1 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp112 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp113 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp114 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp114asQuad (skiatest::Reporter *reporter, const char *filename)
 
static void quadOp10i (skiatest::Reporter *reporter, const char *filename)
 
static void kari1 (skiatest::Reporter *reporter, const char *filename)
 
static void issue2504 (skiatest::Reporter *reporter, const char *filename)
 
static void issue2540 (skiatest::Reporter *reporter, const char *filename)
 
static void rects1 (skiatest::Reporter *reporter, const char *filename)
 
static void rects2 (skiatest::Reporter *reporter, const char *filename)
 
static void rects3 (skiatest::Reporter *reporter, const char *filename)
 
static void rects4 (skiatest::Reporter *reporter, const char *filename)
 
static void issue2753 (skiatest::Reporter *reporter, const char *filename)
 
static void issue2808 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp115 (skiatest::Reporter *reporter, const char *filename)
 
static void testRect1 (skiatest::Reporter *reporter, const char *filename)
 
static void testRect2 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp116 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp117 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp118 (skiatest::Reporter *reporter, const char *filename)
 
static void loop1 (skiatest::Reporter *reporter, const char *filename)
 
static void loop1asQuad (skiatest::Reporter *reporter, const char *filename)
 
static void loop2 (skiatest::Reporter *reporter, const char *filename)
 
static void loop3 (skiatest::Reporter *reporter, const char *filename)
 
static void loop4 (skiatest::Reporter *reporter, const char *filename)
 
static void issue3517 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp119 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp120 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp121 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp122 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp123 (skiatest::Reporter *reporter, const char *filename)
 
static void loop5 (skiatest::Reporter *reporter, const char *filename)
 
static void loop6 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp124 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp125 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp126 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp127 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp128 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp129 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp130 (skiatest::Reporter *reporter, const char *filename)
 
static void complex_to_quads (const SkPoint pts[], SkPath *path)
 
static void cubicOp130a (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp131 (skiatest::Reporter *reporter, const char *filename)
 
static void circlesOp1 (skiatest::Reporter *reporter, const char *filename)
 
static void circlesOp2 (skiatest::Reporter *reporter, const char *filename)
 
static void rRect1x (skiatest::Reporter *reporter, const char *filename)
 
static void loop7 (skiatest::Reporter *reporter, const char *filename)
 
static void rects5 (skiatest::Reporter *reporter, const char *filename)
 
static void loop8 (skiatest::Reporter *reporter, const char *filename)
 
static void loop9 (skiatest::Reporter *reporter, const char *filename)
 
static void circlesOp3 (skiatest::Reporter *reporter, const char *filename)
 
static void loop10 (skiatest::Reporter *reporter, const char *filename)
 
static void loop11 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp132 (skiatest::Reporter *reporter, const char *filename)
 
static void loop12 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp133 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp134 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp135 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp136 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp136a (skiatest::Reporter *reporter, const char *filename)
 
static void cubics137 (skiatest::Reporter *reporter, const char *filename)
 
static void cubics138 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp139 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp140 (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp141 (skiatest::Reporter *reporter, const char *filename)
 
static void quadRect1 (skiatest::Reporter *reporter, const char *filename)
 
static void quadRect2 (skiatest::Reporter *reporter, const char *filename)
 
static void quadRect3 (skiatest::Reporter *reporter, const char *filename)
 
static void quadRect4 (skiatest::Reporter *reporter, const char *filename)
 
static void quadRect5 (skiatest::Reporter *reporter, const char *filename)
 
static void quadRect6 (skiatest::Reporter *reporter, const char *filename)
 
static void loops4i (skiatest::Reporter *reporter, const char *filename)
 
static void loops5i (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp142 (skiatest::Reporter *reporter, const char *filename)
 
static void cubics6d (skiatest::Reporter *reporter, const char *filename)
 
static void cubics7d (skiatest::Reporter *reporter, const char *filename)
 
static void cubics8d (skiatest::Reporter *reporter, const char *filename)
 
static void cubics9d (skiatest::Reporter *reporter, const char *filename)
 
static void cubics10u (skiatest::Reporter *reporter, const char *filename)
 
static void cubics11i (skiatest::Reporter *reporter, const char *filename)
 
static void cubics12d (skiatest::Reporter *reporter, const char *filename)
 
static void cubics13d (skiatest::Reporter *reporter, const char *filename)
 
static void cubics14d (skiatest::Reporter *reporter, const char *filename)
 
static void cubics15d (skiatest::Reporter *reporter, const char *filename)
 
static void cubics16i (skiatest::Reporter *reporter, const char *filename)
 
static void cubics17d (skiatest::Reporter *reporter, const char *filename)
 
static void cubics18d (skiatest::Reporter *reporter, const char *filename)
 
static void cubics19d (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp157 (skiatest::Reporter *reporter, const char *filename)
 
static void cubics20d (skiatest::Reporter *reporter, const char *filename)
 
static void loops20i (skiatest::Reporter *reporter, const char *filename)
 
static void loops21i (skiatest::Reporter *reporter, const char *filename)
 
static void loops22i (skiatest::Reporter *reporter, const char *filename)
 
static void loops23i (skiatest::Reporter *reporter, const char *filename)
 
static void loops24i (skiatest::Reporter *reporter, const char *filename)
 
static void loops25i (skiatest::Reporter *reporter, const char *filename)
 
static void loops26i (skiatest::Reporter *reporter, const char *filename)
 
static void loops27i (skiatest::Reporter *reporter, const char *filename)
 
static void loops28i (skiatest::Reporter *reporter, const char *filename)
 
static void loops29i (skiatest::Reporter *reporter, const char *filename)
 
static void loops30i (skiatest::Reporter *reporter, const char *filename)
 
static void loops31i (skiatest::Reporter *reporter, const char *filename)
 
static void loops32i (skiatest::Reporter *reporter, const char *filename)
 
static void loops33i (skiatest::Reporter *reporter, const char *filename)
 
static void loops33iMod (skiatest::Reporter *reporter, const char *filename)
 
static void loops33iAsQuads (skiatest::Reporter *reporter, const char *filename)
 
static void loops34i (skiatest::Reporter *reporter, const char *filename)
 
static void loops35i (skiatest::Reporter *reporter, const char *filename)
 
static void loops36i (skiatest::Reporter *reporter, const char *filename)
 
static void loops37i (skiatest::Reporter *reporter, const char *filename)
 
static void loops38i (skiatest::Reporter *reporter, const char *filename)
 
static void loops39i (skiatest::Reporter *reporter, const char *filename)
 
static void loops40i (skiatest::Reporter *reporter, const char *filename)
 
static void loops40iAsQuads (skiatest::Reporter *reporter, const char *filename)
 
static void loops44i (skiatest::Reporter *reporter, const char *filename)
 
static void loops45i (skiatest::Reporter *reporter, const char *filename)
 
static void loops46i (skiatest::Reporter *reporter, const char *filename)
 
static void loops47i (skiatest::Reporter *reporter, const char *filename)
 
static void loops48i (skiatest::Reporter *reporter, const char *filename)
 
static void loops49i (skiatest::Reporter *reporter, const char *filename)
 
static void loops50i (skiatest::Reporter *reporter, const char *filename)
 
static void loops51i (skiatest::Reporter *reporter, const char *filename)
 
static void loops52i (skiatest::Reporter *reporter, const char *filename)
 
static void loops53i (skiatest::Reporter *reporter, const char *filename)
 
static void loops54i (skiatest::Reporter *reporter, const char *filename)
 
static void loops55i (skiatest::Reporter *reporter, const char *filename)
 
static void loops56i (skiatest::Reporter *reporter, const char *filename)
 
static void loops57i (skiatest::Reporter *reporter, const char *filename)
 
static void loops58i (skiatest::Reporter *reporter, const char *filename)
 
static void loops58iAsQuads (skiatest::Reporter *reporter, const char *filename)
 
static void loops59i (skiatest::Reporter *reporter, const char *filename)
 
static void loops59iasQuads (skiatest::Reporter *reporter, const char *filename)
 
static void cubics41d (skiatest::Reporter *reporter, const char *filename)
 
void loops61i (skiatest::Reporter *reporter, const char *filename)
 
static void loops62i (skiatest::Reporter *reporter, const char *filename)
 
static void loops63i (skiatest::Reporter *reporter, const char *filename)
 
static void cubics44d (skiatest::Reporter *reporter, const char *filename)
 
static void cubics45u (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz38 (skiatest::Reporter *reporter, const char *filename)
 
static void crbug_526025 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzzX_392 (skiatest::Reporter *reporter, const char *filename)
 
static void dean2 (skiatest::Reporter *reporter, const char *filename)
 
static void cubics_d (skiatest::Reporter *reporter, const char *filename)
 
static void cubics_d2 (skiatest::Reporter *reporter, const char *filename)
 
static void loops_i1 (skiatest::Reporter *reporter, const char *filename)
 
static void loops_i2 (skiatest::Reporter *reporter, const char *filename)
 
static void loops_i3 (skiatest::Reporter *reporter, const char *filename)
 
static void loops_i4 (skiatest::Reporter *reporter, const char *filename)
 
static void loops_i5 (skiatest::Reporter *reporter, const char *filename)
 
static void loops_i6 (skiatest::Reporter *reporter, const char *filename)
 
static void cubics_d3 (skiatest::Reporter *reporter, const char *filename)
 
static void cubics_o (skiatest::Reporter *reporter, const char *filename)
 
static void cubicOp158 (skiatest::Reporter *reporter, const char *filename)
 
static void loop17 (skiatest::Reporter *reporter, const char *filename)
 
static void circlesOp4 (skiatest::Reporter *reporter, const char *filename)
 
static void bug5240 (skiatest::Reporter *reporter, const char *filename)
 
static void android1 (skiatest::Reporter *reporter, const char *filename)
 
static void seanbug (skiatest::Reporter *reporter, const char *filename)
 
static void halbug (skiatest::Reporter *reporter, const char *filename)
 
static void testRect1_u (skiatest::Reporter *reporter, const char *filename)
 
static void filinmangust14 (skiatest::Reporter *reporter, const char *filename)
 
static void grshapearcs1 (skiatest::Reporter *reporter, const char *filename)
 
static void op_1 (skiatest::Reporter *reporter, const char *filename)
 
static void op_2 (skiatest::Reporter *reporter, const char *filename)
 
static void op_3 (skiatest::Reporter *reporter, const char *filename)
 
static void op_4 (skiatest::Reporter *reporter, const char *filename)
 
static void bug8228 (skiatest::Reporter *reporter, const char *filename)
 
static void bug8380 (skiatest::Reporter *reporter, const char *filename)
 
 DEF_TEST (PathOpsOp, reporter)
 
static void fuzz767834 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz535151 (skiatest::Reporter *reporter, const char *filename)
 
static void bufferOverflow (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz433 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz433b (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz487a (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz487b (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz714 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz1 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz753_91 (skiatest::Reporter *reporter, const char *filename)
 
static void bug597926_0 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz1450_0 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz1450_1 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_9 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_4 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_3 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_5 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_2 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_1c (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_1b (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_1a (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_3a (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_5a (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_2a (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_2b (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_2c (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_6 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_7 (skiatest::Reporter *reporter, const char *filename)
 
static void kfuzz2 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_10 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_11 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_12 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_13 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_14 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_15 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_16 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_17 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_18 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_19 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_20 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_21 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_22 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_23 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_24 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_25 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_26 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_28 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_27 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_29 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_30 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_31 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_33 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_32 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_34 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_36 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_35 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_37 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_38 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_41 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_40 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_39 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_42 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_43 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_44 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_45 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_46 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_47 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_48 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_49 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_50 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_51 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_52 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_53 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_54 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_55 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_56 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz763_57 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzzhang_1 (skiatest::Reporter *reporter, const char *filename)
 
static void release_13 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzzhang_2 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzzhang_3 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz754434_1 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz754434_2 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz754434_3 (skiatest::Reporter *reporter, const char *filename)
 
static void fuzz754434_4 (skiatest::Reporter *reporter, const char *filename)
 
 DEF_TEST (PathOpsFailOp, reporter)
 
 DEF_TEST (PathOpsRepOp, reporter)
 

Variables

SkPathOp ops []
 
static void(* skipTest )(skiatest::Reporter *, const char *filename) = nullptr
 
static void(* firstTest )(skiatest::Reporter *, const char *filename) = nullptr
 
static void(* stopTest )(skiatest::Reporter *, const char *filename) = nullptr
 
static struct TestDesc tests []
 
static const size_t testCount = std::size(tests)
 
static struct TestDesc subTests []
 
static const size_t subTestCount = std::size(subTests)
 
static void(* firstSubTest )(skiatest::Reporter *, const char *filename) = nullptr
 
static bool runSubTests = false
 
static bool runSubTestsFirst = true
 
static bool runReverse = false
 
static struct TestDesc failTests []
 
static const size_t failTestCount = std::size(failTests)
 
static struct TestDesc repTests []
 

Macro Definition Documentation

◆ TEST

#define TEST (   name)    { name, #name }

Definition at line 9123 of file PathOpsOpTest.cpp.

Function Documentation

◆ android1()

static void android1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5432 of file PathOpsOpTest.cpp.

5432 {
5433 SkPath path, pathB;
5434path.moveTo(SkBits2Float(0xc0a00000), SkBits2Float(0x00000000)); // -5, 0
5435path.lineTo(SkBits2Float(0x44866000), SkBits2Float(0x00000000)); // 1075, 0
5436path.lineTo(SkBits2Float(0x44866000), SkBits2Float(0x43720000)); // 1075, 242
5437path.lineTo(SkBits2Float(0xc0a00000), SkBits2Float(0x43720000)); // -5, 242
5438path.lineTo(SkBits2Float(0xc0a00000), SkBits2Float(0x00000000)); // -5, 0
5439path.close();
5440pathB.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
5441pathB.lineTo(SkBits2Float(0x44870000), SkBits2Float(0x00000000)); // 1080, 0
5442pathB.lineTo(SkBits2Float(0x44870000), SkBits2Float(0x43720000)); // 1080, 242
5443pathB.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x43720000)); // 0, 242
5444pathB.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
5445pathB.close();
5446 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5447}
reporter
reporter
Definition FontMgrTest.cpp:39
testPathOp
bool testPathOp(skiatest::Reporter *reporter, const SkPath &a, const SkPath &b, const SkPathOp shapeOp, const char *testName)
Definition PathOpsExtendedTest.cpp:618
SkBits2Float
static float SkBits2Float(uint32_t bits)
Definition SkFloatBits.h:48
kIntersect_SkPathOp
@ kIntersect_SkPathOp
intersect the two paths
Definition SkPathOps.h:24
SkPath::moveTo
SkPath & moveTo(SkScalar x, SkScalar y)
Definition SkPath.cpp:678
SkPath::lineTo
SkPath & lineTo(SkScalar x, SkScalar y)
Definition SkPath.cpp:718
SkPath::close
SkPath & close()
Definition SkPath.cpp:813
flutter::path
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir path
Definition switches.h:57

◆ bufferOverflow()

static void bufferOverflow ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9634 of file PathOpsOpTest.cpp.

9634 {
9635 SkPath path;
9636 path.addRect(0,0, 300,170141183460469231731687303715884105728.f);
9637 SkPath pathB;
9638 pathB.addRect(0,0, 300,16);
9639 testPathOpFuzz(reporter, path, pathB, kUnion_SkPathOp, filename);
9640}
testPathOpFuzz
bool testPathOpFuzz(skiatest::Reporter *reporter, const SkPath &a, const SkPath &b, const SkPathOp shapeOp, const char *testName)
Definition PathOpsExtendedTest.cpp:630
kUnion_SkPathOp
@ kUnion_SkPathOp
union (inclusive-or) the two paths
Definition SkPathOps.h:25
SkPath::addRect
SkPath & addRect(const SkRect &rect, SkPathDirection dir, unsigned start)
Definition SkPath.cpp:854

◆ bug5240()

static void bug5240 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5421 of file PathOpsOpTest.cpp.

5421 {
5422 SkPath path;
5423path.moveTo(815, 82);
5424path.cubicTo(814.4794311523438f, 82.7868881225586f, 814.5330810546875f,
542582.6266555786133f, 814.5291137695312f, 82.6252212524414f);
5426path.cubicTo(814.5229492187500f, 82.6230010986328f, 814.3790283203125f,
542783.0008087158203f, 813.8533935546875f, 82.7072601318359f);
5428path.close();
5429 testPathOp(reporter, path, path, kUnion_SkPathOp, filename);
5430}

◆ bug597926_0()

static void bug597926_0 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9850 of file PathOpsOpTest.cpp.

9850 {
9851SkPath path;
9852path.setFillType((SkPathFillType) 0);
9853path.moveTo(SkBits2Float(0x43b38000), SkBits2Float(0x433e0000)); // 359, 190
9854path.lineTo(SkBits2Float(0x40c00000), SkBits2Float(0x449ce000)); // 6, 1255
9855path.cubicTo(SkBits2Float(0x438c0000), SkBits2Float(0x4497a000), SkBits2Float(0x43e40000), SkBits2Float(0x44750000), SkBits2Float(0x41000000), SkBits2Float(0x44aa2000)); // 280, 1213, 456, 980, 8, 1361
9856path.moveTo(SkBits2Float(0x43290000), SkBits2Float(0x4431c000)); // 169, 711
9857path.lineTo(SkBits2Float(0xd987d6ba), SkBits2Float(0xd93d0ad4)); // -4.7794e+15f, -3.32567e+15f
9858path.conicTo(SkBits2Float(0x43cc8000), SkBits2Float(0x445b8000), SkBits2Float(0xd888b096), SkBits2Float(0xd9a1ebfa), SkBits2Float(0x3ebcb199)); // 409, 878, -1.20234e+15f, -5.69712e+15f, 0.368542f
9859path.cubicTo(SkBits2Float(0x43c00000), SkBits2Float(0x443a8000), SkBits2Float(0x42380000), SkBits2Float(0x4421c000), SkBits2Float(0x42500000), SkBits2Float(0x448ca000)); // 384, 746, 46, 647, 52, 1125
9860path.quadTo(SkBits2Float(0x43948000), SkBits2Float(0x42ac0000), SkBits2Float(0x43880000), SkBits2Float(0x4487e000)); // 297, 86, 272, 1087
9861SkPath path1(path);
9862path.reset();
9863path.setFillType((SkPathFillType) 0);
9864path.moveTo(SkBits2Float(0xc51d735c), SkBits2Float(0xc49db029)); // -2519.21f, -1261.51f
9865path.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
9866path.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
9867path.quadTo(SkBits2Float(0xc51bf7eb), SkBits2Float(0xc49cf010), SkBits2Float(0xc51ba866), SkBits2Float(0xc49cb9e6)); // -2495.49f, -1255.5f, -2490.52f, -1253.81f
9868path.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
9869SkPath path2(path);
9870testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
9871}
path1
static SkPath path1()
Definition PathOpsIssue3651.cpp:19
path2
static SkPath path2()
Definition PathOpsIssue3651.cpp:198
SkPathOp
SkPathOp
Definition SkPathOps.h:22
SkPathFillType
SkPathFillType
Definition SkPathTypes.h:11

◆ bug8228()

static void bug8228 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9056 of file PathOpsOpTest.cpp.

9056 {
9057 SkPath path1;
9058 path1.moveTo(SkBits2Float(0x41fd5557), SkBits2Float(0x4292aaab));
9059 path1.lineTo(SkBits2Float(0x41fd5557), SkBits2Float(0x41555556));
9060 path1.conicTo(SkBits2Float(0x41fd5557), SkBits2Float(0x41200002), SkBits2Float(0x420c0000), SkBits2Float(0x41200002), SkBits2Float(0x3f3504f3));
9061 path1.lineTo(SkBits2Float(0x426071c7), SkBits2Float(0x41200002));
9062 path1.conicTo(SkBits2Float(0x426dc71d), SkBits2Float(0x41200002), SkBits2Float(0x426dc71d), SkBits2Float(0x41555556), SkBits2Float(0x3f3504f3));
9063 path1.lineTo(SkBits2Float(0x426dc71d), SkBits2Float(0x4292aaab));
9064 path1.conicTo(SkBits2Float(0x426dc71d), SkBits2Float(0x42995555), SkBits2Float(0x426071c7), SkBits2Float(0x42995555), SkBits2Float(0x3f3504f3));
9065 path1.lineTo(SkBits2Float(0x420c0000), SkBits2Float(0x42995555));
9066 path1.conicTo(SkBits2Float(0x41fd5557), SkBits2Float(0x42995555), SkBits2Float(0x41fd5557), SkBits2Float(0x4292aaab), SkBits2Float(0x3f3504f3));
9067 path1.close();
9068
9069 SkPath path2;
9070 path2.moveTo(SkBits2Float(0x41200000), SkBits2Float(0x41200000));
9071 path2.lineTo(SkBits2Float(0x41eb2366), SkBits2Float(0x41200000));
9072 path2.conicTo(SkBits2Float(0x41e9d2b6), SkBits2Float(0x4127bdec), SkBits2Float(0x41e9d2b6), SkBits2Float(0x412feb1c), SkBits2Float(0x3f7c9333));
9073 path2.lineTo(SkBits2Float(0x41e9d2b6), SkBits2Float(0x42855349));
9074 path2.conicTo(SkBits2Float(0x41e9d2b6), SkBits2Float(0x428b82b9), SkBits2Float(0x4201483b), SkBits2Float(0x428b82b9), SkBits2Float(0x3f3504f3));
9075 path2.lineTo(SkBits2Float(0x424fa11f), SkBits2Float(0x428b82b9));
9076 path2.conicTo(SkBits2Float(0x425bffff), SkBits2Float(0x428b82b9), SkBits2Float(0x425bffff), SkBits2Float(0x42855349), SkBits2Float(0x3f3504f3));
9077 path2.lineTo(SkBits2Float(0x425bffff), SkBits2Float(0x412feb1c));
9078 path2.conicTo(SkBits2Float(0x425bffff), SkBits2Float(0x4127bdec), SkBits2Float(0x425b57a7), SkBits2Float(0x41200000), SkBits2Float(0x3f7c9333));
9079 path2.lineTo(SkBits2Float(0x4282f24d), SkBits2Float(0x41200000));
9080 path2.conicTo(SkBits2Float(0x42829e21), SkBits2Float(0x4127bdec), SkBits2Float(0x42829e21), SkBits2Float(0x412feb1c), SkBits2Float(0x3f7c9333));
9081 path2.lineTo(SkBits2Float(0x42829e21), SkBits2Float(0x42855349));
9082 path2.conicTo(SkBits2Float(0x42829e21), SkBits2Float(0x428b82b9), SkBits2Float(0x4288cd91), SkBits2Float(0x428b82b9), SkBits2Float(0x3f3504f3));
9083 path2.lineTo(SkBits2Float(0x42affa03), SkBits2Float(0x428b82b9));
9084 path2.conicTo(SkBits2Float(0x42b62973), SkBits2Float(0x428b82b9), SkBits2Float(0x42b62973), SkBits2Float(0x42855349), SkBits2Float(0x3f3504f3));
9085 path2.lineTo(SkBits2Float(0x42b62973), SkBits2Float(0x412feb1c));
9086 path2.conicTo(SkBits2Float(0x42b62973), SkBits2Float(0x4127bdec), SkBits2Float(0x42b5d547), SkBits2Float(0x41200000), SkBits2Float(0x3f7c9333));
9087 path2.lineTo(SkBits2Float(0x42dc0000), SkBits2Float(0x41200000));
9088 path2.lineTo(SkBits2Float(0x42dc0000), SkBits2Float(0x42dc0000));
9089 path2.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x42dc0000));
9090 path2.lineTo(SkBits2Float(0x41200000), SkBits2Float(0x41200000));
9091 path2.close();
9092 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename);
9093}
SkPath::conicTo
SkPath & conicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar w)
Definition SkPath.cpp:756

◆ bug8380()

static void bug8380 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9095 of file PathOpsOpTest.cpp.

9095 {
9096SkPath path, path2;
9097path.setFillType(SkPathFillType::kEvenOdd);
9098path.moveTo(SkBits2Float(0xa6800000), SkBits2Float(0x43b0f22d)); // -8.88178e-16f, 353.892f
9099path.lineTo(SkBits2Float(0x42fc0000), SkBits2Float(0x4116566d)); // 126, 9.3961f
9100path.cubicTo(SkBits2Float(0x42fb439d), SkBits2Float(0x4114bbc7), SkBits2Float(0x42fa3ed7), SkBits2Float(0x411565bd), SkBits2Float(0x42f934d2), SkBits2Float(0x4116131e)); // 125.632f, 9.29584f, 125.123f, 9.33734f, 124.603f, 9.37967f
9101path.cubicTo(SkBits2Float(0x42f84915), SkBits2Float(0x4116acc3), SkBits2Float(0x42f75939), SkBits2Float(0x41174918), SkBits2Float(0x42f693f8), SkBits2Float(0x4116566d)); // 124.143f, 9.41718f, 123.674f, 9.45535f, 123.289f, 9.3961f
9102path.lineTo(SkBits2Float(0x42ec3cee), SkBits2Float(0x410127bb)); // 118.119f, 8.0722f
9103path.lineTo(SkBits2Float(0x4102c0ec), SkBits2Float(0x42d06d0e)); // 8.1721f, 104.213f
9104path.lineTo(SkBits2Float(0xa6000000), SkBits2Float(0x4381a63d)); // -4.44089e-16f, 259.299f
9105path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x43b0f22d)); // 0, 353.892f
9106path.lineTo(SkBits2Float(0xa6800000), SkBits2Float(0x43b0f22d)); // -8.88178e-16f, 353.892f
9107path.close();
9108path2.setFillType(SkPathFillType::kEvenOdd);
9109path2.moveTo(SkBits2Float(0x4102c0ec), SkBits2Float(0x42d06d0e)); // 8.1721f, 104.213f
9110path2.lineTo(SkBits2Float(0xc0ba5a1d), SkBits2Float(0x43b8e831)); // -5.8235f, 369.814f
9111path2.lineTo(SkBits2Float(0x42fc0000), SkBits2Float(0x411656d6)); // 126, 9.3962f
9112path2.cubicTo(SkBits2Float(0x42fa9cac), SkBits2Float(0x41134fdf), SkBits2Float(0x42f837cf), SkBits2Float(0x41185aee), SkBits2Float(0x42f693f8), SkBits2Float(0x411656d6)); // 125.306f, 9.207f, 124.109f, 9.5222f, 123.289f, 9.3962f
9113path2.lineTo(SkBits2Float(0x42ec3cee), SkBits2Float(0x410127bb)); // 118.119f, 8.0722f
9114path2.lineTo(SkBits2Float(0x4102c0ec), SkBits2Float(0x42d06d0e)); // 8.1721f, 104.213f
9115path2.close();
9116 testPathOp(reporter, path, path2, kIntersect_SkPathOp, filename);
9117}
SkPath::setFillType
void setFillType(SkPathFillType ft)
Definition SkPath.h:235
SkPath::cubicTo
SkPath & cubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3)
Definition SkPath.cpp:789

◆ circlesOp1()

static void circlesOp1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3911 of file PathOpsOpTest.cpp.

3911 {
3912 SkPath path, pathB;
3913 path.setFillType(SkPathFillType::kWinding);
3914 path.addCircle(0, 1, 2, SkPathDirection::kCCW);
3915 pathB.setFillType(SkPathFillType::kWinding);
3916 pathB.addCircle(0, 1, 1, SkPathDirection::kCW);
3917 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3918}
kDifference_SkPathOp
@ kDifference_SkPathOp
subtract the op path from the first path
Definition SkPathOps.h:23
SkPath::addCircle
SkPath & addCircle(SkScalar x, SkScalar y, SkScalar radius, SkPathDirection dir=SkPathDirection::kCW)
Definition SkPath.cpp:1149

◆ circlesOp2()

static void circlesOp2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3920 of file PathOpsOpTest.cpp.

3920 {
3921 SkPath path, pathB;
3922 path.setFillType(SkPathFillType::kWinding);
3923 path.addCircle(0, 1, 4, SkPathDirection::kCCW);
3924 pathB.setFillType(SkPathFillType::kWinding);
3925 pathB.addCircle(0, 4, 3, SkPathDirection::kCW);
3926 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3927}

◆ circlesOp3()

static void circlesOp3 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4017 of file PathOpsOpTest.cpp.

4017 {
4018 SkPath path, pathB;
4019 path.setFillType(SkPathFillType::kWinding);
4020 path.addCircle(0, 1, 2, SkPathDirection::kCCW);
4021 pathB.setFillType(SkPathFillType::kWinding);
4022 pathB.addCircle(3, 5, 3, SkPathDirection::kCW);
4023 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4024}

◆ circlesOp4()

static void circlesOp4 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5412 of file PathOpsOpTest.cpp.

5412 {
5413 SkPath path, pathB;
5414 path.setFillType(SkPathFillType::kWinding);
5415 path.addCircle(0, 1, 5, SkPathDirection::kCW);
5416 pathB.setFillType(SkPathFillType::kWinding);
5417 pathB.addCircle(0, 1, 0, SkPathDirection::kCW);
5418 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5419}

◆ complex_to_quads()

static void complex_to_quads ( const SkPoint  pts[],
SkPath *  path 
)
static

Definition at line 3866 of file PathOpsOpTest.cpp.

3866 {
3867 SkScalar loopT[3];
3868 if (SkDCubic::ComplexBreak(pts, loopT)) {
3869 SkPoint cubicPair[7];
3870 SkChopCubicAt(pts, cubicPair, loopT[0]);
3871 SkDCubic c1, c2;
3872 c1.set(cubicPair);
3873 c2.set(&cubicPair[3]);
3874 SkDQuad q1 = c1.toQuad();
3875 SkDQuad q2 = c2.toQuad();
3876 path->quadTo(q1[1].asSkPoint(), q1[2].asSkPoint());
3877 path->quadTo(q2[1].asSkPoint(), q2[2].asSkPoint());
3878 } else {
3879 path->cubicTo(pts[1], pts[2], pts[3]);
3880 }
3881}
SkChopCubicAt
void SkChopCubicAt(const SkPoint src[4], SkPoint dst[7], SkScalar t)
Definition SkGeometry.cpp:473
SkScalar
float SkScalar
Definition extension.cpp:12
SkDCubic::set
const SkDCubic & set(const SkPoint pts[kPointCount] SkDEBUGPARAMS(SkOpGlobalState *state=nullptr))
Definition SkPathOpsCubic.h:122
SkDCubic::toQuad
SkDQuad toQuad() const
Definition SkDCubicToQuads.cpp:36
SkDCubic::ComplexBreak
static int ComplexBreak(const SkPoint pts[4], SkScalar *t)
Definition SkPathOpsCubic.cpp:254

◆ crbug_526025()

static void crbug_526025 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5189 of file PathOpsOpTest.cpp.

5189 {
5190 SkPath path;
5191 path.setFillType((SkPathFillType) 1);
5192path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0xcf000000)); // 360, -2.14748e+09f
5193path.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
5194path.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
5195path.lineTo(SkBits2Float(0x444bf3bc), SkBits2Float(0x4460537e)); // 815.808f, 897.305f
5196path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f
5197path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000)); // 32, 16
5198path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000)); // 100, 512
5199path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f
5200path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000)); // 360, 1024
5201path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140
5202
5203 SkPath path1(path);
5204 path.reset();
5205 path.setFillType((SkPathFillType) 0);
5206path.moveTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321
5207path.lineTo(SkBits2Float(0x45d5c000), SkBits2Float(0x43870000)); // 6840, 270
5208path.lineTo(SkBits2Float(0xd0a00000), SkBits2Float(0x4cbebc20)); // -2.14748e+10f, 1e+08
5209path.lineTo(SkBits2Float(0x451f7000), SkBits2Float(0x42800000)); // 2551, 64
5210path.lineTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321
5211path.close();
5212
5213 SkPath path2(path);
5214 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
5215}

◆ cubicOp100()

static void cubicOp100 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3062 of file PathOpsOpTest.cpp.

3062 {
3063 SkPath path, pathB;
3064 path.setFillType(SkPathFillType::kWinding);
3065 path.moveTo(0,1);
3066 path.cubicTo(0,2, 2,1, 4,2);
3067 path.close();
3068 pathB.setFillType(SkPathFillType::kWinding);
3069 pathB.moveTo(1,2);
3070 pathB.cubicTo(2,4, 1,0, 2,0);
3071 pathB.close();
3072 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3073}

◆ cubicOp101()

static void cubicOp101 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3075 of file PathOpsOpTest.cpp.

3075 {
3076 SkPath path, pathB;
3077 path.setFillType(SkPathFillType::kWinding);
3078 path.moveTo(0, 1);
3079 path.cubicTo(2, 3, 2, 1, 5, 3);
3080 path.close();
3081 pathB.setFillType(SkPathFillType::kWinding);
3082 pathB.moveTo(1, 2);
3083 pathB.cubicTo(3, 5, 1, 0, 3, 2);
3084 pathB.close();
3085 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3086}

◆ cubicOp102()

static void cubicOp102 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3088 of file PathOpsOpTest.cpp.

3088 {
3089 SkPath path, pathB;
3090 path.setFillType(SkPathFillType::kWinding);
3091 path.moveTo(0,1);
3092 path.cubicTo(1,2, 1,0, 3,0);
3093 path.close();
3094 pathB.setFillType(SkPathFillType::kWinding);
3095 pathB.moveTo(0,1);
3096 pathB.cubicTo(0,3, 1,0, 2,1);
3097 pathB.close();
3098 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3099}

◆ cubicOp103()

static void cubicOp103 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3101 of file PathOpsOpTest.cpp.

3101 {
3102 SkPath path, pathB;
3103 path.setFillType(SkPathFillType::kWinding);
3104 path.moveTo(0,1);
3105 path.cubicTo(1,5, 2,0, 2,1);
3106 path.close();
3107 pathB.setFillType(SkPathFillType::kWinding);
3108 pathB.moveTo(0,2);
3109 pathB.cubicTo(1,2, 1,0, 5,1);
3110 pathB.close();
3111 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3112}

◆ cubicOp104()

static void cubicOp104 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3114 of file PathOpsOpTest.cpp.

3114 {
3115 SkPath path, pathB;
3116 path.setFillType(SkPathFillType::kWinding);
3117 path.moveTo(0,1);
3118 path.cubicTo(0,6, 4,0, 6,1);
3119 path.close();
3120 pathB.setFillType(SkPathFillType::kWinding);
3121 pathB.moveTo(0,4);
3122 pathB.cubicTo(1,6, 1,0, 6,0);
3123 pathB.close();
3124 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3125}

◆ cubicOp105()

static void cubicOp105 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3127 of file PathOpsOpTest.cpp.

3127 {
3128 SkPath path, pathB;
3129 path.setFillType(SkPathFillType::kWinding);
3130 path.moveTo(0,1);
3131 path.cubicTo(0,4, 6,5, 2,0);
3132 path.close();
3133 pathB.setFillType(SkPathFillType::kWinding);
3134 pathB.moveTo(5,6);
3135 pathB.cubicTo(0,2, 1,0, 4,0);
3136 pathB.close();
3137 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3138}

◆ cubicOp106()

static void cubicOp106 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3140 of file PathOpsOpTest.cpp.

3140 {
3141 SkPath path, pathB;
3142 path.setFillType(SkPathFillType::kWinding);
3143 path.moveTo(0, 1);
3144 path.cubicTo(4, 6, 2, 1, 2, 0);
3145 path.close();
3146 pathB.setFillType(SkPathFillType::kWinding);
3147 pathB.moveTo(1, 2);
3148 pathB.cubicTo(0, 2, 1, 0, 6, 4);
3149 pathB.close();
3150 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3151}

◆ cubicOp107()

static void cubicOp107 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3153 of file PathOpsOpTest.cpp.

3153 {
3154 SkPath path, pathB;
3155 path.setFillType(SkPathFillType::kWinding);
3156 path.moveTo(0, 1);
3157 path.cubicTo(4, 6, 2, 1, 2, 0);
3158 path.close();
3159 pathB.setFillType(SkPathFillType::kWinding);
3160 pathB.moveTo(1, 2);
3161 pathB.cubicTo(0, 2, 1, 0, 6, 4);
3162 pathB.close();
3163 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3164}

◆ cubicOp108()

static void cubicOp108 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3166 of file PathOpsOpTest.cpp.

3166 {
3167 SkPath path, pathB;
3168 path.setFillType(SkPathFillType::kWinding);
3169 path.moveTo(0, 1);
3170 path.cubicTo(4, 6, 2, 1, 2, 0);
3171 path.close();
3172 pathB.setFillType(SkPathFillType::kWinding);
3173 pathB.moveTo(1, 2);
3174 pathB.cubicTo(0, 2, 1, 0, 6, 4);
3175 pathB.close();
3176 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3177}

◆ cubicOp109()

static void cubicOp109 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3179 of file PathOpsOpTest.cpp.

3179 {
3180 SkPath path, pathB;
3181 path.setFillType(SkPathFillType::kWinding);
3182 path.moveTo(0,1);
3183 path.cubicTo(4,5, 6,3, 5,4);
3184 path.close();
3185 pathB.setFillType(SkPathFillType::kWinding);
3186 pathB.moveTo(3,6);
3187 pathB.cubicTo(4,5, 1,0, 5,4);
3188 pathB.close();
3189 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3190}

◆ cubicOp10d()

static void cubicOp10d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 203 of file PathOpsOpTest.cpp.

203 {
204 SkPath path, pathB;
205 path.setFillType(SkPathFillType::kWinding);
206 path.moveTo(0,1);
207 path.cubicTo(1,3, 1,0, 4,1);
208 path.close();
209 pathB.setFillType(SkPathFillType::kWinding);
210 pathB.moveTo(0,1);
211 pathB.cubicTo(1,4, 1,0, 3,1);
212 pathB.close();
213 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
214}

◆ cubicOp110()

static void cubicOp110 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3192 of file PathOpsOpTest.cpp.

3192 {
3193 SkPath path, pathB;
3194 path.setFillType(SkPathFillType::kEvenOdd);
3195 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
3196 path.addRect(0, 0, 4, 4, SkPathDirection::kCW);
3197 pathB.setFillType(SkPathFillType::kEvenOdd);
3198 pathB.addRect(0, 0, 2, 2, SkPathDirection::kCW);
3199 pathB.addRect(0, 0, 2, 2, SkPathDirection::kCW);
3200 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3201}

◆ cubicOp111()

static void cubicOp111 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3203 of file PathOpsOpTest.cpp.

3203 {
3204 SkPath path, pathB;
3205 path.setFillType(SkPathFillType::kWinding);
3206 path.moveTo(1,4);
3207 path.cubicTo(0,5, 4,1, 3,1);
3208 path.close();
3209 pathB.setFillType(SkPathFillType::kWinding);
3210 pathB.moveTo(1,4);
3211 pathB.cubicTo(1,3, 4,1, 5,0);
3212 pathB.close();
3213 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3214}

◆ cubicOp112()

static void cubicOp112 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3281 of file PathOpsOpTest.cpp.

3281 {
3282 SkPath path, pathB;
3283 path.setFillType(SkPathFillType::kWinding);
3284 path.moveTo(2,4);
3285 path.cubicTo(2,3, 6,4, 1,0);
3286 path.close();
3287 pathB.setFillType(SkPathFillType::kWinding);
3288 pathB.moveTo(4,6);
3289 pathB.cubicTo(0,1, 4,2, 3,2);
3290 pathB.close();
3291 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3292}

◆ cubicOp113()

static void cubicOp113 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3294 of file PathOpsOpTest.cpp.

3294 {
3295 SkPath path, pathB;
3296 path.moveTo(2,4);
3297 path.cubicTo(3,5, 2.33333325f,4.33333349f, 3.83333325f,3.83333349f);
3298 path.close();
3299 pathB.moveTo(3,5);
3300 pathB.cubicTo(2.33333325f,4.33333349f, 3.83333325f,3.83333349f, 2,4);
3301 pathB.close();
3302 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3303}

◆ cubicOp114()

static void cubicOp114 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3305 of file PathOpsOpTest.cpp.

3305 {
3306 SkPath path, pathB;
3307 path.setFillType(SkPathFillType::kWinding);
3308 path.moveTo(0, 1);
3309 path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
3310 path.close();
3311 pathB.setFillType(SkPathFillType::kWinding);
3312 pathB.moveTo(1, 3);
3313 pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1);
3314 pathB.close();
3315 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3316}

◆ cubicOp114asQuad()

static void cubicOp114asQuad ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3318 of file PathOpsOpTest.cpp.

3318 {
3319 SkPath path, pathB;
3320 path.setFillType(SkPathFillType::kWinding);
3321 path.moveTo(0, 1);
3322 path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
3323 path.close();
3324 pathB.setFillType(SkPathFillType::kWinding);
3325 pathB.moveTo(1, 3);
3326 pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1);
3327 pathB.close();
3328 SkPath qPath, qPathB;
3329 CubicPathToQuads(path, &qPath);
3330 CubicPathToQuads(pathB, &qPathB);
3331 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename);
3332}
CubicPathToQuads
void CubicPathToQuads(const SkPath &cubicPath, SkPath *quadPath)
Definition PathOpsTestCommon.cpp:178

◆ cubicOp115()

static void cubicOp115 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3528 of file PathOpsOpTest.cpp.

3528 {
3529 SkPath path, pathB;
3530 path.setFillType(SkPathFillType::kWinding);
3531 path.moveTo(0,1);
3532 path.cubicTo(3,4, 2,1, 5,3);
3533 path.close();
3534 pathB.setFillType(SkPathFillType::kWinding);
3535 pathB.moveTo(1,2);
3536 pathB.cubicTo(3,5, 1,0, 4,3);
3537 pathB.close();
3538 SkPath path2(path);
3539 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3540}

◆ cubicOp116()

static void cubicOp116 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3562 of file PathOpsOpTest.cpp.

3562 {
3563 SkPath path, pathB;
3564 path.setFillType(SkPathFillType::kWinding);
3565 path.moveTo(0,1);
3566 path.cubicTo(4,6, 2,0, 2,0);
3567 path.close();
3568 pathB.setFillType(SkPathFillType::kWinding);
3569 pathB.moveTo(0,2);
3570 pathB.cubicTo(0,2, 1,0, 6,4);
3571 pathB.close();
3572 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3573}

◆ cubicOp117()

static void cubicOp117 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3575 of file PathOpsOpTest.cpp.

3575 {
3576 SkPath path, pathB;
3577 path.setFillType(SkPathFillType::kWinding);
3578 path.moveTo(0,1);
3579 path.cubicTo(4,5, 6,0, 1,0);
3580 path.close();
3581 pathB.setFillType(SkPathFillType::kWinding);
3582 pathB.moveTo(0,6);
3583 pathB.cubicTo(0,1, 1,0, 5,4);
3584 pathB.close();
3585 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3586}

◆ cubicOp118()

static void cubicOp118 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3588 of file PathOpsOpTest.cpp.

3588 {
3589 SkPath path, pathB;
3590 path.setFillType(SkPathFillType::kWinding);
3591 path.moveTo(0,1);
3592 path.cubicTo(4,6, 5,1, 6,2);
3593 path.close();
3594 pathB.setFillType(SkPathFillType::kWinding);
3595 pathB.moveTo(1,5);
3596 pathB.cubicTo(2,6, 1,0, 6,4);
3597 pathB.close();
3598 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3599}

◆ cubicOp119()

static void cubicOp119 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3687 of file PathOpsOpTest.cpp.

3687 {
3688 SkPath path, pathB;
3689 path.setFillType(SkPathFillType::kWinding);
3690 path.moveTo(0,1);
3691 path.cubicTo(3,5, 2,1, 3,1);
3692 path.close();
3693 pathB.setFillType(SkPathFillType::kWinding);
3694 pathB.moveTo(1,2);
3695 pathB.cubicTo(1,3, 1,0, 5,3);
3696 pathB.close();
3697 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3698}

◆ cubicOp11d()

static void cubicOp11d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 216 of file PathOpsOpTest.cpp.

216 {
217 SkPath path, pathB;
218 path.setFillType(SkPathFillType::kWinding);
219 path.moveTo(0,1);
220 path.cubicTo(3,4, 1,0, 5,1);
221 path.close();
222 pathB.setFillType(SkPathFillType::kWinding);
223 pathB.moveTo(0,1);
224 pathB.cubicTo(1,5, 1,0, 4,3);
225 pathB.close();
226 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
227}

◆ cubicOp120()

static void cubicOp120 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3700 of file PathOpsOpTest.cpp.

3700 {
3701 SkPath path, pathB;
3702 path.setFillType(SkPathFillType::kWinding);
3703 path.moveTo(0,1);
3704 path.cubicTo(2,4, 2,1, 4,0);
3705 path.close();
3706 pathB.setFillType(SkPathFillType::kWinding);
3707 pathB.moveTo(1,2);
3708 pathB.cubicTo(0,4, 1,0, 4,2);
3709 pathB.close();
3710 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3711}

◆ cubicOp121()

static void cubicOp121 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3713 of file PathOpsOpTest.cpp.

3713 {
3714 SkPath path, pathB;
3715 path.setFillType(SkPathFillType::kWinding);
3716 path.moveTo(0,1);
3717 path.cubicTo(3,4, 3,2, 4,3);
3718 path.close();
3719 pathB.setFillType(SkPathFillType::kWinding);
3720 pathB.moveTo(2,3);
3721 pathB.cubicTo(3,4, 1,0, 4,3);
3722 pathB.close();
3723 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3724}

◆ cubicOp122()

static void cubicOp122 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3727 of file PathOpsOpTest.cpp.

3727 {
3728 SkPath path, pathB;
3729 path.setFillType(SkPathFillType::kWinding);
3730 path.moveTo(0,1);
3731 path.cubicTo(3,5, 4,1, 4,0);
3732 path.close();
3733 pathB.setFillType(SkPathFillType::kWinding);
3734 pathB.moveTo(1,4);
3735 pathB.cubicTo(0,4, 1,0, 5,3);
3736 pathB.close();
3737 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3738}

◆ cubicOp123()

static void cubicOp123 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3740 of file PathOpsOpTest.cpp.

3740 {
3741 SkPath path, pathB;
3742 path.setFillType(SkPathFillType::kWinding);
3743 path.moveTo(0,1);
3744 path.cubicTo(1,5, 2,0, 6,0);
3745 path.close();
3746 pathB.setFillType(SkPathFillType::kWinding);
3747 pathB.moveTo(0,2);
3748 pathB.cubicTo(0,6, 1,0, 5,1);
3749 pathB.close();
3750 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3751}

◆ cubicOp124()

static void cubicOp124 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3775 of file PathOpsOpTest.cpp.

3775 {
3776 SkPath path, pathB;
3777 path.setFillType(SkPathFillType::kWinding);
3778 path.moveTo(0,1);
3779 path.cubicTo(1,5, 6,0, 3,0);
3780 path.close();
3781 pathB.setFillType(SkPathFillType::kWinding);
3782 pathB.moveTo(0,6);
3783 pathB.cubicTo(0,3, 1,0, 5,1);
3784 pathB.close();
3785 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3786}

◆ cubicOp125()

static void cubicOp125 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3788 of file PathOpsOpTest.cpp.

3788 {
3789 SkPath path, pathB;
3790 path.setFillType(SkPathFillType::kWinding);
3791 path.moveTo(0,1);
3792 path.cubicTo(3,6, 3,1, 6,2);
3793 path.close();
3794 pathB.setFillType(SkPathFillType::kWinding);
3795 pathB.moveTo(1,3);
3796 pathB.cubicTo(2,6, 1,0, 6,3);
3797 pathB.close();
3798 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3799}

◆ cubicOp126()

static void cubicOp126 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3801 of file PathOpsOpTest.cpp.

3801 {
3802 SkPath path, pathB;
3803 path.setFillType(SkPathFillType::kWinding);
3804 path.moveTo(0,1);
3805 path.cubicTo(0,3, 6,0, 2,1);
3806 path.close();
3807 pathB.setFillType(SkPathFillType::kWinding);
3808 pathB.moveTo(0,6);
3809 pathB.cubicTo(1,2, 1,0, 3,0);
3810 pathB.close();
3811 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3812}

◆ cubicOp127()

static void cubicOp127 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3814 of file PathOpsOpTest.cpp.

3814 {
3815 SkPath path, pathB;
3816 path.setFillType(SkPathFillType::kWinding);
3817 path.moveTo(0,1);
3818 path.cubicTo(1,5, 6,0, 3,0);
3819 path.close();
3820 pathB.setFillType(SkPathFillType::kWinding);
3821 pathB.moveTo(0,6);
3822 pathB.cubicTo(0,3, 1,0, 5,1);
3823 pathB.close();
3824 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3825}

◆ cubicOp128()

static void cubicOp128 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3827 of file PathOpsOpTest.cpp.

3827 {
3828 SkPath path, pathB;
3829 path.setFillType(SkPathFillType::kWinding);
3830 path.moveTo(0,1);
3831 path.cubicTo(0,3, 3,2, 5,2);
3832 path.close();
3833 pathB.setFillType(SkPathFillType::kWinding);
3834 pathB.moveTo(2,3);
3835 pathB.cubicTo(2,5, 1,0, 3,0);
3836 pathB.close();
3837 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3838}

◆ cubicOp129()

static void cubicOp129 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3840 of file PathOpsOpTest.cpp.

3840 {
3841 SkPath path, pathB;
3842 path.setFillType(SkPathFillType::kWinding);
3843 path.moveTo(5,6);
3844 path.cubicTo(3,4, 2,0, 2,1);
3845 path.close();
3846 pathB.setFillType(SkPathFillType::kWinding);
3847 pathB.moveTo(0,2);
3848 pathB.cubicTo(1,2, 6,5, 4,3);
3849 pathB.close();
3850 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3851}

◆ cubicOp12d()

static void cubicOp12d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 229 of file PathOpsOpTest.cpp.

229 {
230 SkPath path, pathB;
231 path.setFillType(SkPathFillType::kWinding);
232 path.moveTo(0,1);
233 path.cubicTo(1,6, 1,0, 1,0);
234 path.close();
235 pathB.setFillType(SkPathFillType::kWinding);
236 pathB.moveTo(0,1);
237 pathB.cubicTo(0,1, 1,0, 6,1);
238 pathB.close();
239 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
240}

◆ cubicOp130()

static void cubicOp130 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3853 of file PathOpsOpTest.cpp.

3853 {
3854 SkPath path, pathB;
3855 path.setFillType(SkPathFillType::kWinding);
3856 path.moveTo(5,6);
3857 path.cubicTo(4,6, 3,0, 2,1);
3858 path.close();
3859 pathB.setFillType(SkPathFillType::kWinding);
3860 pathB.moveTo(0,3);
3861 pathB.cubicTo(1,2, 6,5, 6,4);
3862 pathB.close();
3863 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3864}

◆ cubicOp130a()

static void cubicOp130a ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3883 of file PathOpsOpTest.cpp.

3883 {
3884 SkPath path, pathB;
3885 path.setFillType(SkPathFillType::kWinding);
3886 path.moveTo(5,6);
3887 SkPoint pts[] = { {5,6}, {4,6}, {3,0}, {2,1} };
3888 complex_to_quads(pts, &path);
3889 path.close();
3890 pathB.setFillType(SkPathFillType::kWinding);
3891 pathB.moveTo(0,3);
3892 SkPoint pts2[] = { {0,3}, {1,2}, {6,5}, {6,4} };
3893 complex_to_quads(pts2, &path);
3894 pathB.close();
3895 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3896}
complex_to_quads
static void complex_to_quads(const SkPoint pts[], SkPath *path)
Definition PathOpsOpTest.cpp:3866

◆ cubicOp131()

static void cubicOp131 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3898 of file PathOpsOpTest.cpp.

3898 {
3899 SkPath path, pathB;
3900 path.setFillType(SkPathFillType::kWinding);
3901 path.moveTo(0,1);
3902 path.cubicTo(3,4, 3,0, 6,2);
3903 path.close();
3904 pathB.setFillType(SkPathFillType::kWinding);
3905 pathB.moveTo(0,3);
3906 pathB.cubicTo(2,6, 1,0, 4,3);
3907 pathB.close();
3908 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3909}

◆ cubicOp132()

static void cubicOp132 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4048 of file PathOpsOpTest.cpp.

4048 {
4049 SkPath path, pathB;
4050 path.setFillType(SkPathFillType::kWinding);
4051 path.moveTo(5,6);
4052 path.cubicTo(3,4, 3,0, 3,2);
4053 path.close();
4054 pathB.setFillType(SkPathFillType::kWinding);
4055 pathB.moveTo(0,3);
4056 pathB.cubicTo(2,3, 6,5, 4,3);
4057 pathB.close();
4058 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4059}

◆ cubicOp133()

static void cubicOp133 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4072 of file PathOpsOpTest.cpp.

4072 {
4073 SkPath path, pathB;
4074 path.setFillType(SkPathFillType::kWinding);
4075 path.moveTo(5,6);
4076 path.cubicTo(5,6, 5,0, 4,1);
4077 path.close();
4078 pathB.setFillType(SkPathFillType::kWinding);
4079 pathB.moveTo(0,5);
4080 pathB.cubicTo(1,4, 6,5, 6,5);
4081 pathB.close();
4082 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4083}

◆ cubicOp134()

static void cubicOp134 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4085 of file PathOpsOpTest.cpp.

4085 {
4086 SkPath path, pathB;
4087 path.setFillType(SkPathFillType::kWinding);
4088 path.moveTo(5,6);
4089 path.cubicTo(5,6, 6,0, 3,1);
4090 path.close();
4091 pathB.setFillType(SkPathFillType::kWinding);
4092 pathB.moveTo(0,6);
4093 pathB.cubicTo(1,3, 6,5, 6,5);
4094 pathB.close();
4095 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4096}

◆ cubicOp135()

static void cubicOp135 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4098 of file PathOpsOpTest.cpp.

4098 {
4099 SkPath path, pathB;
4100 path.setFillType(SkPathFillType::kWinding);
4101 path.moveTo(5,6);
4102 path.cubicTo(5,6, 6,0, 4,1);
4103 path.close();
4104 pathB.setFillType(SkPathFillType::kWinding);
4105 pathB.moveTo(0,6);
4106 pathB.cubicTo(1,4, 6,5, 6,5);
4107 pathB.close();
4108 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4109}

◆ cubicOp136()

static void cubicOp136 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4111 of file PathOpsOpTest.cpp.

4111 {
4112 SkPath path, pathB;
4113 path.setFillType(SkPathFillType::kWinding);
4114 path.moveTo(5,6);
4115 path.cubicTo(5,6, 5,0, 3,1);
4116 path.close();
4117 pathB.setFillType(SkPathFillType::kWinding);
4118 pathB.moveTo(0,5);
4119 pathB.cubicTo(1,3, 6,5, 6,5);
4120 pathB.close();
4121 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4122}

◆ cubicOp136a()

static void cubicOp136a ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4124 of file PathOpsOpTest.cpp.

4124 {
4125 SkPath path, pathB;
4126 path.setFillType(SkPathFillType::kWinding);
4127 path.moveTo(5,6);
4128 path.quadTo(5,0, 3,1);
4129 path.close();
4130 pathB.setFillType(SkPathFillType::kWinding);
4131 pathB.moveTo(0,5);
4132 pathB.cubicTo(1,3, 6,5, 6,5);
4133 pathB.close();
4134 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4135}

◆ cubicOp139()

static void cubicOp139 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4164 of file PathOpsOpTest.cpp.

4164 {
4165 SkPath path, pathB;
4166 path.setFillType(SkPathFillType::kWinding);
4167 path.moveTo(0,2);
4168 path.cubicTo(0,4, 3,1, 5,1);
4169 path.close();
4170 pathB.setFillType(SkPathFillType::kWinding);
4171 pathB.moveTo(1,3);
4172 pathB.cubicTo(1,5, 2,0, 4,0);
4173 pathB.close();
4174 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4175}

◆ cubicOp13d()

static void cubicOp13d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 242 of file PathOpsOpTest.cpp.

242 {
243 SkPath path, pathB;
244 path.setFillType(SkPathFillType::kWinding);
245 path.moveTo(0,1);
246 path.cubicTo(4,5, 1,0, 5,3);
247 path.close();
248 pathB.setFillType(SkPathFillType::kWinding);
249 pathB.moveTo(0,1);
250 pathB.cubicTo(3,5, 1,0, 5,4);
251 pathB.close();
252 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
253}

◆ cubicOp140()

static void cubicOp140 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4177 of file PathOpsOpTest.cpp.

4177 {
4178 SkPath path, pathB;
4179 path.setFillType(SkPathFillType::kWinding);
4180 path.moveTo(0,2);
4181 path.cubicTo(1,2, 5,4, 3,2);
4182 path.close();
4183 pathB.setFillType(SkPathFillType::kWinding);
4184 pathB.moveTo(4,5);
4185 pathB.cubicTo(2,3, 2,0, 2,1);
4186 pathB.close();
4187 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4188}

◆ cubicOp141()

static void cubicOp141 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4190 of file PathOpsOpTest.cpp.

4190 {
4191 SkPath path, pathB;
4192 path.setFillType(SkPathFillType::kWinding);
4193 path.moveTo(0,2);
4194 path.cubicTo(1,2, 6,4, 3,2);
4195 path.close();
4196 pathB.setFillType(SkPathFillType::kWinding);
4197 pathB.moveTo(4,6);
4198 pathB.cubicTo(2,3, 2,0, 2,1);
4199 pathB.close();
4200 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4201}

◆ cubicOp142()

static void cubicOp142 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4289 of file PathOpsOpTest.cpp.

4289 {
4290 SkPath path, pathB;
4291 path.setFillType(SkPathFillType::kWinding);
4292 path.moveTo(5,6);
4293 path.cubicTo(2,5, 2,1, 1,0);
4294 path.close();
4295 pathB.setFillType(SkPathFillType::kWinding);
4296 pathB.moveTo(1,2);
4297 pathB.cubicTo(0,1, 6,5, 5,2);
4298 pathB.close();
4299 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4300}

◆ cubicOp14d()

static void cubicOp14d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 255 of file PathOpsOpTest.cpp.

255 {
256 SkPath path, pathB;
257 path.setFillType(SkPathFillType::kWinding);
258 path.moveTo(0,1);
259 path.cubicTo(0,2, 2,0, 2,1);
260 path.close();
261 pathB.setFillType(SkPathFillType::kWinding);
262 pathB.moveTo(0,2);
263 pathB.cubicTo(1,2, 1,0, 2,0);
264 pathB.close();
265 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
266}

◆ cubicOp157()

static void cubicOp157 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4484 of file PathOpsOpTest.cpp.

4484 {
4485 SkPath path, pathB;
4486 path.setFillType(SkPathFillType::kWinding);
4487 path.moveTo(1,5);
4488 path.cubicTo(1,3, 6,2, 4,2);
4489 path.close();
4490 pathB.setFillType(SkPathFillType::kWinding);
4491 pathB.moveTo(2,6);
4492 pathB.cubicTo(2,4, 5,1, 3,1);
4493 pathB.close();
4494 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4495}

◆ cubicOp158()

static void cubicOp158 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5388 of file PathOpsOpTest.cpp.

5388 {
5389 SkPath path, pathB;
5390 path.setFillType(SkPathFillType::kWinding);
5391 path.moveTo(0,1);
5392 path.cubicTo(2,4, 2,0, 2,0);
5393 path.close();
5394 pathB.setFillType(SkPathFillType::kWinding);
5395 pathB.moveTo(0,2);
5396 pathB.cubicTo(0,2, 1,0, 4,2);
5397 pathB.close();
5398 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5399}

◆ cubicOp15d()

static void cubicOp15d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 268 of file PathOpsOpTest.cpp.

268 {
269 SkPath path, pathB;
270 path.setFillType(SkPathFillType::kWinding);
271 path.moveTo(0,1);
272 path.cubicTo(3,6, 2,0, 2,1);
273 path.close();
274 pathB.setFillType(SkPathFillType::kWinding);
275 pathB.moveTo(0,2);
276 pathB.cubicTo(1,2, 1,0, 6,3);
277 pathB.close();
278 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
279}

◆ cubicOp16d()

static void cubicOp16d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 281 of file PathOpsOpTest.cpp.

281 {
282 SkPath path, pathB;
283 path.setFillType(SkPathFillType::kWinding);
284 path.moveTo(0,2);
285 path.cubicTo(0,1, 3,0, 1,0);
286 path.close();
287 pathB.setFillType(SkPathFillType::kWinding);
288 pathB.moveTo(0,3);
289 pathB.cubicTo(0,1, 2,0, 1,0);
290 pathB.close();
291 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
292}

◆ cubicOp17d()

static void cubicOp17d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 294 of file PathOpsOpTest.cpp.

294 {
295 SkPath path, pathB;
296 path.setFillType(SkPathFillType::kWinding);
297 path.moveTo(0,2);
298 path.cubicTo(0,2, 4,0, 2,1);
299 path.close();
300 pathB.setFillType(SkPathFillType::kWinding);
301 pathB.moveTo(0,4);
302 pathB.cubicTo(1,2, 2,0, 2,0);
303 pathB.close();
304 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
305}

◆ cubicOp18d()

static void cubicOp18d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 307 of file PathOpsOpTest.cpp.

307 {
308 SkPath path, pathB;
309 path.setFillType(SkPathFillType::kWinding);
310 path.moveTo(0,1);
311 path.cubicTo(3,5, 2,0, 2,1);
312 path.close();
313 pathB.setFillType(SkPathFillType::kWinding);
314 pathB.moveTo(0,2);
315 pathB.cubicTo(1,2, 1,0, 5,3);
316 pathB.close();
317 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
318}

◆ cubicOp19i()

static void cubicOp19i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 320 of file PathOpsOpTest.cpp.

320 {
321 SkPath path, pathB;
322 path.setFillType(SkPathFillType::kWinding);
323 path.moveTo(0,2);
324 path.cubicTo(0,1, 2,1, 6,2);
325 path.close();
326 pathB.setFillType(SkPathFillType::kWinding);
327 pathB.moveTo(1,2);
328 pathB.cubicTo(2,6, 2,0, 1,0);
329 pathB.close();
330 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
331}

◆ cubicOp1d()

static void cubicOp1d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 52 of file PathOpsOpTest.cpp.

52 {
53 SkPath path, pathB;
54 path.setFillType(SkPathFillType::kWinding);
55 path.moveTo(0,1);
56 path.cubicTo(0,2, 1,0, 1,0);
57 path.close();
58 pathB.setFillType(SkPathFillType::kWinding);
59 pathB.moveTo(0,1);
60 pathB.cubicTo(0,1, 1,0, 2,0);
61 pathB.close();
62 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
63}

◆ cubicOp1i()

static void cubicOp1i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 190 of file PathOpsOpTest.cpp.

190 {
191 SkPath path, pathB;
192 path.setFillType(SkPathFillType::kWinding);
193 path.moveTo(0,1);
194 path.cubicTo(1,2, 1,0, 2,1);
195 path.close();
196 pathB.setFillType(SkPathFillType::kWinding);
197 pathB.moveTo(0,1);
198 pathB.cubicTo(1,2, 1,0, 2,1);
199 pathB.close();
200 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
201}

◆ cubicOp20d()

static void cubicOp20d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 333 of file PathOpsOpTest.cpp.

333 {
334 SkPath path, pathB;
335 path.setFillType(SkPathFillType::kWinding);
336 path.moveTo(0,1);
337 path.cubicTo(0,1, 6,0, 2,1);
338 path.close();
339 pathB.setFillType(SkPathFillType::kWinding);
340 pathB.moveTo(0,6);
341 pathB.cubicTo(1,2, 1,0, 1,0);
342 pathB.close();
343 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
344}

◆ cubicOp21d()

static void cubicOp21d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 346 of file PathOpsOpTest.cpp.

346 {
347 SkPath path, pathB;
348 path.setFillType(SkPathFillType::kWinding);
349 path.moveTo(0,1);
350 path.cubicTo(0,1, 2,1, 6,5);
351 path.close();
352 pathB.setFillType(SkPathFillType::kWinding);
353 pathB.moveTo(1,2);
354 pathB.cubicTo(5,6, 1,0, 1,0);
355 pathB.close();
356 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
357}

◆ cubicOp22d()

static void cubicOp22d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 359 of file PathOpsOpTest.cpp.

359 {
360 SkPath path, pathB;
361 path.setFillType(SkPathFillType::kWinding);
362 path.moveTo(0,1);
363 path.cubicTo(2,3, 3,0, 2,1);
364 path.close();
365 pathB.setFillType(SkPathFillType::kWinding);
366 pathB.moveTo(0,3);
367 pathB.cubicTo(1,2, 1,0, 3,2);
368 pathB.close();
369 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
370}

◆ cubicOp23d()

static void cubicOp23d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 372 of file PathOpsOpTest.cpp.

372 {
373 SkPath path, pathB;
374 path.setFillType(SkPathFillType::kWinding);
375 path.moveTo(0,1);
376 path.cubicTo(1,2, 4,0, 2,1);
377 path.close();
378 pathB.setFillType(SkPathFillType::kWinding);
379 pathB.moveTo(0,4);
380 pathB.cubicTo(1,2, 1,0, 2,1);
381 pathB.close();
382 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
383}

◆ cubicOp24d()

static void cubicOp24d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 385 of file PathOpsOpTest.cpp.

385 {
386 SkPath path, pathB;
387 path.setFillType(SkPathFillType::kWinding);
388 path.moveTo(0,1);
389 path.cubicTo(1,2, 2,0, 3,2);
390 path.close();
391 pathB.setFillType(SkPathFillType::kWinding);
392 pathB.moveTo(0,2);
393 pathB.cubicTo(2,3, 1,0, 2,1);
394 pathB.close();
395 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
396}

◆ cubicOp25i()

static void cubicOp25i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 561 of file PathOpsOpTest.cpp.

561 {
562 SkPath path, pathB;
563 path.setFillType(SkPathFillType::kWinding);
564 path.moveTo(0,1);
565 path.cubicTo(2,4, 5,0, 3,2);
566 path.close();
567 pathB.setFillType(SkPathFillType::kWinding);
568 pathB.moveTo(0,5);
569 pathB.cubicTo(2,3, 1,0, 4,2);
570 pathB.close();
571 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
572}

◆ cubicOp26d()

static void cubicOp26d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 574 of file PathOpsOpTest.cpp.

574 {
575 SkPath path, pathB;
576 path.setFillType(SkPathFillType::kWinding);
577 path.moveTo(0,1);
578 path.cubicTo(3,4, 4,0, 3,2);
579 path.close();
580 pathB.setFillType(SkPathFillType::kWinding);
581 pathB.moveTo(0,4);
582 pathB.cubicTo(2,3, 1,0, 4,3);
583 pathB.close();
584 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
585}

◆ cubicOp27d()

static void cubicOp27d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 587 of file PathOpsOpTest.cpp.

587 {
588 SkPath path, pathB;
589 path.setFillType(SkPathFillType::kWinding);
590 path.moveTo(0,1);
591 path.cubicTo(3,6, 1,0, 5,2);
592 path.close();
593 pathB.setFillType(SkPathFillType::kWinding);
594 pathB.moveTo(0,1);
595 pathB.cubicTo(2,5, 1,0, 6,3);
596 pathB.close();
597 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
598}

◆ cubicOp28u()

static void cubicOp28u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 600 of file PathOpsOpTest.cpp.

600 {
601 SkPath path, pathB;
602 path.setFillType(SkPathFillType::kWinding);
603 path.moveTo(0,1);
604 path.cubicTo(1,4, 6,0, 3,2);
605 path.close();
606 pathB.setFillType(SkPathFillType::kWinding);
607 pathB.moveTo(0,6);
608 pathB.cubicTo(2,3, 1,0, 4,1);
609 pathB.close();
610 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
611}

◆ cubicOp29d()

static void cubicOp29d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 613 of file PathOpsOpTest.cpp.

613 {
614 SkPath path, pathB;
615 path.setFillType(SkPathFillType::kWinding);
616 path.moveTo(0,1);
617 path.cubicTo(2,5, 6,0, 4,2);
618 path.close();
619 pathB.setFillType(SkPathFillType::kWinding);
620 pathB.moveTo(0,6);
621 pathB.cubicTo(2,4, 1,0, 5,2);
622 pathB.close();
623 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
624}

◆ cubicOp2d()

static void cubicOp2d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 65 of file PathOpsOpTest.cpp.

65 {
66 SkPath path, pathB;
67 path.setFillType(SkPathFillType::kWinding);
68 path.moveTo(0,2);
69 path.cubicTo(0,1, 1,0, 1,0);
70 path.close();
71 pathB.setFillType(SkPathFillType::kWinding);
72 pathB.moveTo(0,1);
73 pathB.cubicTo(0,1, 2,0, 1,0);
74 pathB.close();
75 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
76}

◆ cubicOp30d()

static void cubicOp30d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 626 of file PathOpsOpTest.cpp.

626 {
627 SkPath path, pathB;
628 path.setFillType(SkPathFillType::kWinding);
629 path.moveTo(0,1);
630 path.cubicTo(2,5, 6,0, 5,3);
631 path.close();
632 pathB.setFillType(SkPathFillType::kWinding);
633 pathB.moveTo(0,6);
634 pathB.cubicTo(3,5, 1,0, 5,2);
635 pathB.close();
636 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
637}

◆ cubicOp31d()

static void cubicOp31d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 639 of file PathOpsOpTest.cpp.

639 {
640 SkPath path, pathB;
641 path.setFillType(SkPathFillType::kWinding);
642 path.moveTo(0,2);
643 path.cubicTo(0,3, 2,1, 4,0);
644 path.close();
645 pathB.setFillType(SkPathFillType::kWinding);
646 pathB.moveTo(1,2);
647 pathB.cubicTo(0,4, 2,0, 3,0);
648 pathB.close();
649 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
650}

◆ cubicOp31u()

static void cubicOp31u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 652 of file PathOpsOpTest.cpp.

652 {
653 SkPath path, pathB;
654 path.setFillType(SkPathFillType::kWinding);
655 path.moveTo(0,2);
656 path.cubicTo(0,3, 2,1, 4,0);
657 path.close();
658 pathB.setFillType(SkPathFillType::kWinding);
659 pathB.moveTo(1,2);
660 pathB.cubicTo(0,4, 2,0, 3,0);
661 pathB.close();
662 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
663}

◆ cubicOp31x()

static void cubicOp31x ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 665 of file PathOpsOpTest.cpp.

665 {
666 SkPath path, pathB;
667 path.setFillType(SkPathFillType::kWinding);
668 path.moveTo(0,2);
669 path.cubicTo(0,3, 2,1, 4,0);
670 path.close();
671 pathB.setFillType(SkPathFillType::kWinding);
672 pathB.moveTo(1,2);
673 pathB.cubicTo(0,4, 2,0, 3,0);
674 pathB.close();
675 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
676}
kXOR_SkPathOp
@ kXOR_SkPathOp
exclusive-or the two paths
Definition SkPathOps.h:26

◆ cubicOp32d()

static void cubicOp32d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 678 of file PathOpsOpTest.cpp.

678 {
679 SkPath path, pathB;
680 path.setFillType(SkPathFillType::kWinding);
681 path.moveTo(0,1);
682 path.cubicTo(1,2, 6,0, 3,1);
683 path.close();
684 pathB.setFillType(SkPathFillType::kWinding);
685 pathB.moveTo(0,6);
686 pathB.cubicTo(1,3, 1,0, 2,1);
687 pathB.close();
688 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
689}

◆ cubicOp33i()

static void cubicOp33i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 691 of file PathOpsOpTest.cpp.

691 {
692 SkPath path, pathB;
693 path.setFillType(SkPathFillType::kWinding);
694 path.moveTo(0,1);
695 path.cubicTo(1,2, 6,0, 3,1);
696 path.close();
697 pathB.setFillType(SkPathFillType::kWinding);
698 pathB.moveTo(0,6);
699 pathB.cubicTo(1,3, 1,0, 2,1);
700 pathB.close();
701 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
702}

◆ cubicOp34d()

static void cubicOp34d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 704 of file PathOpsOpTest.cpp.

704 {
705 SkPath path, pathB;
706 path.setFillType(SkPathFillType::kWinding);
707 path.moveTo(0,1);
708 path.cubicTo(3,5, 2,1, 3,1);
709 path.close();
710 pathB.setFillType(SkPathFillType::kWinding);
711 pathB.moveTo(1,2);
712 pathB.cubicTo(1,3, 1,0, 5,3);
713 pathB.close();
714 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
715}

◆ cubicOp35d()

static void cubicOp35d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 717 of file PathOpsOpTest.cpp.

717 {
718 SkPath path, pathB;
719 path.setFillType(SkPathFillType::kWinding);
720 path.moveTo(0,1);
721 path.cubicTo(1,5, 2,1, 4,0);
722 path.close();
723 pathB.setFillType(SkPathFillType::kWinding);
724 pathB.moveTo(1,2);
725 pathB.cubicTo(0,4, 1,0, 5,1);
726 pathB.close();
727 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
728}

◆ cubicOp36u()

static void cubicOp36u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 730 of file PathOpsOpTest.cpp.

730 {
731 SkPath path, pathB;
732 path.setFillType(SkPathFillType::kWinding);
733 path.moveTo(0,1);
734 path.cubicTo(1,6, 2,0, 5,1);
735 path.close();
736 pathB.setFillType(SkPathFillType::kWinding);
737 pathB.moveTo(0,2);
738 pathB.cubicTo(1,5, 1,0, 6,1);
739 pathB.close();
740 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
741}

◆ cubicOp37d()

static void cubicOp37d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 743 of file PathOpsOpTest.cpp.

743 {
744 SkPath path, pathB;
745 path.setFillType(SkPathFillType::kWinding);
746 path.moveTo(0,1);
747 path.cubicTo(2,6, 6,1, 4,3);
748 path.close();
749 pathB.setFillType(SkPathFillType::kWinding);
750 pathB.moveTo(1,6);
751 pathB.cubicTo(3,4, 1,0, 6,2);
752 pathB.close();
753 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
754}

◆ cubicOp38d()

static void cubicOp38d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 756 of file PathOpsOpTest.cpp.

756 {
757 SkPath path, pathB;
758 path.setFillType(SkPathFillType::kWinding);
759 path.moveTo(0,1);
760 path.cubicTo(0,6, 3,2, 4,1);
761 path.close();
762 pathB.setFillType(SkPathFillType::kWinding);
763 pathB.moveTo(2,3);
764 pathB.cubicTo(1,4, 1,0, 6,0);
765 pathB.close();
766 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
767}

◆ cubicOp39d()

static void cubicOp39d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 769 of file PathOpsOpTest.cpp.

769 {
770 SkPath path, pathB;
771 path.setFillType(SkPathFillType::kWinding);
772 path.moveTo(0,1);
773 path.cubicTo(2,3, 5,1, 4,3);
774 path.close();
775 pathB.setFillType(SkPathFillType::kWinding);
776 pathB.moveTo(1,5);
777 pathB.cubicTo(3,4, 1,0, 3,2);
778 pathB.close();
779 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
780}

◆ cubicOp3d()

static void cubicOp3d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 78 of file PathOpsOpTest.cpp.

78 {
79 SkPath path, pathB;
80 path.setFillType(SkPathFillType::kWinding);
81 path.moveTo(0,1);
82 path.cubicTo(2,3, 1,0, 1,0);
83 path.close();
84 pathB.setFillType(SkPathFillType::kWinding);
85 pathB.moveTo(0,1);
86 pathB.cubicTo(0,1, 1,0, 3,2);
87 pathB.close();
88 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
89}

◆ cubicOp40d()

static void cubicOp40d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 782 of file PathOpsOpTest.cpp.

782 {
783 SkPath path, pathB;
784 path.setFillType(SkPathFillType::kWinding);
785 path.moveTo(0,1);
786 path.cubicTo(1,5, 3,2, 4,2);
787 path.close();
788 pathB.setFillType(SkPathFillType::kWinding);
789 pathB.moveTo(2,3);
790 pathB.cubicTo(2,4, 1,0, 5,1);
791 pathB.close();
792 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
793}

◆ cubicOp41i()

static void cubicOp41i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 795 of file PathOpsOpTest.cpp.

795 {
796 SkPath path, pathB;
797 path.setFillType(SkPathFillType::kWinding);
798 path.moveTo(0,1);
799 path.cubicTo(2,6, 4,3, 6,4);
800 path.close();
801 pathB.setFillType(SkPathFillType::kWinding);
802 pathB.moveTo(3,4);
803 pathB.cubicTo(4,6, 1,0, 6,2);
804 pathB.close();
805 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
806}

◆ cubicOp42d()

static void cubicOp42d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 808 of file PathOpsOpTest.cpp.

808 {
809 SkPath path, pathB;
810 path.setFillType(SkPathFillType::kWinding);
811 path.moveTo(0,1);
812 path.cubicTo(1,2, 6,5, 5,4);
813 path.close();
814 pathB.setFillType(SkPathFillType::kWinding);
815 pathB.moveTo(5,6);
816 pathB.cubicTo(4,5, 1,0, 2,1);
817 pathB.close();
818 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
819}

◆ cubicOp43d()

static void cubicOp43d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 821 of file PathOpsOpTest.cpp.

821 {
822 SkPath path, pathB;
823 path.setFillType(SkPathFillType::kWinding);
824 path.moveTo(0,2);
825 path.cubicTo(1,2, 4,0, 3,1);
826 path.close();
827 pathB.setFillType(SkPathFillType::kWinding);
828 pathB.moveTo(0,4);
829 pathB.cubicTo(1,3, 2,0, 2,1);
830 pathB.close();
831 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
832}

◆ cubicOp44d()

static void cubicOp44d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 834 of file PathOpsOpTest.cpp.

834 {
835 SkPath path, pathB;
836 path.setFillType(SkPathFillType::kWinding);
837 path.moveTo(0,2);
838 path.cubicTo(3,6, 4,0, 3,2);
839 path.close();
840 pathB.setFillType(SkPathFillType::kWinding);
841 pathB.moveTo(0,4);
842 pathB.cubicTo(2,3, 2,0, 6,3);
843 pathB.close();
844 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
845}

◆ cubicOp45d()

static void cubicOp45d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 847 of file PathOpsOpTest.cpp.

847 {
848 SkPath path, pathB;
849 path.setFillType(SkPathFillType::kWinding);
850 path.moveTo(0,2);
851 path.cubicTo(2,4, 4,0, 3,2);
852 path.close();
853 pathB.setFillType(SkPathFillType::kWinding);
854 pathB.moveTo(0,4);
855 pathB.cubicTo(2,3, 2,0, 4,2);
856 pathB.close();
857 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
858}

◆ cubicOp46d()

static void cubicOp46d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 860 of file PathOpsOpTest.cpp.

860 {
861 SkPath path, pathB;
862 path.setFillType(SkPathFillType::kWinding);
863 path.moveTo(0,2);
864 path.cubicTo(3,5, 5,0, 4,2);
865 path.close();
866 pathB.setFillType(SkPathFillType::kWinding);
867 pathB.moveTo(0,5);
868 pathB.cubicTo(2,4, 2,0, 5,3);
869 pathB.close();
870 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
871}

◆ cubicOp47d()

static void cubicOp47d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 873 of file PathOpsOpTest.cpp.

873 {
874 SkPath path, pathB;
875 path.setFillType(SkPathFillType::kWinding);
876 path.moveTo(0,1);
877 path.cubicTo(1,6, 6,2, 5,4);
878 path.close();
879 pathB.setFillType(SkPathFillType::kWinding);
880 pathB.moveTo(2,6);
881 pathB.cubicTo(4,5, 1,0, 6,1);
882 pathB.close();
883 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
884}

◆ cubicOp48d()

static void cubicOp48d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 886 of file PathOpsOpTest.cpp.

886 {
887 SkPath path, pathB;
888 path.setFillType(SkPathFillType::kWinding);
889 path.moveTo(0,2);
890 path.cubicTo(2,3, 5,1, 3,2);
891 path.close();
892 pathB.setFillType(SkPathFillType::kWinding);
893 pathB.moveTo(1,5);
894 pathB.cubicTo(2,3, 2,0, 3,2);
895 pathB.close();
896 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
897}

◆ cubicOp49d()

static void cubicOp49d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 899 of file PathOpsOpTest.cpp.

899 {
900 SkPath path, pathB;
901 path.setFillType(SkPathFillType::kWinding);
902 path.moveTo(0,2);
903 path.cubicTo(1,5, 3,2, 4,1);
904 path.close();
905 pathB.setFillType(SkPathFillType::kWinding);
906 pathB.moveTo(2,3);
907 pathB.cubicTo(1,4, 2,0, 5,1);
908 pathB.close();
909 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
910}

◆ cubicOp50d()

static void cubicOp50d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 912 of file PathOpsOpTest.cpp.

912 {
913 SkPath path, pathB;
914 path.setFillType(SkPathFillType::kWinding);
915 path.moveTo(0,3);
916 path.cubicTo(1,6, 5,0, 5,1);
917 path.close();
918 pathB.setFillType(SkPathFillType::kWinding);
919 pathB.moveTo(0,5);
920 pathB.cubicTo(1,5, 3,0, 6,1);
921 pathB.close();
922 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
923}

◆ cubicOp51d()

static void cubicOp51d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 925 of file PathOpsOpTest.cpp.

925 {
926 SkPath path, pathB;
927 path.setFillType(SkPathFillType::kWinding);
928 path.moveTo(0,3);
929 path.cubicTo(1,2, 4,1, 6,0);
930 path.close();
931 pathB.setFillType(SkPathFillType::kWinding);
932 pathB.moveTo(1,4);
933 pathB.cubicTo(0,6, 3,0, 2,1);
934 pathB.close();
935 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
936}

◆ cubicOp52d()

static void cubicOp52d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 938 of file PathOpsOpTest.cpp.

938 {
939 SkPath path, pathB;
940 path.setFillType(SkPathFillType::kWinding);
941 path.moveTo(0,2);
942 path.cubicTo(1,2, 5,4, 4,3);
943 path.close();
944 pathB.setFillType(SkPathFillType::kWinding);
945 pathB.moveTo(4,5);
946 pathB.cubicTo(3,4, 2,0, 2,1);
947 pathB.close();
948 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
949}

◆ cubicOp53d()

static void cubicOp53d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 951 of file PathOpsOpTest.cpp.

951 {
952 SkPath path, pathB;
953 path.setFillType(SkPathFillType::kWinding);
954 path.moveTo(0,3);
955 path.cubicTo(1,2, 5,3, 2,1);
956 path.close();
957 pathB.setFillType(SkPathFillType::kWinding);
958 pathB.moveTo(3,5);
959 pathB.cubicTo(1,2, 3,0, 2,1);
960 pathB.close();
961 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
962}

◆ cubicOp54d()

static void cubicOp54d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 964 of file PathOpsOpTest.cpp.

964 {
965 SkPath path, pathB;
966 path.setFillType(SkPathFillType::kWinding);
967 path.moveTo(0,4);
968 path.cubicTo(1,3, 5,4, 4,2);
969 path.close();
970 pathB.setFillType(SkPathFillType::kWinding);
971 pathB.moveTo(4,5);
972 pathB.cubicTo(2,4, 4,0, 3,1);
973 pathB.close();
974 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
975}

◆ cubicOp55d()

static void cubicOp55d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 977 of file PathOpsOpTest.cpp.

977 {
978 SkPath path, pathB;
979 path.setFillType(SkPathFillType::kWinding);
980 path.moveTo(0,5);
981 path.cubicTo(1,3, 3,2, 5,0);
982 path.close();
983 pathB.setFillType(SkPathFillType::kWinding);
984 pathB.moveTo(2,3);
985 pathB.cubicTo(0,5, 5,0, 3,1);
986 pathB.close();
987 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
988}

◆ cubicOp56d()

static void cubicOp56d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 990 of file PathOpsOpTest.cpp.

990 {
991 SkPath path, pathB;
992 path.setFillType(SkPathFillType::kWinding);
993 path.moveTo(0,1);
994 path.cubicTo(2,6, 5,0, 2,1);
995 path.close();
996 pathB.setFillType(SkPathFillType::kWinding);
997 pathB.moveTo(0,5);
998 pathB.cubicTo(1,2, 1,0, 6,2);
999 pathB.close();
1000 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1001}

◆ cubicOp57d()

static void cubicOp57d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1003 of file PathOpsOpTest.cpp.

1003 {
1004 SkPath path, pathB;
1005 path.setFillType(SkPathFillType::kWinding);
1006 path.moveTo(0,5);
1007 path.cubicTo(0,5, 5,4, 6,4);
1008 path.close();
1009 pathB.setFillType(SkPathFillType::kWinding);
1010 pathB.moveTo(4,5);
1011 pathB.cubicTo(4,6, 5,0, 5,0);
1012 pathB.close();
1013 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1014}

◆ cubicOp58d()

static void cubicOp58d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1016 of file PathOpsOpTest.cpp.

1016 {
1017 SkPath path, pathB;
1018 path.setFillType(SkPathFillType::kWinding);
1019 path.moveTo(0,5);
1020 path.cubicTo(3,4, 6,5, 5,3);
1021 path.close();
1022 pathB.setFillType(SkPathFillType::kWinding);
1023 pathB.moveTo(5,6);
1024 pathB.cubicTo(3,5, 5,0, 4,3);
1025 pathB.close();
1026 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1027}

◆ cubicOp59d()

static void cubicOp59d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1029 of file PathOpsOpTest.cpp.

1029 {
1030 SkPath path, pathB;
1031 path.setFillType(SkPathFillType::kWinding);
1032 path.moveTo(0,1);
1033 path.cubicTo(5,6, 4,0, 4,1);
1034 path.close();
1035 pathB.setFillType(SkPathFillType::kWinding);
1036 pathB.moveTo(0,4);
1037 pathB.cubicTo(1,4, 1,0, 6,5);
1038 pathB.close();
1039 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1040}

◆ cubicOp5d()

static void cubicOp5d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 91 of file PathOpsOpTest.cpp.

91 {
92 SkPath path, pathB;
93 path.setFillType(SkPathFillType::kWinding);
94 path.moveTo(0,1);
95 path.cubicTo(0,2, 1,0, 2,0);
96 path.close();
97 pathB.setFillType(SkPathFillType::kWinding);
98 pathB.moveTo(0,1);
99 pathB.cubicTo(0,2, 1,0, 2,0);
100 pathB.close();
101 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
102}

◆ cubicOp60d()

static void cubicOp60d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1042 of file PathOpsOpTest.cpp.

1042 {
1043 SkPath path, pathB;
1044 path.setFillType(SkPathFillType::kWinding);
1045 path.moveTo(0,2);
1046 path.cubicTo(4,6, 6,0, 5,2);
1047 path.close();
1048 pathB.setFillType(SkPathFillType::kWinding);
1049 pathB.moveTo(0,6);
1050 pathB.cubicTo(2,5, 2,0, 6,4);
1051 pathB.close();
1052 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1053}

◆ cubicOp61d()

static void cubicOp61d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1055 of file PathOpsOpTest.cpp.

1055 {
1056 SkPath path, pathB;
1057 path.setFillType(SkPathFillType::kWinding);
1058 path.moveTo(1,2);
1059 path.cubicTo(0,5, 3,2, 6,1);
1060 path.close();
1061 pathB.setFillType(SkPathFillType::kWinding);
1062 pathB.moveTo(2,3);
1063 pathB.cubicTo(1,6, 2,1, 5,0);
1064 pathB.close();
1065 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1066}

◆ cubicOp62d()

static void cubicOp62d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1068 of file PathOpsOpTest.cpp.

1068 {
1069 SkPath path, pathB;
1070 path.setFillType(SkPathFillType::kWinding);
1071 path.moveTo(1,3);
1072 path.cubicTo(5,6, 5,3, 5,4);
1073 path.close();
1074 pathB.setFillType(SkPathFillType::kWinding);
1075 pathB.moveTo(3,5);
1076 pathB.cubicTo(4,5, 3,1, 6,5);
1077 pathB.close();
1078 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1079}

◆ cubicOp63d()

static void cubicOp63d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1081 of file PathOpsOpTest.cpp.

1081 {
1082 SkPath path, pathB;
1083 path.setFillType(SkPathFillType::kWinding);
1084 path.moveTo(2,3);
1085 path.cubicTo(0,4, 3,2, 5,3);
1086 path.close();
1087 pathB.setFillType(SkPathFillType::kWinding);
1088 pathB.moveTo(2,3);
1089 pathB.cubicTo(3,5, 3,2, 4,0);
1090 pathB.close();
1091 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1092}

◆ cubicOp64d()

static void cubicOp64d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1094 of file PathOpsOpTest.cpp.

1094 {
1095 SkPath path, pathB;
1096 path.moveTo(0,1);
1097 path.cubicTo(0,1, 1,0, 3,0);
1098 path.lineTo(0,1);
1099 path.close();
1100 pathB.moveTo(0,1);
1101 pathB.cubicTo(0,3, 1,0, 1,0);
1102 pathB.lineTo(0,1);
1103 pathB.close();
1104 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1105}

◆ cubicOp65d()

static void cubicOp65d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1107 of file PathOpsOpTest.cpp.

1107 {
1108 SkPath path, pathB;
1109 path.moveTo(0,1);
1110 path.cubicTo(1,5, 1,0, 1,0);
1111 path.lineTo(0,1);
1112 path.close();
1113 pathB.moveTo(0,1);
1114 pathB.cubicTo(0,1, 1,0, 5,1);
1115 pathB.lineTo(0,1);
1116 pathB.close();
1117 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1118}

◆ cubicOp66u()

static void cubicOp66u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1133 of file PathOpsOpTest.cpp.

1133 {
1134 SkPath path, pathB;
1135 path.setFillType(SkPathFillType::kWinding);
1136 path.moveTo(0,1);
1137 path.cubicTo(2,6, 4,2, 5,3);
1138 path.close();
1139 pathB.setFillType(SkPathFillType::kWinding);
1140 pathB.moveTo(2,4);
1141 pathB.cubicTo(3,5, 1,0, 6,2);
1142 pathB.close();
1143 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1144}

◆ cubicOp67u()

static void cubicOp67u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1146 of file PathOpsOpTest.cpp.

1146 {
1147 SkPath path, pathB;
1148 path.moveTo(3,5);
1149 path.cubicTo(1,6, 5,0, 3,1);
1150 path.lineTo(3,5);
1151 path.close();
1152 pathB.moveTo(0,5);
1153 pathB.cubicTo(1,3, 5,3, 6,1);
1154 pathB.lineTo(0,5);
1155 pathB.close();
1156 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1157}

◆ cubicOp68u()

static void cubicOp68u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1159 of file PathOpsOpTest.cpp.

1159 {
1160 SkPath path, pathB;
1161 path.moveTo(0,5);
1162 path.cubicTo(4,5, 4,1, 5,0);
1163 path.close();
1164 pathB.moveTo(1,4);
1165 pathB.cubicTo(0,5, 5,0, 5,4);
1166 pathB.close();
1167 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1168}

◆ cubicOp69d()

static void cubicOp69d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1170 of file PathOpsOpTest.cpp.

1170 {
1171 SkPath path, pathB;
1172 path.moveTo(1,3);
1173 path.cubicTo(0,1, 3,1, 2,0);
1174 path.close();
1175 pathB.moveTo(1,3);
1176 pathB.cubicTo(0,2, 3,1, 1,0);
1177 pathB.close();
1178 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1179}

◆ cubicOp6d()

static void cubicOp6d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 104 of file PathOpsOpTest.cpp.

104 {
105 SkPath path, pathB;
106 path.setFillType(SkPathFillType::kWinding);
107 path.moveTo(0,1);
108 path.cubicTo(0,6, 1,0, 3,0);
109 path.close();
110 pathB.setFillType(SkPathFillType::kWinding);
111 pathB.moveTo(0,1);
112 pathB.cubicTo(0,3, 1,0, 6,0);
113 pathB.close();
114 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
115}

◆ cubicOp70d()

static void cubicOp70d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1369 of file PathOpsOpTest.cpp.

1369 {
1370 SkPath path, pathB;
1371 path.setFillType(SkPathFillType::kWinding);
1372 path.moveTo(0,1);
1373 path.cubicTo(0,5, 4,0, 5,0);
1374 path.close();
1375 pathB.setFillType(SkPathFillType::kWinding);
1376 pathB.moveTo(0,4);
1377 pathB.cubicTo(0,5, 1,0, 5,0);
1378 pathB.close();
1379 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1380}

◆ cubicOp71d()

static void cubicOp71d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1382 of file PathOpsOpTest.cpp.

1382 {
1383 SkPath path, pathB;
1384 path.setFillType(SkPathFillType::kWinding);
1385 path.moveTo(0,1);
1386 path.cubicTo(0,5, 4,1, 6,4);
1387 path.close();
1388 pathB.setFillType(SkPathFillType::kWinding);
1389 pathB.moveTo(1,4);
1390 pathB.cubicTo(4,6, 1,0, 5,0);
1391 pathB.close();
1392 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1393}

◆ cubicOp72i()

static void cubicOp72i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1395 of file PathOpsOpTest.cpp.

1395 {
1396 SkPath path, pathB;
1397 path.setFillType(SkPathFillType::kWinding);
1398 path.moveTo(0,1);
1399 path.cubicTo(0,5, 5,2, 5,4);
1400 path.close();
1401 pathB.setFillType(SkPathFillType::kWinding);
1402 pathB.moveTo(2,5);
1403 pathB.cubicTo(4,5, 1,0, 5,0);
1404 pathB.close();
1405 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1406}

◆ cubicOp73d()

static void cubicOp73d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1408 of file PathOpsOpTest.cpp.

1408 {
1409 SkPath path, pathB;
1410 path.setFillType(SkPathFillType::kWinding);
1411 path.moveTo(0,1);
1412 path.cubicTo(3,4, 4,0, 6,4);
1413 path.lineTo(0,1);
1414 path.close();
1415 pathB.setFillType(SkPathFillType::kWinding);
1416 pathB.moveTo(0,4);
1417 pathB.cubicTo(4,6, 1,0, 4,3);
1418 pathB.lineTo(0,4);
1419 pathB.close();
1420 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1421}

◆ cubicOp74d()

static void cubicOp74d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1423 of file PathOpsOpTest.cpp.

1423 {
1424 SkPath path, pathB;
1425 path.setFillType(SkPathFillType::kWinding);
1426 path.moveTo(0,1);
1427 path.cubicTo(1,5, 5,1, 5,1);
1428 path.lineTo(0,1);
1429 path.close();
1430 pathB.setFillType(SkPathFillType::kWinding);
1431 pathB.moveTo(1,5);
1432 pathB.cubicTo(1,5, 1,0, 5,1);
1433 pathB.lineTo(1,5);
1434 pathB.close();
1435 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1436}

◆ cubicOp75d()

static void cubicOp75d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1438 of file PathOpsOpTest.cpp.

1438 {
1439 SkPath path, pathB;
1440 path.setFillType(SkPathFillType::kWinding);
1441 path.moveTo(0,1);
1442 path.cubicTo(0,4, 5,1, 6,4);
1443 path.lineTo(0,1);
1444 path.close();
1445 pathB.setFillType(SkPathFillType::kWinding);
1446 pathB.moveTo(1,5);
1447 pathB.cubicTo(4,6, 1,0, 4,0);
1448 pathB.lineTo(1,5);
1449 pathB.close();
1450 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1451}

◆ cubicOp76u()

static void cubicOp76u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1453 of file PathOpsOpTest.cpp.

1453 {
1454 SkPath path, pathB;
1455 path.setFillType(SkPathFillType::kWinding);
1456 path.moveTo(0,1);
1457 path.cubicTo(0,2, 2,0, 5,3);
1458 path.close();
1459 pathB.setFillType(SkPathFillType::kWinding);
1460 pathB.moveTo(0,2);
1461 pathB.cubicTo(3,5, 1,0, 2,0);
1462 pathB.close();
1463 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1464}

◆ cubicOp77i()

static void cubicOp77i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1466 of file PathOpsOpTest.cpp.

1466 {
1467 SkPath path, pathB;
1468 path.setFillType(SkPathFillType::kEvenOdd);
1469 path.moveTo(0,1);
1470 path.cubicTo(1,3, 2,0, 3,2);
1471 path.lineTo(0,1);
1472 path.close();
1473 pathB.setFillType(SkPathFillType::kEvenOdd);
1474 pathB.moveTo(0,2);
1475 pathB.cubicTo(2,3, 1,0, 3,1);
1476 pathB.lineTo(0,2);
1477 pathB.close();
1478 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1479}

◆ cubicOp78u()

static void cubicOp78u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1481 of file PathOpsOpTest.cpp.

1481 {
1482 SkPath path, pathB;
1483 path.setFillType(SkPathFillType::kEvenOdd);
1484 path.moveTo(1,6);
1485 path.cubicTo(1,6, 5,0, 6,1);
1486 path.lineTo(1,6);
1487 path.close();
1488 pathB.setFillType(SkPathFillType::kEvenOdd);
1489 pathB.moveTo(0,5);
1490 pathB.cubicTo(1,6, 6,1, 6,1);
1491 pathB.lineTo(0,5);
1492 pathB.close();
1493 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1494}

◆ cubicOp79u()

static void cubicOp79u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1496 of file PathOpsOpTest.cpp.

1496 {
1497 SkPath path, pathB;
1498 path.setFillType(SkPathFillType::kWinding);
1499 path.moveTo(0,1);
1500 path.cubicTo(1,3, 1,0, 6,4);
1501 path.close();
1502 pathB.setFillType(SkPathFillType::kWinding);
1503 pathB.moveTo(0,1);
1504 pathB.cubicTo(4,6, 1,0, 3,1);
1505 pathB.close();
1506 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1507}

◆ cubicOp7d()

static void cubicOp7d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 117 of file PathOpsOpTest.cpp.

117 {
118 SkPath path, pathB;
119 path.setFillType(SkPathFillType::kWinding);
120 path.moveTo(0,1);
121 path.cubicTo(3,4, 1,0, 3,0);
122 path.close();
123 pathB.setFillType(SkPathFillType::kWinding);
124 pathB.moveTo(0,1);
125 pathB.cubicTo(0,3, 1,0, 4,3);
126 pathB.close();
127 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
128}

◆ cubicOp80i()

static void cubicOp80i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1509 of file PathOpsOpTest.cpp.

1509 {
1510 SkPath path, pathB;
1511 path.setFillType(SkPathFillType::kWinding);
1512 path.moveTo(0,1);
1513 path.cubicTo(2,3, 2,1, 4,3);
1514 path.lineTo(0,1);
1515 path.close();
1516 pathB.setFillType(SkPathFillType::kWinding);
1517 pathB.moveTo(1,2);
1518 pathB.cubicTo(3,4, 1,0, 3,2);
1519 pathB.lineTo(1,2);
1520 pathB.close();
1521 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1522}

◆ cubicOp81d()

static void cubicOp81d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1524 of file PathOpsOpTest.cpp.

1524 {
1525 SkPath path, pathB;
1526 path.setFillType(SkPathFillType::kWinding);
1527 path.moveTo(0,1);
1528 path.cubicTo(4,6, 4,3, 5,4);
1529 path.close();
1530 pathB.setFillType(SkPathFillType::kWinding);
1531 pathB.moveTo(3,4);
1532 pathB.cubicTo(4,5, 1,0, 6,4);
1533 pathB.close();
1534 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1535}

◆ cubicOp82i()

static void cubicOp82i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1537 of file PathOpsOpTest.cpp.

1537 {
1538 SkPath path, pathB;
1539 path.setFillType(SkPathFillType::kEvenOdd);
1540 path.moveTo(0,1);
1541 path.cubicTo(2,3, 5,2, 3,0);
1542 path.lineTo(0,1);
1543 path.close();
1544 pathB.setFillType(SkPathFillType::kWinding);
1545 pathB.moveTo(2,5);
1546 pathB.cubicTo(0,3, 1,0, 3,2);
1547 pathB.lineTo(2,5);
1548 pathB.close();
1549 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1550}

◆ cubicOp83i()

static void cubicOp83i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1552 of file PathOpsOpTest.cpp.

1552 {
1553 SkPath path, pathB;
1554 path.setFillType(SkPathFillType::kWinding);
1555 path.moveTo(0,1);
1556 path.cubicTo(0,3, 2,1, 4,1);
1557 path.lineTo(0,1);
1558 path.close();
1559 pathB.setFillType(SkPathFillType::kWinding);
1560 pathB.moveTo(1,2);
1561 pathB.cubicTo(1,4, 1,0, 3,0);
1562 pathB.lineTo(1,2);
1563 pathB.close();
1564 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1565}

◆ cubicOp84d()

static void cubicOp84d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1567 of file PathOpsOpTest.cpp.

1567 {
1568 SkPath path, pathB;
1569 path.setFillType(SkPathFillType::kWinding);
1570 path.moveTo(0,4);
1571 path.cubicTo(2,3, 6,3, 3,2);
1572 path.close();
1573 pathB.setFillType(SkPathFillType::kWinding);
1574 pathB.moveTo(3,6);
1575 pathB.cubicTo(2,3, 4,0, 3,2);
1576 pathB.close();
1577 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1578}

◆ cubicOp85d()

static void cubicOp85d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1821 of file PathOpsOpTest.cpp.

1821 {
1822 SkPath path;
1823 path.setFillType(SkPathFillType::kWinding);
1824 path.moveTo(0,1);
1825 path.cubicTo(1,6, 1,0, 6,2);
1826 path.close();
1827 SkPath pathB;
1828 pathB.setFillType(SkPathFillType::kWinding);
1829 pathB.moveTo(0,1);
1830 pathB.cubicTo(2,6, 1,0, 6,1);
1831 pathB.close();
1832 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1833}

◆ cubicOp85i()

static void cubicOp85i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2001 of file PathOpsOpTest.cpp.

2001 {
2002 SkPath path, pathB;
2003 path.setFillType(SkPathFillType::kWinding);
2004 path.moveTo(3, 4);
2005 path.cubicTo(1, 5, 4, 3, 6, 4);
2006 path.close();
2007 pathB.setFillType(SkPathFillType::kWinding);
2008 pathB.moveTo(3, 4);
2009 pathB.cubicTo(4, 6, 4, 3, 5, 1);
2010 pathB.close();
2011 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2012}

◆ cubicOp86i()

static void cubicOp86i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2212 of file PathOpsOpTest.cpp.

2212 {
2213 SkPath path, pathB;
2214 path.setFillType(SkPathFillType::kWinding);
2215 path.moveTo(0, 4);
2216 path.cubicTo(3, 4, 6, 2, 5, 2);
2217 path.close();
2218 pathB.setFillType(SkPathFillType::kEvenOdd);
2219 pathB.moveTo(2, 6);
2220 pathB.cubicTo(2, 5, 4, 0, 4, 3);
2221 pathB.close();
2222 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2223}

◆ cubicOp87u()

static void cubicOp87u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2225 of file PathOpsOpTest.cpp.

2225 {
2226 SkPath path, pathB;
2227 path.setFillType(SkPathFillType::kWinding);
2228 path.moveTo(0,1);
2229 path.cubicTo(0,2, 2,0, 6,4);
2230 path.close();
2231 pathB.setFillType(SkPathFillType::kWinding);
2232 pathB.moveTo(0,2);
2233 pathB.cubicTo(4,6, 1,0, 2,0);
2234 pathB.close();
2235 markTestFlakyForPathKit();
2236 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2237}
markTestFlakyForPathKit
void markTestFlakyForPathKit()
Definition PathOpsExtendedTest.cpp:369

◆ cubicOp88u()

static void cubicOp88u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2239 of file PathOpsOpTest.cpp.

2239 {
2240 SkPath path, pathB;
2241 path.setFillType(SkPathFillType::kWinding);
2242 path.moveTo(0,1);
2243 path.cubicTo(2,5, 5,0, 6,4);
2244 path.close();
2245 pathB.setFillType(SkPathFillType::kWinding);
2246 pathB.moveTo(0,5);
2247 pathB.cubicTo(4,6, 1,0, 5,2);
2248 pathB.close();
2249 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2250}

◆ cubicOp89u()

static void cubicOp89u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2252 of file PathOpsOpTest.cpp.

2252 {
2253 SkPath path, pathB;
2254 path.setFillType(SkPathFillType::kWinding);
2255 path.moveTo(0, 3);
2256 path.cubicTo(1, 6, 5, 0, 6, 3);
2257 path.close();
2258 pathB.setFillType(SkPathFillType::kWinding);
2259 pathB.moveTo(0, 5);
2260 pathB.cubicTo(3, 6, 3, 0, 6, 1);
2261 pathB.close();
2262 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2263}

◆ cubicOp8d()

static void cubicOp8d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 130 of file PathOpsOpTest.cpp.

130 {
131 SkPath path, pathB;
132 path.setFillType(SkPathFillType::kWinding);
133 path.moveTo(0,1);
134 path.cubicTo(0,5, 1,0, 4,0);
135 path.close();
136 pathB.setFillType(SkPathFillType::kWinding);
137 pathB.moveTo(0,1);
138 pathB.cubicTo(0,4, 1,0, 5,0);
139 pathB.close();
140 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
141}

◆ cubicOp90u()

static void cubicOp90u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2265 of file PathOpsOpTest.cpp.

2265 {
2266 SkPath path, pathB;
2267 path.setFillType(SkPathFillType::kEvenOdd);
2268 path.moveTo(0, 5);
2269 path.cubicTo(1, 2, 5, 2, 4, 1);
2270 path.close();
2271 pathB.setFillType(SkPathFillType::kEvenOdd);
2272 pathB.moveTo(2, 5);
2273 pathB.cubicTo(1, 4, 5, 0, 2, 1);
2274 pathB.close();
2275 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2276}

◆ cubicOp91u()

static void cubicOp91u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2278 of file PathOpsOpTest.cpp.

2278 {
2279 SkPath path, pathB;
2280 path.setFillType(SkPathFillType::kWinding);
2281 path.moveTo(1, 6);
2282 path.cubicTo(0, 3, 6, 3, 5, 0);
2283 path.close();
2284 pathB.setFillType(SkPathFillType::kWinding);
2285 pathB.moveTo(3, 6);
2286 pathB.cubicTo(0, 5, 6, 1, 3, 0);
2287 pathB.close();
2288 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2289}

◆ cubicOp92i()

static void cubicOp92i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2504 of file PathOpsOpTest.cpp.

2504 {
2505 SkPath path, pathB;
2506 path.setFillType(SkPathFillType::kWinding);
2507 path.moveTo(0, 1);
2508 path.cubicTo(2, 6, 4, 1, 5, 4);
2509 path.close();
2510 pathB.setFillType(SkPathFillType::kWinding);
2511 pathB.moveTo(1, 4);
2512 pathB.cubicTo(4, 5, 1, 0, 6, 2);
2513 pathB.close();
2514 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2515}

◆ cubicOp93d()

static void cubicOp93d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2517 of file PathOpsOpTest.cpp.

2517 {
2518 SkPath path, pathB;
2519 path.setFillType(SkPathFillType::kWinding);
2520 path.moveTo(0, 1);
2521 path.cubicTo(1, 6, 4, 1, 4, 3);
2522 path.close();
2523 pathB.setFillType(SkPathFillType::kWinding);
2524 pathB.moveTo(1, 4);
2525 pathB.cubicTo(3, 4, 1, 0, 6, 1);
2526 pathB.close();
2527 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2528}

◆ cubicOp94u()

static void cubicOp94u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2530 of file PathOpsOpTest.cpp.

2530 {
2531 SkPath path, pathB;
2532 path.setFillType(SkPathFillType::kEvenOdd);
2533 path.moveTo(0, 3);
2534 path.cubicTo(2, 3, 5, 0, 5, 3);
2535 path.close();
2536 pathB.setFillType(SkPathFillType::kEvenOdd);
2537 pathB.moveTo(0, 5);
2538 pathB.cubicTo(3, 5, 3, 0, 3, 2);
2539 pathB.close();
2540 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2541}

◆ cubicOp95u()

static void cubicOp95u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2997 of file PathOpsOpTest.cpp.

2997 {
2998 SkPath path, pathB;
2999 path.setFillType(SkPathFillType::kEvenOdd);
3000 path.moveTo(0, 2);
3001 path.cubicTo(2, 3, 5, 1, 3, 2);
3002 path.close();
3003 pathB.setFillType(SkPathFillType::kEvenOdd);
3004 pathB.moveTo(1, 5);
3005 pathB.cubicTo(2, 3, 2, 0, 3, 2);
3006 pathB.close();
3007 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3008}

◆ cubicOp96d()

static void cubicOp96d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3010 of file PathOpsOpTest.cpp.

3010 {
3011 SkPath path, pathB;
3012 path.setFillType(SkPathFillType::kEvenOdd);
3013 path.moveTo(1, 6);
3014 path.cubicTo(0, 3, 6, 3, 5, 0);
3015 path.close();
3016 pathB.setFillType(SkPathFillType::kEvenOdd);
3017 pathB.moveTo(3, 6);
3018 pathB.cubicTo(0, 5, 6, 1, 3, 0);
3019 pathB.close();
3020 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3021}

◆ cubicOp97x()

static void cubicOp97x ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3023 of file PathOpsOpTest.cpp.

3023 {
3024 SkPath path, pathB;
3025 path.setFillType(SkPathFillType::kEvenOdd);
3026 path.moveTo(0, 2);
3027 path.cubicTo(0, 6, 2, 1, 2, 1);
3028 path.close();
3029 pathB.setFillType(SkPathFillType::kEvenOdd);
3030 pathB.moveTo(1, 2);
3031 pathB.cubicTo(1, 2, 2, 0, 6, 0);
3032 pathB.close();
3033 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
3034}

◆ cubicOp98x()

static void cubicOp98x ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3036 of file PathOpsOpTest.cpp.

3036 {
3037 SkPath path, pathB;
3038 path.setFillType(SkPathFillType::kEvenOdd);
3039 path.moveTo(0, 3);
3040 path.cubicTo(3, 6, 4, 1, 6, 3);
3041 path.close();
3042 pathB.setFillType(SkPathFillType::kEvenOdd);
3043 pathB.moveTo(1, 4);
3044 pathB.cubicTo(3, 6, 3, 0, 6, 3);
3045 pathB.close();
3046 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
3047}

◆ cubicOp99()

static void cubicOp99 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3049 of file PathOpsOpTest.cpp.

3049 {
3050 SkPath path, pathB;
3051 path.setFillType(SkPathFillType::kWinding);
3052 path.moveTo(3,6);
3053 path.cubicTo(0,3, 6,5, 5,4);
3054 path.close();
3055 pathB.setFillType(SkPathFillType::kWinding);
3056 pathB.moveTo(5,6);
3057 pathB.cubicTo(4,5, 6,3, 3,0);
3058 pathB.close();
3059 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3060}

◆ cubicOp9d()

static void cubicOp9d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 143 of file PathOpsOpTest.cpp.

143 {
144 SkPath path, pathB;
145 path.setFillType(SkPathFillType::kWinding);
146 path.moveTo(0,1);
147 path.cubicTo(1,6, 1,0, 2,1);
148 path.close();
149 pathB.setFillType(SkPathFillType::kWinding);
150 pathB.moveTo(0,1);
151 pathB.cubicTo(1,2, 1,0, 6,1);
152 pathB.close();
153 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
154}

◆ cubics10u()

static void cubics10u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4354 of file PathOpsOpTest.cpp.

4354 {
4355 SkPath path, pathB;
4356 path.setFillType(SkPathFillType::kWinding);
4357 path.moveTo(2, 4);
4358 path.cubicTo(1, 6, 4, 1, 5, 1);
4359 path.close();
4360 pathB.setFillType(SkPathFillType::kWinding);
4361 pathB.moveTo(1, 4);
4362 pathB.cubicTo(1, 5, 4, 2, 6, 1);
4363 pathB.close();
4364 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
4365}

◆ cubics11i()

static void cubics11i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4367 of file PathOpsOpTest.cpp.

4367 {
4368 SkPath path, pathB;
4369 path.setFillType(SkPathFillType::kWinding);
4370 path.moveTo(2, 4);
4371 path.cubicTo(2, 5, 3, 2, 5, 1);
4372 path.close();
4373 pathB.setFillType(SkPathFillType::kWinding);
4374 pathB.moveTo(2, 3);
4375 pathB.cubicTo(1, 5, 4, 2, 5, 2);
4376 pathB.close();
4377 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4378}

◆ cubics12d()

static void cubics12d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4380 of file PathOpsOpTest.cpp.

4380 {
4381 SkPath path, pathB;
4382 path.setFillType(SkPathFillType::kWinding);
4383 path.moveTo(2, 4);
4384 path.cubicTo(0, 4, 5, 3, 5, 1);
4385 path.close();
4386 pathB.setFillType(SkPathFillType::kWinding);
4387 pathB.moveTo(3, 5);
4388 pathB.cubicTo(1, 5, 4, 2, 4, 0);
4389 pathB.close();
4390 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4391}

◆ cubics137()

static void cubics137 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4137 of file PathOpsOpTest.cpp.

4137 {
4138 SkPath path, pathB;
4139 path.setFillType(SkPathFillType::kWinding);
4140 path.moveTo(0, 5);
4141 path.cubicTo(3, 6, 1, 0, 3, 2);
4142 path.close();
4143 pathB.setFillType(SkPathFillType::kWinding);
4144 pathB.moveTo(0, 1);
4145 pathB.cubicTo(2, 3, 5, 0, 6, 3);
4146 pathB.close();
4147 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4148}

◆ cubics138()

static void cubics138 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4150 of file PathOpsOpTest.cpp.

4150 {
4151 SkPath path, pathB;
4152 path.setFillType(SkPathFillType::kWinding);
4153 path.moveTo(0, 5);
4154 path.cubicTo(3, 6, 1, 0, 4, 2);
4155 path.close();
4156 pathB.setFillType(SkPathFillType::kWinding);
4157 pathB.moveTo(0, 1);
4158 pathB.cubicTo(2, 4, 5, 0, 6, 3);
4159 pathB.close();
4160 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4161}

◆ cubics13d()

static void cubics13d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4393 of file PathOpsOpTest.cpp.

4393 {
4394 SkPath path, pathB;
4395 path.setFillType(SkPathFillType::kWinding);
4396 path.moveTo(2, 3);
4397 path.cubicTo(1, 5, 4, 2, 5, 2);
4398 path.close();
4399 pathB.setFillType(SkPathFillType::kWinding);
4400 pathB.moveTo(2, 4);
4401 pathB.cubicTo(2, 5, 3, 2, 5, 1);
4402 pathB.close();
4403 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4404}

◆ cubics14d()

static void cubics14d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4406 of file PathOpsOpTest.cpp.

4406 {
4407 SkPath path, pathB;
4408 path.setFillType(SkPathFillType::kWinding);
4409 path.moveTo(2, 3);
4410 path.cubicTo(0, 4, 3, 1, 3, 0);
4411 path.close();
4412 pathB.setFillType(SkPathFillType::kWinding);
4413 pathB.moveTo(1, 3);
4414 pathB.cubicTo(0, 3, 3, 2, 4, 0);
4415 pathB.close();
4416 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4417}

◆ cubics15d()

static void cubics15d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4419 of file PathOpsOpTest.cpp.

4419 {
4420 SkPath path, pathB;
4421 path.setFillType(SkPathFillType::kWinding);
4422 path.moveTo(1, 5);
4423 path.cubicTo(3, 5, 4, 0, 4, 2);
4424 path.close();
4425 pathB.setFillType(SkPathFillType::kWinding);
4426 pathB.moveTo(0, 4);
4427 pathB.cubicTo(2, 4, 5, 1, 5, 3);
4428 pathB.close();
4429 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4430}

◆ cubics16i()

static void cubics16i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4432 of file PathOpsOpTest.cpp.

4432 {
4433 SkPath path, pathB;
4434 path.setFillType(SkPathFillType::kWinding);
4435 path.moveTo(1, 5);
4436 path.cubicTo(2, 5, 5, 0, 4, 2);
4437 path.close();
4438 pathB.setFillType(SkPathFillType::kWinding);
4439 pathB.moveTo(0, 5);
4440 pathB.cubicTo(2, 4, 5, 1, 5, 2);
4441 pathB.close();
4442 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4443}

◆ cubics17d()

static void cubics17d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4445 of file PathOpsOpTest.cpp.

4445 {
4446 SkPath path, pathB;
4447 path.setFillType(SkPathFillType::kWinding);
4448 path.moveTo(1, 5);
4449 path.cubicTo(3, 4, 4, 1, 4, 2);
4450 path.close();
4451 pathB.setFillType(SkPathFillType::kWinding);
4452 pathB.moveTo(1, 4);
4453 pathB.cubicTo(2, 4, 5, 1, 4, 3);
4454 pathB.close();
4455 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4456}

◆ cubics18d()

static void cubics18d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4458 of file PathOpsOpTest.cpp.

4458 {
4459 SkPath path, pathB;
4460 path.setFillType(SkPathFillType::kWinding);
4461 path.moveTo(1, 5);
4462 path.cubicTo(1, 3, 4, 0, 2, 0);
4463 path.close();
4464 pathB.setFillType(SkPathFillType::kWinding);
4465 pathB.moveTo(0, 4);
4466 pathB.cubicTo(0, 2, 5, 1, 3, 1);
4467 pathB.close();
4468 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4469}

◆ cubics19d()

static void cubics19d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4471 of file PathOpsOpTest.cpp.

4471 {
4472 SkPath path, pathB;
4473 path.setFillType(SkPathFillType::kWinding);
4474 path.moveTo(1, 5);
4475 path.cubicTo(2, 3, 5, 2, 4, 2);
4476 path.close();
4477 pathB.setFillType(SkPathFillType::kWinding);
4478 pathB.moveTo(2, 5);
4479 pathB.cubicTo(2, 4, 5, 1, 3, 2);
4480 pathB.close();
4481 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4482}

◆ cubics20d()

static void cubics20d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4497 of file PathOpsOpTest.cpp.

4497 {
4498 SkPath path, pathB;
4499 path.setFillType(SkPathFillType::kWinding);
4500 path.moveTo(1, 2);
4501 path.cubicTo(0, 3, 6, 0, 3, 2);
4502 path.close();
4503 pathB.setFillType(SkPathFillType::kWinding);
4504 pathB.moveTo(0, 6);
4505 pathB.cubicTo(2, 3, 2, 1, 3, 0);
4506 pathB.close();
4507 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4508}

◆ cubics41d()

static void cubics41d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5097 of file PathOpsOpTest.cpp.

5097 {
5098 SkPath path, pathB;
5099 path.setFillType(SkPathFillType::kWinding);
5100 path.moveTo(0, 1);
5101 path.cubicTo(1, 4, 3, 0, 3, 1);
5102 path.close();
5103 pathB.setFillType(SkPathFillType::kWinding);
5104 pathB.moveTo(0, 3);
5105 pathB.cubicTo(1, 3, 1, 0, 4, 1);
5106 pathB.close();
5107 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5108}

◆ cubics44d()

static void cubics44d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5149 of file PathOpsOpTest.cpp.

5149 {
5150 SkPath path, pathB;
5151 path.setFillType(SkPathFillType::kWinding);
5152 path.moveTo(3, 4);
5153 path.cubicTo(2, 5, 3, 1, 6, 2);
5154 path.close();
5155 pathB.setFillType(SkPathFillType::kWinding);
5156 pathB.moveTo(1, 3);
5157 pathB.cubicTo(2, 6, 4, 3, 5, 2);
5158 pathB.close();
5159 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5160}

◆ cubics45u()

static void cubics45u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5162 of file PathOpsOpTest.cpp.

5162 {
5163 SkPath path, pathB;
5164 path.setFillType(SkPathFillType::kWinding);
5165 path.moveTo(1, 3);
5166 path.cubicTo(2, 6, 4, 3, 5, 2);
5167 path.close();
5168 pathB.setFillType(SkPathFillType::kWinding);
5169 pathB.moveTo(3, 4);
5170 pathB.cubicTo(2, 5, 3, 1, 6, 2);
5171 pathB.close();
5172 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
5173}

◆ cubics6d()

static void cubics6d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4302 of file PathOpsOpTest.cpp.

4302 {
4303 SkPath path, pathB;
4304 path.setFillType(SkPathFillType::kWinding);
4305 path.moveTo(3, 5);
4306 path.cubicTo(1, 5, 4, 2, 4, 0);
4307 path.close();
4308 pathB.setFillType(SkPathFillType::kWinding);
4309 pathB.moveTo(2, 4);
4310 pathB.cubicTo(0, 4, 5, 3, 5, 1);
4311 pathB.close();
4312 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4313}

◆ cubics7d()

static void cubics7d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4315 of file PathOpsOpTest.cpp.

4315 {
4316 SkPath path, pathB;
4317 path.setFillType(SkPathFillType::kWinding);
4318 path.moveTo(2, 6);
4319 path.cubicTo(2, 4, 5, 1, 3, 1);
4320 path.close();
4321 pathB.setFillType(SkPathFillType::kWinding);
4322 pathB.moveTo(1, 5);
4323 pathB.cubicTo(1, 3, 6, 2, 4, 2);
4324 pathB.close();
4325 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4326}

◆ cubics8d()

static void cubics8d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4328 of file PathOpsOpTest.cpp.

4328 {
4329 SkPath path, pathB;
4330 path.setFillType(SkPathFillType::kWinding);
4331 path.moveTo(2, 5);
4332 path.cubicTo(2, 4, 5, 1, 3, 2);
4333 path.close();
4334 pathB.setFillType(SkPathFillType::kWinding);
4335 pathB.moveTo(1, 5);
4336 pathB.cubicTo(2, 3, 5, 2, 4, 2);
4337 pathB.close();
4338 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4339}

◆ cubics9d()

static void cubics9d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4341 of file PathOpsOpTest.cpp.

4341 {
4342 SkPath path, pathB;
4343 path.setFillType(SkPathFillType::kWinding);
4344 path.moveTo(2, 4);
4345 path.cubicTo(2, 6, 3, 1, 5, 1);
4346 path.close();
4347 pathB.setFillType(SkPathFillType::kWinding);
4348 pathB.moveTo(1, 3);
4349 pathB.cubicTo(1, 5, 4, 2, 6, 2);
4350 pathB.close();
4351 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4352}

◆ cubics_d()

static void cubics_d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5258 of file PathOpsOpTest.cpp.

5258 {
5259 SkPath path, pathB;
5260 path.setFillType(SkPathFillType::kWinding);
5261 path.moveTo(0, 1);
5262 path.cubicTo(3, 5, 1, 0, 3, 0);
5263 path.close();
5264 pathB.setFillType(SkPathFillType::kWinding);
5265 pathB.moveTo(0, 1);
5266 pathB.cubicTo(0, 3, 1, 0, 5, 3);
5267 pathB.close();
5268 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5269}

◆ cubics_d2()

static void cubics_d2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5271 of file PathOpsOpTest.cpp.

5271 {
5272 SkPath path, pathB;
5273 path.setFillType(SkPathFillType::kWinding);
5274 path.moveTo(0, 1);
5275 path.cubicTo(2, 5, 2, 0, 2, 1);
5276 path.close();
5277 pathB.setFillType(SkPathFillType::kWinding);
5278 pathB.moveTo(0, 2);
5279 pathB.cubicTo(1, 2, 1, 0, 5, 2);
5280 pathB.close();
5281 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5282}

◆ cubics_d3()

static void cubics_d3 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5362 of file PathOpsOpTest.cpp.

5362 {
5363 SkPath path, pathB;
5364 path.setFillType(SkPathFillType::kWinding);
5365 path.moveTo(3, 4);
5366 path.cubicTo(0, 6, 6, 1, 4, 2);
5367 path.close();
5368 pathB.setFillType(SkPathFillType::kWinding);
5369 pathB.moveTo(1, 6);
5370 pathB.cubicTo(2, 4, 4, 3, 6, 0);
5371 pathB.close();
5372 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5373}

◆ cubics_o()

static void cubics_o ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5375 of file PathOpsOpTest.cpp.

5375 {
5376 SkPath path, pathB;
5377 path.setFillType(SkPathFillType::kWinding);
5378 path.moveTo(1, 4);
5379 path.cubicTo(2, 6, 5, 0, 5, 3);
5380 path.close();
5381 pathB.setFillType(SkPathFillType::kWinding);
5382 pathB.moveTo(0, 5);
5383 pathB.cubicTo(3, 5, 4, 1, 6, 2);
5384 pathB.close();
5385 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
5386}

◆ dean2()

static void dean2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5237 of file PathOpsOpTest.cpp.

5237 {
5238 SkPath path;
5239 path.setFillType((SkPathFillType) 0);
5240path.moveTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5241path.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
5242path.cubicTo(SkBits2Float(0x414a835a), SkBits2Float(0x3ec07ba6), SkBits2Float(0x413fcc0d), SkBits2Float(0x3e193319), SkBits2Float(0x4134a02b), SkBits2Float(0x00000000)); // 12.6571f, 0.375943f, 11.9873f, 0.149609f, 11.2891f, 0
5243path.lineTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5244path.close();
5245 SkPath path1(path);
5246
5247 path.reset();
5248 path.setFillType((SkPathFillType) 0);
5249path.moveTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5250path.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
5251path.lineTo(SkBits2Float(0x417ab74b), SkBits2Float(0x4154a02b)); // 15.6697f, 13.2891f
5252path.lineTo(SkBits2Float(0x3f2b74b3), SkBits2Float(0x4154a02b)); // 0.669749f, 13.2891f
5253path.close();
5254 SkPath path2(path);
5255 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename);
5256}

◆ DEF_TEST() [1/3]

DEF_TEST ( PathOpsFailOp  ,
reporter   
)

Definition at line 12541 of file PathOpsOpTest.cpp.

12541 {
12542 RunTestSet(reporter, failTests, failTestCount, nullptr, nullptr, nullptr, false);
12543}
RunTestSet
void RunTestSet(skiatest::Reporter *reporter, TestDesc tests[], size_t count, void(*firstTest)(skiatest::Reporter *, const char *filename), void(*skipTest)(skiatest::Reporter *, const char *filename), void(*stopTest)(skiatest::Reporter *, const char *filename), bool reverse)
Definition PathOpsExtendedTest.cpp:691
failTests
static struct TestDesc failTests[]
Definition PathOpsOpTest.cpp:12451
failTestCount
static const size_t failTestCount
Definition PathOpsOpTest.cpp:12539

◆ DEF_TEST() [2/3]

DEF_TEST ( PathOpsOp  ,
reporter   
)

Definition at line 9507 of file PathOpsOpTest.cpp.

9507 {
9508 if (runSubTests && runSubTestsFirst) {
9509 RunTestSet(reporter, subTests, subTestCount, firstSubTest, nullptr, stopTest, runReverse);
9510 }
9511 RunTestSet(reporter, tests, testCount, firstTest, skipTest, stopTest, runReverse);
9512 if (runSubTests && !runSubTestsFirst) {
9513 RunTestSet(reporter, subTests, subTestCount, firstSubTest, nullptr, stopTest, runReverse);
9514 }
9515}
subTests
static struct TestDesc subTests[]
Definition PathOpsOpTest.cpp:9492
testCount
static const size_t testCount
Definition PathOpsOpTest.cpp:9490
runSubTests
static bool runSubTests
Definition PathOpsOpTest.cpp:9503
stopTest
static void(* stopTest)(skiatest::Reporter *, const char *filename)
Definition PathOpsOpTest.cpp:9121
runSubTestsFirst
static bool runSubTestsFirst
Definition PathOpsOpTest.cpp:9504
tests
static struct TestDesc tests[]
Definition PathOpsOpTest.cpp:9125
subTestCount
static const size_t subTestCount
Definition PathOpsOpTest.cpp:9499
firstTest
static void(* firstTest)(skiatest::Reporter *, const char *filename)
Definition PathOpsOpTest.cpp:9120
firstSubTest
static void(* firstSubTest)(skiatest::Reporter *, const char *filename)
Definition PathOpsOpTest.cpp:9501
skipTest
static void(* skipTest)(skiatest::Reporter *, const char *filename)
Definition PathOpsOpTest.cpp:9119
runReverse
static bool runReverse
Definition PathOpsOpTest.cpp:9505

◆ DEF_TEST() [3/3]

DEF_TEST ( PathOpsRepOp  ,
reporter   
)

Definition at line 12549 of file PathOpsOpTest.cpp.

12549 {
12550 if (PathOpsDebug::gJson) {
12551 return;
12552 }
12553 for (int index = 0; index < 1; ++index)
12554 RunTestSet(reporter, repTests, std::size(repTests), nullptr, nullptr, nullptr, false);
12555}
repTests
static struct TestDesc repTests[]
Definition PathOpsOpTest.cpp:12545
PathOpsDebug::gJson
static bool gJson
Definition PathOpsDebug.h:15

◆ filinmangust14()

static void filinmangust14 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5774 of file PathOpsOpTest.cpp.

5774 {
5775SkPath path, path1;
5776path.setFillType(SkPathFillType::kWinding);
5777 path.moveTo(SkBits2Float(0x440bc02c), SkBits2Float(0x4409c000)); // 559.003f, 551
5778 path.lineTo(SkBits2Float(0x440bc02c), SkBits2Float(0x440e8000)); // 559.003f, 570
5779 path.lineTo(SkBits2Float(0x440bbfda), SkBits2Float(0x440e8000)); // 558.998f, 570
5780 path.lineTo(SkBits2Float(0x440bbfda), SkBits2Float(0x4409c000)); // 558.998f, 551
5781 path.lineTo(SkBits2Float(0x440bc02c), SkBits2Float(0x4409c000)); // 559.003f, 551
5782 path.close();
5783path1 = path;
5784path.reset();
5785 path.setFillType(SkPathFillType::kWinding);
5786 path.moveTo(SkBits2Float(0x45582000), SkBits2Float(0x45be9805)); // 3458, 6099
5787 path.lineTo(SkBits2Float(0x4554b667), SkBits2Float(0x45be9805)); // 3403.4f, 6099
5788 path.lineTo(SkBits2Float(0x4554b667), SkBits2Float(0x45be97fb)); // 3403.4f, 6099
5789 path.lineTo(SkBits2Float(0x45582000), SkBits2Float(0x45be97fb)); // 3458, 6099
5790 path.lineTo(SkBits2Float(0x45582000), SkBits2Float(0x45be9805)); // 3458, 6099
5791 path.close();
5792 path.moveTo(SkBits2Float(0x43b60000), SkBits2Float(0x443dffd7)); // 364, 759.997f
5793 path.lineTo(SkBits2Float(0x4554b667), SkBits2Float(0x443dffd7)); // 3403.4f, 759.997f
5794 path.lineTo(SkBits2Float(0x4554b667), SkBits2Float(0x443e0029)); // 3403.4f, 760.003f
5795 path.lineTo(SkBits2Float(0x43b60000), SkBits2Float(0x443e0029)); // 364, 760.003f
5796 path.lineTo(SkBits2Float(0x43b60000), SkBits2Float(0x443dffd7)); // 364, 759.997f
5797 path.close();
5798 path.moveTo(SkBits2Float(0x4554b65d), SkBits2Float(0x45be9800)); // 3403.4f, 6099
5799 path.lineTo(SkBits2Float(0x4554b65d), SkBits2Float(0x443e0000)); // 3403.4f, 760
5800 path.lineTo(SkBits2Float(0x4554b671), SkBits2Float(0x443e0000)); // 3403.4f, 760
5801 path.lineTo(SkBits2Float(0x4554b671), SkBits2Float(0x45be9800)); // 3403.4f, 6099
5802 path.lineTo(SkBits2Float(0x4554b65d), SkBits2Float(0x45be9800)); // 3403.4f, 6099
5803 path.close();
5804 path.moveTo(SkBits2Float(0x449f4000), SkBits2Float(0x43bdffae)); // 1274, 379.997f
5805 path.lineTo(SkBits2Float(0x4554b667), SkBits2Float(0x43bdffae)); // 3403.4f, 379.997f
5806 path.lineTo(SkBits2Float(0x4554b667), SkBits2Float(0x43be0052)); // 3403.4f, 380.003f
5807 path.lineTo(SkBits2Float(0x449f4000), SkBits2Float(0x43be0052)); // 1274, 380.003f
5808 path.lineTo(SkBits2Float(0x449f4000), SkBits2Float(0x43bdffae)); // 1274, 379.997f
5809 path.close();
5810 path.moveTo(SkBits2Float(0x4554b65d), SkBits2Float(0x443e0000)); // 3403.4f, 760
5811 path.lineTo(SkBits2Float(0x4554b65d), SkBits2Float(0x43be0000)); // 3403.4f, 380
5812 path.lineTo(SkBits2Float(0x4554b671), SkBits2Float(0x43be0000)); // 3403.4f, 380
5813 path.lineTo(SkBits2Float(0x4554b671), SkBits2Float(0x443e0000)); // 3403.4f, 760
5814 path.lineTo(SkBits2Float(0x4554b65d), SkBits2Float(0x443e0000)); // 3403.4f, 760
5815 path.close();
5816 testPathOp(reporter, path1, path, kUnion_SkPathOp, filename);
5817}

◆ findFirst1()

static void findFirst1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3268 of file PathOpsOpTest.cpp.

3268 {
3269 SkPath path, pathB;
3270 path.setFillType(SkPathFillType::kWinding);
3271 path.moveTo(0,1);
3272 path.cubicTo(1,6, 5,0, 2,1);
3273 path.close();
3274 pathB.setFillType(SkPathFillType::kWinding);
3275 pathB.moveTo(0,5);
3276 pathB.cubicTo(1,2, 1,0, 6,1);
3277 pathB.close();
3278 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3279}

◆ fuzz1()

static void fuzz1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9803 of file PathOpsOpTest.cpp.

9803 {
9804 SkPath path;
9805 path.setFillType((SkPathFillType) 0);
9806path.moveTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
9807path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
9808path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
9809path.quadTo(SkBits2Float(0xffc00000), SkBits2Float(0x7f800000), SkBits2Float(0xffc00000), SkBits2Float(0x7f800000));
9810path.quadTo(SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000));
9811path.quadTo(SkBits2Float(0xff000001), SkBits2Float(0xffc00000), SkBits2Float(0xffc00000), SkBits2Float(0xffc00000));
9812path.quadTo(SkBits2Float(0xffc00000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xff000001));
9813path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xffc00000));
9814path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0xffc00000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
9815path.close();
9816
9817 SkPath path1(path);
9818 path.reset();
9819 path.setFillType((SkPathFillType) 0);
9820
9821 SkPath path2(path);
9822 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
9823}

◆ fuzz1450_0()

static void fuzz1450_0 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9873 of file PathOpsOpTest.cpp.

9873 {
9874SkPath path;
9875path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0xcf000000)); // 360, -2.14748e+09f
9876path.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
9877path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0x43800001), SkBits2Float(0x43348000), SkBits2Float(0x43800001), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, 256, 180.5f, 256, 0.707107f
9878SkPath path1(path);
9879path.reset();
9880path.moveTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140
9881path.conicTo(SkBits2Float(0x43b40005), SkBits2Float(0x458a945d), SkBits2Float(0x45610000), SkBits2Float(0x458a945d), SkBits2Float(0x3f3504f3)); // 360, 4434.55f, 3600, 4434.55f, 0.707107f
9882path.conicTo(SkBits2Float(0x45d5bfff), SkBits2Float(0x458a945d), SkBits2Float(0x45d5bfff), SkBits2Float(0x45816000), SkBits2Float(0x3f3504f3)); // 6840, 4434.55f, 6840, 4140, 0.707107f
9883path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000)); // 100, 512
9884path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000)); // 32, 16
9885path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000)); // 360, 1024
9886path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140
9887path.close();
9888SkPath path2(path);
9889testPathOpFuzz(reporter, path1, path2, kUnion_SkPathOp, filename);
9890}

◆ fuzz1450_1()

static void fuzz1450_1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9892 of file PathOpsOpTest.cpp.

9892 {
9893SkPath path;
9894path.setFillType(SkPathFillType::kEvenOdd);
9895path.moveTo(SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe)); // 1.07374e+09f, -1.07374e+09f
9896path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0xcf000000), SkBits2Float(0x43b40000), SkBits2Float(0xcf000000), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, -2.14748e+09f, 360, -2.14748e+09f, 0.707107f
9897path.lineTo(SkBits2Float(0x43348000), SkBits2Float(0x43800001)); // 180.5f, 256
9898path.lineTo(SkBits2Float(0x42000000), SkBits2Float(0x41800000)); // 32, 16
9899path.lineTo(SkBits2Float(0x42c80000), SkBits2Float(0x44000000)); // 100, 512
9900path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f
9901path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x44800000)); // 360, 1024
9902path.lineTo(SkBits2Float(0x43b40000), SkBits2Float(0x45816000)); // 360, 4140
9903path.conicTo(SkBits2Float(0x43b40005), SkBits2Float(0x458a945d), SkBits2Float(0x45610000), SkBits2Float(0x458a945d), SkBits2Float(0x3f3504f3)); // 360, 4434.55f, 3600, 4434.55f, 0.707107f
9904path.conicTo(SkBits2Float(0x45d5bfff), SkBits2Float(0x458a945d), SkBits2Float(0x45d5bfff), SkBits2Float(0x45816000), SkBits2Float(0x3f3504f3)); // 6840, 4434.55f, 6840, 4140, 0.707107f
9905path.lineTo(SkBits2Float(0x43553abd), SkBits2Float(0x440f3cbd)); // 213.229f, 572.949f
9906path.lineTo(SkBits2Float(0x43348000), SkBits2Float(0x43800001)); // 180.5f, 256
9907path.conicTo(SkBits2Float(0x4e800002), SkBits2Float(0x43800001), SkBits2Float(0x4e800002), SkBits2Float(0xce7ffffe), SkBits2Float(0x3f3504f4)); // 1.07374e+09f, 256, 1.07374e+09f, -1.07374e+09f, 0.707107f
9908path.close();
9909SkPath path1(path);
9910path.reset();
9911path.moveTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321
9912path.lineTo(SkBits2Float(0x45d5c000), SkBits2Float(0x43870000)); // 6840, 270
9913path.lineTo(SkBits2Float(0xd0a00000), SkBits2Float(0x4cbebc20)); // -2.14748e+10f, 1e+08
9914path.lineTo(SkBits2Float(0x451f7000), SkBits2Float(0x42800000)); // 2551, 64
9915path.lineTo(SkBits2Float(0x42fe0000), SkBits2Float(0x43a08000)); // 127, 321
9916path.close();
9917SkPath path2(path);
9918testPathOpFuzz(reporter, path1, path2, kUnion_SkPathOp, filename);
9919}

◆ fuzz38()

static void fuzz38 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5175 of file PathOpsOpTest.cpp.

5175 {
5176 SkPath path, pathB;
5177 path.moveTo(100.34f, 303.312f);
5178 path.lineTo(-1e+08, 303.312f);
5179 path.lineTo(102, 310.156f);
5180 path.lineTo(100.34f, 310.156f);
5181 path.lineTo(100.34f, 303.312f);
5182 path.close();
5183 testPathOpCheck(reporter, path, pathB, kUnion_SkPathOp, filename, true);
5184}
testPathOpCheck
bool testPathOpCheck(skiatest::Reporter *reporter, const SkPath &a, const SkPath &b, const SkPathOp shapeOp, const char *testName, bool checkFail)
Definition PathOpsExtendedTest.cpp:624

◆ fuzz433()

static void fuzz433 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9643 of file PathOpsOpTest.cpp.

9643 {
9644 SkPath path1, path2;
9645 path1.moveTo(100,0);
9646 path1.lineTo(60,170);
9647 path1.lineTo(-160,-110);
9648 path1.lineTo(200,0);
9649 path1.lineTo(-170,11000000000.0f);
9650 path1.close();
9651
9652 path2.moveTo(100 + 20,0 + 20);
9653 path2.lineTo(60 + 20,170 + 20);
9654 path2.lineTo(-160 + 20,-110 + 20);
9655 path2.lineTo(200 + 20,0 + 20);
9656 path2.lineTo(-170 + 20,11000000000.0f + 20);
9657 path2.close();
9658
9659 testPathOpFuzz(reporter, path1, path2, kIntersect_SkPathOp, filename);
9660}

◆ fuzz433b()

static void fuzz433b ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9662 of file PathOpsOpTest.cpp.

9662 {
9663 SkPath path1, path2;
9664 path1.setFillType(SkPathFillType::kEvenOdd);
9665 path1.moveTo(140, 40);
9666 path1.lineTo(200, 210);
9667 path1.lineTo(40, 100);
9668 path1.lineTo(240, 100);
9669 path1.lineTo(70, 1.1e+10f);
9670 path1.lineTo(140, 40);
9671 path1.close();
9672
9673 path1.setFillType(SkPathFillType::kWinding);
9674 path2.moveTo(190, 60);
9675 path2.lineTo(250, 230);
9676 path2.lineTo(90, 120);
9677 path2.lineTo(290, 120);
9678 path2.lineTo(120, 1.1e+10f);
9679 path2.lineTo(190, 60);
9680 path2.close();
9681
9682 testPathOpFuzz(reporter, path1, path2, kUnion_SkPathOp, filename);
9683}

◆ fuzz487a()

static void fuzz487a ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9685 of file PathOpsOpTest.cpp.

9685 {
9686 SkPath path;
9687 path.setFillType((SkPathFillType) 0);
9688path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9689path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
9690path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333));
9691path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc));
9692path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff));
9693path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
9694path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
9695path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000));
9696path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000));
9697path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000));
9698path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
9699path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
9700path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000));
9701path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9702path.close();
9703
9704 SkPath path1(path);
9705 path.reset();
9706 path.setFillType((SkPathFillType) 0);
9707path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9708path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
9709path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a));
9710path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a));
9711path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd));
9712path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000));
9713path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a));
9714path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333));
9715path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000));
9716path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000));
9717path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a));
9718path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334));
9719path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd));
9720path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd));
9721path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd));
9722path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334));
9723path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000));
9724path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9725path.close();
9726
9727 SkPath path2(path);
9728 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
9729}

◆ fuzz487b()

static void fuzz487b ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9731 of file PathOpsOpTest.cpp.

9731 {
9732 SkPath path;
9733 path.setFillType((SkPathFillType) 0);
9734path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9735path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
9736path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333));
9737path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc));
9738path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff));
9739path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
9740path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
9741path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000));
9742path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000));
9743path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000));
9744path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
9745path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
9746path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000));
9747path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9748path.close();
9749
9750 SkPath path1(path);
9751 path.reset();
9752 path.setFillType((SkPathFillType) 0);
9753path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9754path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
9755path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a));
9756path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a));
9757path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd));
9758path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000));
9759path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a));
9760path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333));
9761path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000));
9762path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000));
9763path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a));
9764path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334));
9765path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd));
9766path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd));
9767path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd));
9768path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334));
9769path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000));
9770path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
9771path.close();
9772
9773 SkPath path2(path);
9774 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
9775}

◆ fuzz535151()

static void fuzz535151 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9623 of file PathOpsOpTest.cpp.

9623 {
9624 SkPath one;
9625 one.setFillType(SkPathFillType::kWinding);
9626 SkPath two;
9627 two.setFillType(SkPathFillType::kWinding);
9628 two.moveTo(0, 0);
9629 two.lineTo(0, 50);
9630 two.lineTo(4.29497e+09f, 50);
9631 testPathOpFuzz(reporter, one, two, kIntersect_SkPathOp, filename);
9632}
SK_OPTS_NS::two
SI F two(F x)
Definition SkRasterPipeline_opts.h:2172

◆ fuzz714()

static void fuzz714 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9777 of file PathOpsOpTest.cpp.

9777 {
9778 SkPath path;
9779 path.setFillType((SkPathFillType) 1);
9780path.moveTo(SkBits2Float(0x430c0000), SkBits2Float(0x42200000));
9781path.lineTo(SkBits2Float(0x43480000), SkBits2Float(0x43520000));
9782path.lineTo(SkBits2Float(0x42200000), SkBits2Float(0x42c80000));
9783path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x42c80000)); // 2.22222e+022f
9784path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x43520000)); // 2.22222e+022f
9785path.lineTo(SkBits2Float(0x430c0000), SkBits2Float(0x42200000));
9786path.close();
9787
9788 SkPath path1(path);
9789 path.reset();
9790 path.setFillType((SkPathFillType) 0);
9791path.moveTo(SkBits2Float(0x43200000), SkBits2Float(0x42700000));
9792path.lineTo(SkBits2Float(0x435c0000), SkBits2Float(0x43660000));
9793path.lineTo(SkBits2Float(0x42700000), SkBits2Float(0x42f00000));
9794path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x42f00000)); // 2.22222e+022f
9795path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x43660000)); // 2.22222e+022f
9796path.lineTo(SkBits2Float(0x43200000), SkBits2Float(0x42700000));
9797path.close();
9798
9799 SkPath path2(path);
9800 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
9801}

◆ fuzz753_91()

static void fuzz753_91 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9826 of file PathOpsOpTest.cpp.

9826 {
9827 SkPath path;
9828 path.setFillType((SkPathFillType) 0);
9829path.moveTo(SkBits2Float(0x42910000), SkBits2Float(0x00000000)); // 72.5f, 0
9830path.lineTo(SkBits2Float(0x42166668), SkBits2Float(0x00000000)); // 37.6f, 0
9831path.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
9832path.lineTo(SkBits2Float(0x41840004), SkBits2Float(0xc291cccd)); // 16.5f, -72.9f
9833path.lineTo(SkBits2Float(0x42fb6668), SkBits2Float(0x42c73334)); // 125.7f, 99.6f
9834path.lineTo(SkBits2Float(0x43646668), SkBits2Float(0x43880ccd)); // 228.4f, 272.1f
9835
9836 SkPath path1(path);
9837 path.reset();
9838 path.setFillType((SkPathFillType) 0);
9839path.moveTo(SkBits2Float(0x428bf702), SkBits2Float(0xcf223cbf)); // 69.9824f, -2.72189e+09f
9840path.lineTo(SkBits2Float(0x42112d68), SkBits2Float(0xcf223cbf)); // 36.2943f, -2.72189e+09f
9841path.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
9842path.lineTo(SkBits2Float(0x424a99e0), SkBits2Float(0xcf223cc0)); // 50.6503f, -2.72189e+09f
9843path.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
9844path.lineTo(SkBits2Float(0x40f8fbe0), SkBits2Float(0xcf223cc0)); // 7.78075f, -2.72189e+09f
9845
9846 SkPath path2(path);
9847 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
9848}

◆ fuzz754434_1()

static void fuzz754434_1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 12363 of file PathOpsOpTest.cpp.

12363 {
12364 SkPath path;
12365 path.setFillType((SkPathFillType) 0);
12366path.setFillType(SkPathFillType::kWinding);
12367
12368 SkPath path1(path);
12369 path.reset();
12370 path.setFillType((SkPathFillType) 0);
12371path.setFillType(SkPathFillType::kWinding);
12372path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12373path.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
12374path.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
12375path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00faf6f6)); // -1.71467e+38f, 2.30475e-38f
12376path.moveTo(SkBits2Float(0x60576bfa), SkBits2Float(0x006df653)); // 6.20911e+19f, 1.00984e-38f
12377path.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
12378
12379 SkPath path2(path);
12380 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
12381}

◆ fuzz754434_2()

static void fuzz754434_2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 12383 of file PathOpsOpTest.cpp.

12383 {
12384 SkPath path;
12385 path.setFillType((SkPathFillType) 1);
12386path.setFillType(SkPathFillType::kEvenOdd);
12387path.moveTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0
12388path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf66e5600)); // 0, -1.20851e+33f
12389path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf629168b)); // 0, -8.57378e+32f
12390path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12391path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0
12392path.close();
12393
12394 SkPath path1(path);
12395 path.reset();
12396 path.setFillType((SkPathFillType) 0);
12397path.setFillType(SkPathFillType::kWinding);
12398path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12399path.lineTo(SkBits2Float(0x03e8f6f6), SkBits2Float(0xf7060000)); // 1.36924e-36f, -2.71784e+33f
12400path.lineTo(SkBits2Float(0x4ff6f6f6), SkBits2Float(0x3e3e3e2a)); // 8.28676e+09f, 0.185784f
12401path.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
12402
12403 SkPath path2(path);
12404 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
12405}

◆ fuzz754434_3()

static void fuzz754434_3 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 12407 of file PathOpsOpTest.cpp.

12407 {
12408 SkPath path;
12409 path.setFillType((SkPathFillType) 0);
12410path.setFillType(SkPathFillType::kWinding);
12411
12412 SkPath path1(path);
12413 path.reset();
12414 path.setFillType((SkPathFillType) 0);
12415path.setFillType(SkPathFillType::kWinding);
12416path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12417path.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
12418path.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
12419path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00faf6f6)); // -1.71467e+38f, 2.30475e-38f
12420path.moveTo(SkBits2Float(0x60576bfa), SkBits2Float(0x006df653)); // 6.20911e+19f, 1.00984e-38f
12421path.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
12422
12423 SkPath path2(path);
12424 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
12425}

◆ fuzz754434_4()

static void fuzz754434_4 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 12427 of file PathOpsOpTest.cpp.

12427 {
12428 SkPath path;
12429 path.setFillType((SkPathFillType) 1);
12430path.setFillType(SkPathFillType::kEvenOdd);
12431path.moveTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0
12432path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf66e5600)); // 0, -1.20851e+33f
12433path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf629168b)); // 0, -8.57378e+32f
12434path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12435path.lineTo(SkBits2Float(0xff00ff56), SkBits2Float(0x00000000)); // -1.71467e+38f, 0
12436path.close();
12437
12438 SkPath path1(path);
12439 path.reset();
12440 path.setFillType((SkPathFillType) 0);
12441path.setFillType(SkPathFillType::kWinding);
12442path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12443path.lineTo(SkBits2Float(0x03e8f6f6), SkBits2Float(0xf7060000)); // 1.36924e-36f, -2.71784e+33f
12444path.lineTo(SkBits2Float(0x4ff6f6f6), SkBits2Float(0x3e3e3e2a)); // 8.28676e+09f, 0.185784f
12445path.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
12446
12447 SkPath path2(path);
12448 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
12449}

◆ fuzz763_10()

static void fuzz763_10 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10401 of file PathOpsOpTest.cpp.

10401 {
10402 SkPath path;
10403 path.setFillType((SkPathFillType) 1);
10404path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 0, 4.03114e+24f
10405path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10406path.quadTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 6.14991e+25f, 0, 0, 6.14991e+25f
10407path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 0, 4.03114e+24f
10408path.close();
10409
10410 SkPath path1(path);
10411 path.reset();
10412 path.setFillType((SkPathFillType) 0);
10413path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10414path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x2a8c8f55)); // 4.87407e+16f, 2.49685e-13f
10415path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10416path.close();
10417path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
10418path.conicTo(SkBits2Float(0x682d2fed), SkBits2Float(0x755b6829), SkBits2Float(0x5b292d2b), SkBits2Float(0xc92a8c55), SkBits2Float(0x081f2a21)); // 3.27141e+24f, 2.78131e+32f, 4.76189e+16f, -698565, 4.78968e-34f
10419path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
10420path.close();
10421path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
10422path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a29)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121588
10423path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
10424path.close();
10425path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
10426path.quadTo(SkBits2Float(0x6829682d), SkBits2Float(0x292d555b), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a29)); // 3.20001e+24f, 3.84878e-14f, 2.49282e-13f, 4.78969e-34f
10427path.conicTo(SkBits2Float(0x6a497b19), SkBits2Float(0x218ced7a), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x47ed3a7a)); // 6.08939e+25f, 9.54963e-19f, 4.7323e-37f, 5.63611e+25f, 121461
10428path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
10429path.close();
10430path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
10431path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3a21df), SkBits2Float(0x2728282a), SkBits2Float(0x8a3a2129)); // 9.4456e-15f, -8.96194e-33f, 2.33365e-15f, -8.96181e-33f
10432path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3a3ac2b3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.000712435f, 1.50241e-13f, -1.38859e-25f
10433path.lineTo(SkBits2Float(0x272a802a), SkBits2Float(0x2a8c2d29)); // 2.36617e-15f, 2.49003e-13f
10434path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
10435path.close();
10436path.moveTo(SkBits2Float(0x4f9a3a29), SkBits2Float(0x3ab38a28)); // 5.17501e+09f, 0.00136978f
10437path.quadTo(SkBits2Float(0xc368305b), SkBits2Float(0x5b296855), SkBits2Float(0x2d8c5568), SkBits2Float(0x1f2a2172)); // -232.189f, 4.7684e+16f, 1.59541e-11f, 3.60266e-20f
10438path.lineTo(SkBits2Float(0x29c00321), SkBits2Float(0x5b4b7b13)); // 8.52706e-14f, 5.72747e+16f
10439
10440 SkPath path2(path);
10441 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
10442}

◆ fuzz763_11()

static void fuzz763_11 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10444 of file PathOpsOpTest.cpp.

10444 {
10445 SkPath path;
10446 path.setFillType((SkPathFillType) 0);
10447
10448 SkPath path1(path);
10449 path.reset();
10450 path.setFillType((SkPathFillType) 0);
10451path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
10452path.moveTo(SkBits2Float(0x2a0f312a), SkBits2Float(0xc0032108)); // 1.2718e-13f, -2.04889f
10453path.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
10454path.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
10455path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f
10456path.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
10457path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f
10458path.close();
10459path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0x70682955)); // 3.48239e+24f, 2.87402e+29f
10460path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
10461path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10462path.lineTo(SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a281a4f)); // 0.00105461f, -8.09385e-33f
10463path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x2a812a3b), SkBits2Float(0x2a552927)); // 2.25206e-21f, 300.343f, 2.29443e-13f, 1.89325e-13f
10464path.quadTo(SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x203a3b27), SkBits2Float(0x22c5381f)); // 0.00241343f, 3.71093e-14f, 1.57744e-19f, 5.34564e-18f
10465path.moveTo(SkBits2Float(0x5d27ec2a), SkBits2Float(0x705921c2)); // 7.56256e+17f, 2.68796e+29f
10466path.quadTo(SkBits2Float(0x102a5152), SkBits2Float(0x5b2dd912), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 3.35892e-29f, 4.89338e+16f, 4.03114e+24f, 1.50617e+13f
10467path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032127)); // 3.60396e-20f, -2.0489f
10468path.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
10469path.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
10470path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
10471path.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
10472path.lineTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
10473path.close();
10474path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
10475path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x2a21211f)); // 4.85282e+16f, 1.43112e-13f
10476path.lineTo(SkBits2Float(0x03552a8c), SkBits2Float(0x6a4f7b28)); // 6.26439e-37f, 6.27073e+25f
10477path.conicTo(SkBits2Float(0x2347ed93), SkBits2Float(0x282a3a21), SkBits2Float(0x3adf2128), SkBits2Float(0x4f1a3a8a), SkBits2Float(0x3ab38a28)); // 1.08381e-17f, 9.4495e-15f, 0.00170234f, 2.58753e+09f, 0.00136978f
10478path.lineTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
10479path.close();
10480path.moveTo(SkBits2Float(0x2a395b2d), SkBits2Float(0xf0682955)); // 1.64629e-13f, -2.87402e+29f
10481path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x262a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 5.91556e-16f, 0.000649768f
10482path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f
10483path.conicTo(SkBits2Float(0x371f203a), SkBits2Float(0xc52a22c4), SkBits2Float(0xc25d27ec), SkBits2Float(0x3a705921), SkBits2Float(0x5210513a)); // 9.48464e-06f, -2722.17f, -55.289f, 0.000916855f, 1.5496e+11f
10484path.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
10485path.moveTo(SkBits2Float(0x682d6829), SkBits2Float(0x29685555)); // 3.27556e+24f, 5.15884e-14f
10486path.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
10487path.quadTo(SkBits2Float(0x2d685568), SkBits2Float(0x5568295b), SkBits2Float(0x2a552d29), SkBits2Float(0x295b2d27)); // 1.32066e-11f, 1.5954e+13f, 1.89339e-13f, 4.86669e-14f
10488path.lineTo(SkBits2Float(0x682d6829), SkBits2Float(0x29685555)); // 3.27556e+24f, 5.15884e-14f
10489path.close();
10490
10491 SkPath path2(path);
10492 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
10493}

◆ fuzz763_12()

static void fuzz763_12 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10495 of file PathOpsOpTest.cpp.

10495 {
10496 SkPath path;
10497 path.setFillType((SkPathFillType) 1);
10498path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10499path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a29082a)); // 0, 5.10868e+25f
10500path.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
10501path.conicTo(SkBits2Float(0x67aedf99), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x3f801112)); // 1.65163e+24f, 0, 0, 0, 1.00052f
10502path.close();
10503path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10504path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 6.14991e+25f, 0, 0, 4.03114e+24f, 1.50617e+13f
10505path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f
10506path.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
10507path.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
10508path.cubicTo(SkBits2Float(0x679158b0), SkBits2Float(0x00000000), SkBits2Float(0x67531e34), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 1.37276e+24f, 0, 9.96976e+23f, 0, 0, 0
10509path.close();
10510
10511 SkPath path1(path);
10512 path.reset();
10513 path.setFillType((SkPathFillType) 0);
10514path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10515path.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
10516path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10517path.close();
10518path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10519path.lineTo(SkBits2Float(0x3a6821df), SkBits2Float(0x2a8c3a8a)); // 0.000885514f, 2.49096e-13f
10520path.moveTo(SkBits2Float(0x29272a1d), SkBits2Float(0xb03a2a55)); // 3.7118e-14f, -6.77266e-10f
10521path.moveTo(SkBits2Float(0x20213b1e), SkBits2Float(0xc5272927)); // 1.36568e-19f, -2674.57f
10522path.quadTo(SkBits2Float(0xc422373b), SkBits2Float(0xec2a201f), SkBits2Float(0x21c25d27), SkBits2Float(0x523a7059)); // -648.863f, -8.22676e+26f, 1.31706e-18f, 2.00187e+11f
10523path.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
10524path.moveTo(SkBits2Float(0x68556809), SkBits2Float(0x555b2d29)); // 4.03113e+24f, 1.50617e+13f
10525path.moveTo(SkBits2Float(0x1f2a212a), SkBits2Float(0x2d032108)); // 3.60263e-20f, 7.45382e-12f
10526path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x2a552d29)); // 4.03114e+24f, 1.89339e-13f
10527path.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
10528
10529 SkPath path2(path);
10530 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
10531}

◆ fuzz763_13()

static void fuzz763_13 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10533 of file PathOpsOpTest.cpp.

10533 {
10534 SkPath path;
10535 path.setFillType((SkPathFillType) 1);
10536
10537 SkPath path1(path);
10538 path.reset();
10539 path.setFillType((SkPathFillType) 0);
10540path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
10541path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0x3adf2128), SkBits2Float(0x4f1a3a8a)); // 6.14991e+25f, 75739, 9.4495e-15f, 0.00170234f, 2.58753e+09f
10542path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
10543path.close();
10544path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
10545path.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
10546path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
10547path.close();
10548path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
10549path.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
10550path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x68295b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.19905e+24f
10551path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f
10552path.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
10553path.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
10554path.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
10555path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
10556path.close();
10557path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
10558path.lineTo(SkBits2Float(0x5b2d6829), SkBits2Float(0x212a8c55)); // 4.88097e+16f, 5.7784e-19f
10559path.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
10560path.lineTo(SkBits2Float(0x68295b68), SkBits2Float(0x2d296855)); // 3.19906e+24f, 9.6297e-12f
10561path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
10562path.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
10563path.quadTo(SkBits2Float(0x6028282a), SkBits2Float(0x68292ddf), SkBits2Float(0x5b2d555b), SkBits2Float(0x68556829)); // 4.84679e+19f, 3.1957e+24f, 4.8789e+16f, 4.03114e+24f
10564
10565 SkPath path2(path);
10566 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
10567}

◆ fuzz763_14()

static void fuzz763_14 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10569 of file PathOpsOpTest.cpp.

10569 {
10570 SkPath path;
10571 path.setFillType((SkPathFillType) 0);
10572
10573 SkPath path1(path);
10574 path.reset();
10575 path.setFillType((SkPathFillType) 0);
10576path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0xf45b2d29)); // 4.03114e+24f, -6.94598e+31f
10577path.moveTo(SkBits2Float(0x1f2a302a), SkBits2Float(0xc8032108)); // 3.60387e-20f, -134276
10578path.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
10579
10580 SkPath path2(path);
10581 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
10582}

◆ fuzz763_15()

static void fuzz763_15 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10584 of file PathOpsOpTest.cpp.

10584 {
10585 SkPath path;
10586 path.setFillType((SkPathFillType) 1);
10587
10588 SkPath path1(path);
10589 path.reset();
10590 path.setFillType((SkPathFillType) 0);
10591path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55)); // 4.76191e+16f, 5.7784e-19f
10592path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f
10593path.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
10594path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f
10595path.close();
10596path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f
10597path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0xdf218a28), SkBits2Float(0x4f1a3a3a)); // 6.14991e+25f, 75739, 9.4495e-15f, -1.16402e+19f, 2.58751e+09f
10598path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x283ac221), SkBits2Float(0xe6432a29), SkBits2Float(0x2a96812b)); // 0.00136978f, 1.03672e-14f, -2.3041e+23f, 2.6735e-13f
10599path.lineTo(SkBits2Float(0x5529272a), SkBits2Float(0x1eb03a2a)); // 1.16241e+13f, 1.86588e-20f
10600path.conicTo(SkBits2Float(0x2a272021), SkBits2Float(0x3ac52729), SkBits2Float(0xc422313b), SkBits2Float(0xec2a201f), SkBits2Float(0x21c25d27)); // 1.48437e-13f, 0.00150416f, -648.769f, -8.22676e+26f, 1.31706e-18f
10601path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a6b7bc4)); // 4.7323e-37f, 7.11705e+25f
10602path.close();
10603path.moveTo(SkBits2Float(0x1051523a), SkBits2Float(0xd912102a)); // 4.12813e-29f, -2.56957e+15f
10604path.close();
10605path.moveTo(SkBits2Float(0x1051523a), SkBits2Float(0xd912102a)); // 4.12813e-29f, -2.56957e+15f
10606path.quadTo(SkBits2Float(0xc82763e7), SkBits2Float(0x2927b029), SkBits2Float(0x295b2d27), SkBits2Float(0x2d685568)); // -171408, 3.72342e-14f, 4.86669e-14f, 1.32066e-11f
10607path.moveTo(SkBits2Float(0x68556809), SkBits2Float(0x8c555b2d)); // 4.03113e+24f, -1.64364e-31f
10608path.moveTo(SkBits2Float(0x081f2a21), SkBits2Float(0x252d0321)); // 4.78968e-34f, 1.50064e-16f
10609path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x5b2df068)); // 1.59583e+13f, 4.89595e+16f
10610path.quadTo(SkBits2Float(0x2a1f2a8c), SkBits2Float(0x21482a21), SkBits2Float(0x4b7bc003), SkBits2Float(0x8ced3a6a)); // 1.41368e-13f, 6.78184e-19f, 1.64987e+07f, -3.65508e-31f
10611path.moveTo(SkBits2Float(0x21481f21), SkBits2Float(0x4b7bc003)); // 6.78038e-19f, 1.64987e+07f
10612path.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
10613path.lineTo(SkBits2Float(0x21481f21), SkBits2Float(0x4b7bc003)); // 6.78038e-19f, 1.64987e+07f
10614path.close();
10615path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
10616path.conicTo(SkBits2Float(0x682d2fed), SkBits2Float(0x755b6829), SkBits2Float(0x5b292d2b), SkBits2Float(0xc92a8c55), SkBits2Float(0x081f2a21)); // 3.27141e+24f, 2.78131e+32f, 4.76189e+16f, -698565, 4.78968e-34f
10617path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
10618path.close();
10619path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
10620path.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
10621path.quadTo(SkBits2Float(0x6829682d), SkBits2Float(0x292d555b), SkBits2Float(0x292a8c55), SkBits2Float(0x21081f2a)); // 3.20001e+24f, 3.84878e-14f, 3.78693e-14f, 4.61198e-19f
10622path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x218ced7a), SkBits2Float(0x0321081f), SkBits2Float(0x6a3a7bc0), SkBits2Float(0x47ed3a7a)); // 6.14991e+25f, 9.54963e-19f, 4.7323e-37f, 5.63611e+25f, 121461
10623path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
10624path.close();
10625path.moveTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
10626path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3a21df), SkBits2Float(0x2728282a), SkBits2Float(0x8a3a21df)); // 9.4456e-15f, -8.96194e-33f, 2.33365e-15f, -8.96194e-33f
10627path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3a3ac2b3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.000712435f, 1.50241e-13f, -1.38859e-25f
10628path.lineTo(SkBits2Float(0x272a802a), SkBits2Float(0x2a8c2d29)); // 2.36617e-15f, 2.49003e-13f
10629path.lineTo(SkBits2Float(0xc021211f), SkBits2Float(0x6a4b7b03)); // -2.51765f, 6.14982e+25f
10630path.close();
10631path.moveTo(SkBits2Float(0x4f9a3a29), SkBits2Float(0x3ab38a28)); // 5.17501e+09f, 0.00136978f
10632path.quadTo(SkBits2Float(0xc368305b), SkBits2Float(0x5b296855), SkBits2Float(0x2d8c5568), SkBits2Float(0x1f2a2172)); // -232.189f, 4.7684e+16f, 1.59541e-11f, 3.60266e-20f
10633path.lineTo(SkBits2Float(0x29c00321), SkBits2Float(0x5b4b7b13)); // 8.52706e-14f, 5.72747e+16f
10634
10635 SkPath path2(path);
10636 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
10637}

◆ fuzz763_16()

static void fuzz763_16 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10639 of file PathOpsOpTest.cpp.

10639 {
10640 SkPath path;
10641 path.setFillType((SkPathFillType) 0);
10642
10643 SkPath path1(path);
10644 path.reset();
10645 path.setFillType((SkPathFillType) 0);
10646path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
10647path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
10648path.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
10649path.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
10650path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
10651path.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
10652path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
10653path.close();
10654path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
10655path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
10656path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10657path.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
10658path.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
10659path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
10660path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 1.31626e+28f, 4.7323e-37f, 6.14991e+25f, 75739
10661path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
10662path.close();
10663path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
10664path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f
10665path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
10666path.close();
10667path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
10668path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
10669path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
10670path.close();
10671path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
10672path.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
10673path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2769), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21512727)); // 2.22225e-15f, 0.000713936f, -732.486f, -1.90686e+27f, 7.08638e-19f
10674path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
10675path.close();
10676path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
10677path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
10678path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0xc0032108)); // 3.60404e-20f, -2.04889f
10679path.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
10680path.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
10681path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
10682path.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
10683path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
10684path.close();
10685path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
10686path.lineTo(SkBits2Float(0x555b6829), SkBits2Float(0x6c212a8c)); // 1.50775e+13f, 7.79352e+26f
10687path.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
10688path.lineTo(SkBits2Float(0x8c558c55), SkBits2Float(0x212a1f2a)); // -1.64512e-31f, 5.76395e-19f
10689
10690 SkPath path2(path);
10691 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
10692}

◆ fuzz763_17()

static void fuzz763_17 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10694 of file PathOpsOpTest.cpp.

10694 {
10695 SkPath path;
10696 path.setFillType((SkPathFillType) 0);
10697
10698 SkPath path1(path);
10699 path.reset();
10700 path.setFillType((SkPathFillType) 0);
10701path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
10702path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
10703path.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
10704path.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
10705path.moveTo(SkBits2Float(0x6835282d), SkBits2Float(0xf0682955)); // 3.42196e+24f, -2.87402e+29f
10706path.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
10707path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
10708path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10709path.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
10710path.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
10711path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10712path.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
10713path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
10714path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
10715path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10716path.close();
10717path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10718path.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
10719path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0x16c52a22), SkBits2Float(0x515d27ec)); // 2.22225e-15f, 0.000713932f, -732.486f, 3.18537e-25f, 5.93661e+10f
10720path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10721path.close();
10722path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
10723path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
10724path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
10725path.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
10726path.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
10727path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10728path.lineTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x2a212a1f)); // 2.49282e-13f, 1.43143e-13f
10729path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10730path.close();
10731path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10732path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x2a1f08c0)); // -1.31678e-31f, 1.41251e-13f
10733path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10734path.close();
10735path.moveTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f
10736path.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
10737path.lineTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f
10738path.close();
10739path.moveTo(SkBits2Float(0x2a8cef55), SkBits2Float(0x68295b2d)); // 2.50351e-13f, 3.19905e+24f
10740path.lineTo(SkBits2Float(0x6ac07b2a), SkBits2Float(0x395b2d7a)); // 1.16348e+26f, 0.000209024f
10741
10742 SkPath path2(path);
10743 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
10744}

◆ fuzz763_18()

static void fuzz763_18 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10746 of file PathOpsOpTest.cpp.

10746 {
10747 SkPath path;
10748 path.setFillType((SkPathFillType) 0);
10749
10750 SkPath path1(path);
10751 path.reset();
10752 path.setFillType((SkPathFillType) 0);
10753path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
10754path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
10755path.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
10756path.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
10757path.moveTo(SkBits2Float(0x6835282d), SkBits2Float(0xf0682955)); // 3.42196e+24f, -2.87402e+29f
10758path.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
10759path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
10760path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10761path.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
10762path.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
10763path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10764path.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
10765path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
10766path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
10767path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10768path.close();
10769path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10770path.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
10771path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0x16c52a22), SkBits2Float(0x515d27ec)); // 2.22225e-15f, 0.000713932f, -732.486f, 3.18537e-25f, 5.93661e+10f
10772path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10773path.close();
10774path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
10775path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
10776path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
10777path.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
10778path.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
10779path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10780path.lineTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x2a212a1f)); // 2.49282e-13f, 1.43143e-13f
10781path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10782path.close();
10783path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10784path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x2a1f08c0)); // -1.31678e-31f, 1.41251e-13f
10785
10786path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
10787path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
10788path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
10789path.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
10790path.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
10791path.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
10792
10793 SkPath path2(path);
10794 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
10795}

◆ fuzz763_19()

static void fuzz763_19 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10797 of file PathOpsOpTest.cpp.

10797 {
10798 SkPath path;
10799 path.setFillType((SkPathFillType) 1);
10800
10801 SkPath path1(path);
10802 path.reset();
10803 path.setFillType((SkPathFillType) 0);
10804path.moveTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003)); // 4.61198e-19f, 1.64987e+07f
10805path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x69555b2d)); // 9.43289e-15f, 1.61207e+25f
10806path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
10807path.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
10808path.moveTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
10809path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10810path.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
10811path.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
10812path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
10813path.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
10814path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
10815path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
10816path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
10817path.close();
10818path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
10819path.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
10820path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21515d27)); // 2.22225e-15f, 0.000713932f, -732.486f, -1.90686e+27f, 7.09352e-19f
10821path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
10822path.close();
10823path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
10824path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
10825path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
10826path.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
10827path.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
10828path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10829path.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
10830path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10831path.close();
10832path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10833path.lineTo(SkBits2Float(0x555b2c29), SkBits2Float(0x6c212a8c)); // 1.50614e+13f, 7.79352e+26f
10834path.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
10835path.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
10836path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10837path.close();
10838path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10839path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x1f2128c0)); // -1.31678e-31f, 3.41268e-20f
10840path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10841path.close();
10842
10843 SkPath path2(path);
10844 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
10845}

◆ fuzz763_1a()

static void fuzz763_1a ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10123 of file PathOpsOpTest.cpp.

10123 {
10124 SkPath path;
10125 path.setFillType((SkPathFillType) 0);
10126 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10127 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
10128
10129 SkPath path1(path);
10130 path.reset();
10131 path.setFillType((SkPathFillType) 0);
10132 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10133 path.quadTo(SkBits2Float(0x5559a419), SkBits2Float(0x59d55928), SkBits2Float(0xbd595959), SkBits2Float(0x3f3f3f09)); // 1.49562e+13f, 7.50652e+15f, -0.0530637f, 0.747056f
10134 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0x3f3f3f3f)); // 0.747059f, 0.747059f
10135 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f
10136 path.lineTo(SkBits2Float(0x09090909), SkBits2Float(0x3038d509)); // 1.6495e-33f, 6.72416e-10f
10137 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
10138 path.lineTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f
10139 path.close();
10140 path.moveTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f
10141 path.lineTo(SkBits2Float(0x38d57f4b), SkBits2Float(0x59597f4b)); // 0.000101803f, 3.82625e+15f
10142 path.lineTo(SkBits2Float(0x3f3f3f3f), SkBits2Float(0xff3f3f3f)); // 0.747059f, -2.54211e+38f
10143 path.close();
10144 path.moveTo(SkBits2Float(0x384700ff), SkBits2Float(0x0108804b)); // 4.74462e-05f, 2.50713e-38f
10145
10146 SkPath path2(path);
10147 testPathOpFuzz(reporter, path1, path2, (SkPathOp)0, filename);
10148}

◆ fuzz763_1b()

static void fuzz763_1b ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10100 of file PathOpsOpTest.cpp.

10100 {
10101 SkPath path;
10102 path.setFillType((SkPathFillType) 0);
10103 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10104 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
10105 path.lineTo(SkBits2Float(0xda1905ed), SkBits2Float(0x3c05fbfb)); // -1.0768e+16f, 0.00817775f
10106 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
10107
10108 SkPath path1(path);
10109 path.reset();
10110 path.setFillType((SkPathFillType) 0);
10111 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10112 path.quadTo(SkBits2Float(0x3c3c3c3c), SkBits2Float(0xfa253c3c), SkBits2Float(0xfefa00d3), SkBits2Float(0x25fad9df)); // 0.011489f, -2.14488e+35f, -1.66156e+38f, 4.35157e-16f
10113 path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10114 path.close();
10115 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10116 path.lineTo(SkBits2Float(0x8dfefa00), SkBits2Float(0xf0f9fad9)); // -1.57141e-30f, -6.1892e+29f
10117 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
10118
10119 SkPath path2(path);
10120 testPathOpFuzz(reporter, path1, path2, (SkPathOp)2, filename);
10121}

◆ fuzz763_1c()

static void fuzz763_1c ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10082 of file PathOpsOpTest.cpp.

10082 {
10083 SkPath path;
10084 path.setFillType((SkPathFillType) 0);
10085
10086 SkPath path1(path);
10087 path.reset();
10088 path.setFillType((SkPathFillType) 0);
10089 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10090 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
10091 path.moveTo(SkBits2Float(0x000010a1), SkBits2Float(0x19312000)); // 5.96533e-42f, 9.15715e-24f
10092 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
10093 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
10094
10095 SkPath path2(path);
10096 testPathOpFuzz(reporter, path1, path2, (SkPathOp)4, filename);
10097}

◆ fuzz763_2()

static void fuzz763_2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10042 of file PathOpsOpTest.cpp.

10042 {
10043 SkPath path;
10044 path.setFillType((SkPathFillType) 1);
10045
10046 SkPath path1(path);
10047 path.reset();
10048 path.setFillType((SkPathFillType) 0);
10049path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10050path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f
10051path.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
10052path.lineTo(SkBits2Float(0x081f2ad7), SkBits2Float(0x7bc00321)); // 4.78977e-34f, 1.99397e+36f
10053path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
10054path.quadTo(SkBits2Float(0x4f1a3a8a), SkBits2Float(0x3ab38a28), SkBits2Float(0x29283ac2), SkBits2Float(0x962be62a)); // 2.58753e+09f, 0.00136978f, 3.73545e-14f, -1.38859e-25f
10055path.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
10056path.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
10057path.lineTo(SkBits2Float(0x29292727), SkBits2Float(0x21475b3b)); // 3.75595e-14f, 6.75446e-19f
10058path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
10059path.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
10060path.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
10061path.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
10062path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21)); // 2.50338e-13f, 4.61198e-19f
10063path.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
10064path.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
10065path.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
10066path.quadTo(SkBits2Float(0x29210f21), SkBits2Float(0x282a085d), SkBits2Float(0xc2ab2127), SkBits2Float(0xa6800028)); // 3.57623e-14f, 9.43871e-15f, -85.5648f, -8.88183e-16f
10067path.lineTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
10068path.close();
10069path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
10070path.quadTo(SkBits2Float(0x216a2770), SkBits2Float(0x2ab73b28), SkBits2Float(0x4b28f427), SkBits2Float(0x283b5b28)); // 7.93345e-19f, 3.25484e-13f, 1.10726e+07f, 1.04004e-14f
10071path.lineTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
10072path.close();
10073path.moveTo(SkBits2Float(0x2a3a2147), SkBits2Float(0xdf212828)); // 1.65317e-13f, -1.16126e+19f
10074path.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
10075path.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
10076
10077 SkPath path2(path);
10078 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
10079}

◆ fuzz763_20()

static void fuzz763_20 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10847 of file PathOpsOpTest.cpp.

10847 {
10848 SkPath path;
10849 path.setFillType((SkPathFillType) 0);
10850
10851 SkPath path1(path);
10852 path.reset();
10853 path.setFillType((SkPathFillType) 0);
10854path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
10855path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
10856path.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
10857path.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
10858path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
10859path.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
10860path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
10861path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10862path.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
10863path.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
10864path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10865path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321182a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 1.31626e+28f, 4.73414e-37f, 6.14991e+25f, 75739
10866path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10867path.close();
10868path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10869path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f
10870path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10871path.close();
10872path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10873path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
10874path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10875path.close();
10876path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10877path.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
10878path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2769), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x51282727)); // 2.22225e-15f, 0.000713936f, -732.486f, -1.90686e+27f, 4.51382e+10f
10879path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
10880path.close();
10881path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
10882path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x8c555b2d)); // 4.03114e+24f, -1.64364e-31f
10883path.moveTo(SkBits2Float(0x081f2a31), SkBits2Float(0xc0032921)); // 4.78969e-34f, -2.04939f
10884path.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
10885path.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
10886path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10887path.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
10888path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10889path.close();
10890path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10891path.lineTo(SkBits2Float(0x555b6829), SkBits2Float(0x6c212a8c)); // 1.50775e+13f, 7.79352e+26f
10892path.lineTo(SkBits2Float(0x5b2d7a6a), SkBits2Float(0xf0556830)); // 4.88298e+16f, -2.64185e+29f
10893path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10894path.close();
10895path.moveTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10896path.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
10897path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x212128c0)); // -1.31678e-31f, 5.46029e-19f
10898path.lineTo(SkBits2Float(0x68395b2d), SkBits2Float(0xf0682955)); // 3.50128e+24f, -2.87402e+29f
10899path.close();
10900
10901 SkPath path2(path);
10902 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
10903}

◆ fuzz763_21()

static void fuzz763_21 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10905 of file PathOpsOpTest.cpp.

10905 {
10906 SkPath path;
10907 path.setFillType((SkPathFillType) 1);
10908path.moveTo(SkBits2Float(0x6828c6f9), SkBits2Float(0x6614dc9e)); // 3.18811e+24f, 1.75745e+23f
10909path.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
10910path.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
10911path.lineTo(SkBits2Float(0x6828c6f9), SkBits2Float(0x6614dc9e)); // 3.18811e+24f, 1.75745e+23f
10912path.close();
10913path.moveTo(SkBits2Float(0x68226c73), SkBits2Float(0x660bd15e)); // 3.0681e+24f, 1.65068e+23f
10914path.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
10915path.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
10916path.lineTo(SkBits2Float(0x6828d720), SkBits2Float(0x6604a1a2)); // 3.1893e+24f, 1.56583e+23f
10917path.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
10918path.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
10919path.close();
10920path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f
10921path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f
10922path.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
10923path.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
10924path.close();
10925path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f
10926path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f
10927path.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
10928path.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
10929path.conicTo(SkBits2Float(0x68295b21), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x492bb324)); // 3.19904e+24f, 0, 0, 0, 703282
10930path.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
10931path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68156829)); // 0, 2.82222e+24f
10932path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f
10933path.lineTo(SkBits2Float(0x673918f3), SkBits2Float(0x681b0f5f)); // 8.74098e+23f, 2.929e+24f
10934path.lineTo(SkBits2Float(0x67391759), SkBits2Float(0x681b0fae)); // 8.74068e+23f, 2.92902e+24f
10935path.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
10936path.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
10937path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f
10938path.close();
10939
10940 SkPath path1(path);
10941 path.reset();
10942 path.setFillType((SkPathFillType) 0);
10943
10944 SkPath path2(path);
10945 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
10946}

◆ fuzz763_22()

static void fuzz763_22 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10948 of file PathOpsOpTest.cpp.

10948 {
10949 SkPath path;
10950 path.setFillType((SkPathFillType) 1);
10951path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x68295b2d)); // 0, 3.19905e+24f
10952path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10953path.lineTo(SkBits2Float(0x6a3a7bc0), SkBits2Float(0x00000000)); // 5.63611e+25f, 0
10954path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a034b21)); // 0, 3.9681e+25f
10955path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68295b2d)); // 0, 3.19905e+24f
10956path.close();
10957path.moveTo(SkBits2Float(0x6617da56), SkBits2Float(0x00000000)); // 1.79276e+23f, 0
10958path.conicTo(SkBits2Float(0x5e704d09), SkBits2Float(0x5e3a4dfd), SkBits2Float(0x00000000), SkBits2Float(0x65eb62ef), SkBits2Float(0x430fa5e6)); // 4.32888e+18f, 3.35617e+18f, 0, 1.38948e+23f, 143.648f
10959path.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
10960path.conicTo(SkBits2Float(0x62743d2d), SkBits2Float(0x5e49b862), SkBits2Float(0x6617da56), SkBits2Float(0x00000000), SkBits2Float(0x410ef54c)); // 1.12635e+21f, 3.63387e+18f, 1.79276e+23f, 0, 8.93489f
10961path.close();
10962
10963 SkPath path1(path);
10964 path.reset();
10965 path.setFillType((SkPathFillType) 0);
10966path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10967path.quadTo(SkBits2Float(0x4f9a3a8a), SkBits2Float(0xc28a0d28), SkBits2Float(0x273a3ab3), SkBits2Float(0x8b2a2928)); // 5.17506e+09f, -69.0257f, 2.58445e-15f, -3.27718e-32f
10968path.lineTo(SkBits2Float(0x63283ae6), SkBits2Float(0x27282a81)); // 3.1033e+21f, 2.33377e-15f
10969
10970 SkPath path2(path);
10971 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
10972}

◆ fuzz763_23()

static void fuzz763_23 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10974 of file PathOpsOpTest.cpp.

10974 {
10975 SkPath path;
10976 path.setFillType((SkPathFillType) 0);
10977
10978 SkPath path1(path);
10979 path.reset();
10980 path.setFillType((SkPathFillType) 0);
10981path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
10982path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
10983path.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
10984path.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
10985path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
10986path.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
10987path.lineTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0682955)); // 3.33127e+24f, -2.87402e+29f
10988path.close();
10989path.moveTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
10990path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10991path.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
10992path.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
10993path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
10994path.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
10995path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0xc2213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, -40.3073f
10996path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000650423f, 2.50336e-13f
10997path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
10998path.close();
10999path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
11000path.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
11001path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21515d27)); // 2.22225e-15f, 0.000713932f, -732.486f, -1.90686e+27f, 7.09352e-19f
11002path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0685527)); // 3.35016e+24f, -2.87614e+29f
11003path.close();
11004path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
11005path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
11006path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
11007path.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
11008path.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
11009path.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
11010
11011 SkPath path2(path);
11012 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
11013}

◆ fuzz763_24()

static void fuzz763_24 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11015 of file PathOpsOpTest.cpp.

11015 {
11016 SkPath path;
11017 path.setFillType((SkPathFillType) 1);
11018
11019 SkPath path1(path);
11020 path.reset();
11021 path.setFillType((SkPathFillType) 0);
11022path.moveTo(SkBits2Float(0xededed02), SkBits2Float(0xedededed)); // -9.20431e+27f, -9.20445e+27f
11023path.close();
11024path.moveTo(SkBits2Float(0xededed02), SkBits2Float(0xedededed)); // -9.20431e+27f, -9.20445e+27f
11025path.quadTo(SkBits2Float(0x9fb9c16e), SkBits2Float(0x27737375), SkBits2Float(0xb7c5ff00), SkBits2Float(0x00ff9908)); // -7.86706e-20f, 3.37856e-15f, -2.3603e-05f, 2.34729e-38f
11026path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
11027path.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
11028path.quadTo(SkBits2Float(0x04007f41), SkBits2Float(0xecececec), SkBits2Float(0xecececec), SkBits2Float(0xecec41ec)); // 1.51048e-36f, -2.2914e+27f, -2.2914e+27f, -2.28494e+27f
11029path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
11030path.close();
11031path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
11032path.quadTo(SkBits2Float(0x000000ec), SkBits2Float(0xececcc00), SkBits2Float(0x48ececec), SkBits2Float(0x0278806e)); // 3.30706e-43f, -2.29016e+27f, 485223, 1.8257e-37f
11033path.lineTo(SkBits2Float(0x72ececec), SkBits2Float(0xecec02ec)); // 9.38559e+30f, -2.28256e+27f
11034path.quadTo(SkBits2Float(0xec04007f), SkBits2Float(0xecececec), SkBits2Float(0xecececec), SkBits2Float(0xecec0400)); // -6.38322e+26f, -2.2914e+27f, -2.2914e+27f, -2.2826e+27f
11035path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
11036path.close();
11037path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
11038path.quadTo(SkBits2Float(0x000040ec), SkBits2Float(0x3a333300), SkBits2Float(0xecec3333), SkBits2Float(0xececdbec)); // 2.32896e-41f, 0.000683591f, -2.28439e+27f, -2.29076e+27f
11039path.lineTo(SkBits2Float(0x3300007f), SkBits2Float(0x33d83333)); // 2.98028e-08f, 1.00676e-07f
11040path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
11041path.close();
11042path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
11043path.quadTo(SkBits2Float(0x9e9ea900), SkBits2Float(0x33ececec), SkBits2Float(0xececec33), SkBits2Float(0xec336e6e)); // -1.67988e-20f, 1.10327e-07f, -2.29138e+27f, -8.67677e+26f
11044path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
11045path.close();
11046path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
11047path.lineTo(SkBits2Float(0xedededed), SkBits2Float(0xedededed)); // -9.20445e+27f, -9.20445e+27f
11048path.lineTo(SkBits2Float(0xecececec), SkBits2Float(0xecececec)); // -2.2914e+27f, -2.2914e+27f
11049path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
11050path.close();
11051path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
11052path.lineTo(SkBits2Float(0x01003300), SkBits2Float(0x33d83333)); // 2.35465e-38f, 1.00676e-07f
11053path.quadTo(SkBits2Float(0xecec3333), SkBits2Float(0x04eeedec), SkBits2Float(0xe0e0e0e0), SkBits2Float(0x9ee0e0e0)); // -2.28439e+27f, 5.6172e-36f, -1.29634e+20f, -2.38099e-20f
11054path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
11055path.close();
11056path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
11057path.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
11058path.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
11059
11060 SkPath path2(path);
11061 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
11062}

◆ fuzz763_25()

static void fuzz763_25 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11064 of file PathOpsOpTest.cpp.

11064 {
11065 SkPath path;
11066 path.setFillType((SkPathFillType) 1);
11067path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f
11068path.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
11069path.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
11070path.lineTo(SkBits2Float(0x68555b29), SkBits2Float(0x00000000)); // 4.03018e+24f, 0
11071path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x682d2927), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6829686f)); // 0, 3.27091e+24f, 0, 0, 3.20003e+24f
11072path.lineTo(SkBits2Float(0xdf218a28), SkBits2Float(0x00000000)); // -1.16402e+19f, 0
11073path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc4)); // 0, 6.14991e+25f
11074path.close();
11075path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11076path.conicTo(SkBits2Float(0x6642c40c), SkBits2Float(0x00000000), SkBits2Float(0x65906630), SkBits2Float(0x6a25a070), SkBits2Float(0x3edcd74d)); // 2.29939e+23f, 0, 8.52382e+22f, 5.00576e+25f, 0.43133f
11077path.conicTo(SkBits2Float(0x68295afa), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x4277a57b)); // 3.19903e+24f, 0, 0, 0, 61.9116f
11078path.close();
11079
11080 SkPath path1(path);
11081 path.reset();
11082 path.setFillType((SkPathFillType) 0);
11083
11084 SkPath path2(path);
11085 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
11086}

◆ fuzz763_26()

static void fuzz763_26 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11089 of file PathOpsOpTest.cpp.

11089 {
11090 SkPath path;
11091 path.setFillType((SkPathFillType) 0);
11092
11093 SkPath path1(path);
11094 path.reset();
11095 path.setFillType((SkPathFillType) 0);
11096path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
11097path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc003210a)); // 3.60396e-20f, -2.04889f
11098path.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
11099path.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
11100path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
11101path.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
11102path.lineTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
11103path.close();
11104path.moveTo(SkBits2Float(0x68315b2d), SkBits2Float(0xf0682955)); // 3.35016e+24f, -2.87402e+29f
11105path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
11106path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
11107path.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
11108path.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
11109path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
11110path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x6e2a1f72), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 1.31626e+28f, 4.7323e-37f, 6.14991e+25f, 75739
11111path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
11112path.close();
11113path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
11114path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a284f1a), SkBits2Float(0x2c213ab3)); // 5.69738e-19f, 0.00105461f, -8.10378e-33f, 2.29121e-12f
11115path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
11116path.close();
11117path.moveTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
11118path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a2a812a), SkBits2Float(0x2127ed29)); // 2.25206e-21f, 300.343f, 0.000650423f, 5.68957e-19f
11119path.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
11120path.conicTo(SkBits2Float(0x27202140), SkBits2Float(0x3a3b2769), SkBits2Float(0xc4371f20), SkBits2Float(0xecc52a22), SkBits2Float(0x21512727)); // 2.22225e-15f, 0.000713936f, -732.486f, -1.90686e+27f, 7.08638e-19f
11121path.lineTo(SkBits2Float(0x68355b2d), SkBits2Float(0xf0685527)); // 3.42572e+24f, -2.87614e+29f
11122path.close();
11123path.moveTo(SkBits2Float(0x6829523a), SkBits2Float(0x2d555b2d)); // 3.19839e+24f, 1.21279e-11f
11124path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x5b2d5529)); // 4.03114e+24f, 4.87888e+16f
11125path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0xc0032108)); // 3.60404e-20f, -2.04889f
11126path.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
11127path.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
11128path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
11129path.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
11130path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
11131path.close();
11132path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
11133path.lineTo(SkBits2Float(0x555b1b29), SkBits2Float(0x6c212a8c)); // 1.50569e+13f, 7.79352e+26f
11134path.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
11135path.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
11136path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
11137path.close();
11138path.moveTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
11139path.lineTo(SkBits2Float(0x8c2aed7a), SkBits2Float(0x1f2128c0)); // -1.31678e-31f, 3.41268e-20f
11140path.lineTo(SkBits2Float(0x68385b2d), SkBits2Float(0xf0682955)); // 3.48239e+24f, -2.87402e+29f
11141path.close();
11142
11143 SkPath path2(path);
11144 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
11145}

◆ fuzz763_27()

static void fuzz763_27 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11185 of file PathOpsOpTest.cpp.

11185 {
11186 SkPath path;
11187 path.setFillType((SkPathFillType) 0);
11188
11189 SkPath path1(path);
11190 path.reset();
11191 path.setFillType((SkPathFillType) 0);
11192path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11193path.quadTo(SkBits2Float(0x30309ab8), SkBits2Float(0x305b3030), SkBits2Float(0x00f53030), SkBits2Float(0x3a3a0000)); // 6.42483e-10f, 7.97402e-10f, 2.2517e-38f, 0.000709534f
11194path.quadTo(SkBits2Float(0xb8b8d5b8), SkBits2Float(0x0b0b0b03), SkBits2Float(0x0b0b0b0b), SkBits2Float(0x3a3a0b0b)); // -8.81361e-05f, 2.67787e-32f, 2.67787e-32f, 0.000709698f
11195path.quadTo(SkBits2Float(0xb8b8b8b8), SkBits2Float(0x0b1203b8), SkBits2Float(0x0b0b0b0b), SkBits2Float(0x3a3a2110)); // -8.80821e-05f, 2.81214e-32f, 2.67787e-32f, 0.000710026f
11196
11197 SkPath path2(path);
11198 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
11199}

◆ fuzz763_28()

static void fuzz763_28 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11147 of file PathOpsOpTest.cpp.

11147 {
11148 SkPath path;
11149 path.setFillType((SkPathFillType) 0);
11150
11151 SkPath path1(path);
11152 path.reset();
11153 path.setFillType((SkPathFillType) 0);
11154path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
11155path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
11156path.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
11157path.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
11158path.moveTo(SkBits2Float(0x6c395b2d), SkBits2Float(0xf0682955)); // 8.96327e+26f, -2.87402e+29f
11159path.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
11160path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
11161path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
11162path.lineTo(SkBits2Float(0x8a283a28), SkBits2Float(0x284f1a3a)); // -8.09984e-33f, 1.14965e-14f
11163path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f
11164path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f
11165path.conicTo(SkBits2Float(0x381f203a), SkBits2Float(0x2ac422c5), SkBits2Float(0xc25d27ec), SkBits2Float(0x3a705921), SkBits2Float(0x2a105152)); // 3.79386e-05f, 3.48407e-13f, -55.289f, 0.000916855f, 1.2818e-13f
11166path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x683a5b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.52017e+24f
11167path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f
11168path.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
11169path.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
11170path.quadTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f
11171path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
11172path.close();
11173path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
11174path.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
11175path.lineTo(SkBits2Float(0x5b2d212d), SkBits2Float(0x2d556829)); // 4.87316e+16f, 1.21308e-11f
11176path.moveTo(SkBits2Float(0x68552968), SkBits2Float(0x5568295b)); // 4.02651e+24f, 1.5954e+13f
11177path.moveTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55)); // 4.87407e+16f, 5.7784e-19f
11178path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
11179path.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
11180
11181 SkPath path2(path);
11182 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
11183}

◆ fuzz763_29()

static void fuzz763_29 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11201 of file PathOpsOpTest.cpp.

11201 {
11202 SkPath path;
11203 path.setFillType((SkPathFillType) 1);
11204path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11205path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x743e0000)); // 0, 6.02134e+31f
11206path.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
11207path.quadTo(SkBits2Float(0x74360ca0), SkBits2Float(0x7401e10c), SkBits2Float(0x7436a382), SkBits2Float(0x7401cc18)); // 5.76937e+31f, 4.11603e+31f, 5.78805e+31f, 4.11344e+31f
11208path.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
11209path.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
11210path.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
11211path.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
11212path.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
11213path.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
11214path.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
11215path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11216path.close();
11217
11218 SkPath path1(path);
11219 path.reset();
11220 path.setFillType((SkPathFillType) 0);
11221path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11222path.lineTo(SkBits2Float(0xf0682955), SkBits2Float(0x211f5b2d)); // -2.87402e+29f, 5.3992e-19f
11223path.moveTo(SkBits2Float(0x2d2aff2d), SkBits2Float(0x74747474)); // 9.72004e-12f, 7.74708e+31f
11224path.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
11225path.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
11226path.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
11227path.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
11228
11229 SkPath path2(path);
11230 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
11231}

◆ fuzz763_2a()

static void fuzz763_2a ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10196 of file PathOpsOpTest.cpp.

10196 {
10197 SkPath path;
10198 path.setFillType((SkPathFillType) 1);
10199
10200 SkPath path1(path);
10201 path.reset();
10202 path.setFillType((SkPathFillType) 0);
10203path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10204path.quadTo(SkBits2Float(0x3e484500), SkBits2Float(0x164f3a30), SkBits2Float(0x49484801), SkBits2Float(0x7d0100c8)); // 0.195576f, 1.67397e-25f, 820352, 1.07172e+37f
10205path.conicTo(SkBits2Float(0xff7f36fd), SkBits2Float(0x3e647d01), SkBits2Float(0x0c00f430), SkBits2Float(0x486b6448), SkBits2Float(0x00484848)); // -3.39239e+38f, 0.223133f, 9.93424e-32f, 241041, 6.63809e-39f
10206path.lineTo(SkBits2Float(0x4f4f557d), SkBits2Float(0x48480112)); // 3.47849e+09f, 204804
10207path.lineTo(SkBits2Float(0xf40c01ff), SkBits2Float(0x45008000)); // -4.43702e+31f, 2056
10208path.moveTo(SkBits2Float(0x4bfffa00), SkBits2Float(0x7d4ac859)); // 3.35514e+07f, 1.68465e+37f
10209path.conicTo(SkBits2Float(0x7d014f3e), SkBits2Float(0x00f4ff01), SkBits2Float(0x6b64480c), SkBits2Float(0x48484848), SkBits2Float(0x557d0100)); // 1.07426e+37f, 2.24993e-38f, 2.75975e+26f, 205089, 1.73863e+13f
10210
10211 SkPath path2(path);
10212 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
10213}

◆ fuzz763_2b()

static void fuzz763_2b ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10216 of file PathOpsOpTest.cpp.

10216 {
10217 SkPath path;
10218 path.setFillType((SkPathFillType) 1);
10219
10220 SkPath path1(path);
10221 path.reset();
10222 path.setFillType((SkPathFillType) 0);
10223path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x212a8c55)); // 4.76191e+16f, 5.7784e-19f
10224path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
10225path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21)); // 2.50338e-13f, 4.61198e-19f
10226path.conicTo(SkBits2Float(0x6a3a7bc0), SkBits2Float(0x4721ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28), SkBits2Float(0x4f9a3a8a)); // 5.63611e+25f, 41453.5f, 9.4495e-15f, 0.000617492f, 5.17506e+09f
10227path.lineTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
10228path.close();
10229path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
10230path.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
10231path.lineTo(SkBits2Float(0x081f2a21), SkBits2Float(0x7bc00321)); // 4.78968e-34f, 1.99397e+36f
10232path.lineTo(SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28)); // 9.4495e-15f, 0.000617492f
10233path.lineTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
10234path.close();
10235path.moveTo(SkBits2Float(0x3b21081f), SkBits2Float(0x4b7bc003)); // 0.00245715f, 1.64987e+07f
10236path.quadTo(SkBits2Float(0x8a4fc29a), SkBits2Float(0x3ab3283a), SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6)); // -1.00033e-32f, 0.00136686f, 2.25206e-21f, 300.343f
10237path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
10238path.conicTo(SkBits2Float(0x1e2ab03a), SkBits2Float(0x2920213b), SkBits2Float(0x3b3ac527), SkBits2Float(0xc422333b), SkBits2Float(0x6c2a9f1f)); // 9.03617e-21f, 3.5556e-14f, 0.00284989f, -648.8f, 8.25075e+26f
10239path.quadTo(SkBits2Float(0xc25d2757), SkBits2Float(0x3a705921), SkBits2Float(0x2a105152), SkBits2Float(0x28d91210)); // -55.2884f, 0.000916855f, 1.2818e-13f, 2.40997e-14f
10240path.quadTo(SkBits2Float(0x68295b2d), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19905e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f
10241path.lineTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
10242path.close();
10243path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
10244path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0xcb7bc003), SkBits2Float(0x47ed7a6a)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, -1.64987e+07f, 121589
10245path.lineTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
10246path.close();
10247path.moveTo(SkBits2Float(0x5b2d2a81), SkBits2Float(0x29276829)); // 4.87419e+16f, 3.71718e-14f
10248path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x2d8a3a21), SkBits2Float(0x5b682b68), SkBits2Float(0x5b292d55)); // -1.2117e+19f, 1.57146e-11f, 6.53499e+16f, 4.76191e+16f
10249path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x0321081f)); // 1.43144e-13f, 4.7323e-37f
10250path.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
10251path.moveTo(SkBits2Float(0x21df2828), SkBits2Float(0x9a3a8a3a)); // 1.51217e-18f, -3.85756e-23f
10252path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x28273ac2), SkBits2Float(0xe61d2a29), SkBits2Float(0x2a63962b)); // 0.00136978f, 9.2831e-15f, -1.85547e+23f, 2.02138e-13f
10253path.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
10254path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10255path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
10256path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10257path.close();
10258
10259 SkPath path2(path);
10260 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
10261}

◆ fuzz763_2c()

static void fuzz763_2c ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10263 of file PathOpsOpTest.cpp.

10263 {
10264 SkPath path;
10265 path.setFillType((SkPathFillType) 1);
10266
10267path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x36344a4a)); // 0, 2.68653e-06f
10268path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x364a4a4a), SkBits2Float(0x364a4a4a), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0, 3.01436e-06f, 3.01436e-06f, 0, 0
10269path.lineTo(SkBits2Float(0x364a4a4a), SkBits2Float(0x00000000)); // 3.01436e-06f, 0
10270path.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
10271path.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
10272path.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
10273path.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
10274path.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
10275path.close();
10276 SkPath path1(path);
10277 path.reset();
10278 path.setFillType((SkPathFillType) 0);
10279path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10280path.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
10281path.moveTo(SkBits2Float(0x000010a1), SkBits2Float(0x19312000)); // 5.96533e-42f, 9.15715e-24f
10282path.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
10283path.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
10284 SkPath path2(path);
10285 testPathOpFuzz(reporter, path1, path2, kReverseDifference_SkPathOp, filename);
10286}
kReverseDifference_SkPathOp
@ kReverseDifference_SkPathOp
subtract the first path from the op path
Definition SkPathOps.h:27

◆ fuzz763_3()

static void fuzz763_3 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9982 of file PathOpsOpTest.cpp.

9982 {
9983 SkPath path;
9984 path.setFillType((SkPathFillType) 1);
9985
9986 SkPath path1(path);
9987 path.reset();
9988 path.setFillType((SkPathFillType) 0);
9989path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
9990path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f
9991path.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
9992path.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
9993path.moveTo(SkBits2Float(0x25682929), SkBits2Float(0x212a8c5b)); // 2.01367e-16f, 5.7784e-19f
9994path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4a7bc0)); // 4.7323e-37f, 6.11969e+25f
9995path.conicTo(SkBits2Float(0x032108ed), SkBits2Float(0x283a7bc0), SkBits2Float(0x47ed7a6a), SkBits2Float(0x282a3a21), SkBits2Float(0x3a21ff28)); // 4.73239e-37f, 1.03519e-14f, 121589, 9.4495e-15f, 0.000617968f
9996path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3), SkBits2Float(0x2a292827), SkBits2Float(0x962be61d)); // -8.10388e-33f, 0.00148185f, 1.50241e-13f, -1.38859e-25f
9997path.lineTo(SkBits2Float(0x295b2d2a), SkBits2Float(0x2d296868)); // 4.86669e-14f, 9.62972e-12f
9998path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
9999path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x898ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // 6.14991e+25f, -3.39271e-33f, 4.61198e-19f, 0.00096035f, 121589
10000path.lineTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
10001path.close();
10002path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
10003path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0xb38a281a), SkBits2Float(0x29283ac2)); // -1.2117e+19f, 0.00105459f, -6.43342e-08f, 3.73545e-14f
10004path.moveTo(SkBits2Float(0x962be61d), SkBits2Float(0x432a2927)); // -1.38859e-25f, 170.161f
10005path.conicTo(SkBits2Float(0x3a2a552a), SkBits2Float(0x3b1e2ab0), SkBits2Float(0x29272021), SkBits2Float(0x3b3ac527), SkBits2Float(0x1fc42236)); // 0.000649768f, 0.00241343f, 3.71093e-14f, 0.00284989f, 8.30658e-20f
10006path.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
10007path.lineTo(SkBits2Float(0x272927b0), SkBits2Float(0x5b392929)); // 2.3475e-15f, 5.21181e+16f
10008path.moveTo(SkBits2Float(0x3a1127b4), SkBits2Float(0x2921ee3b)); // 0.000553723f, 3.59558e-14f
10009path.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
10010path.moveTo(SkBits2Float(0x21081f3f), SkBits2Float(0x9fd4e62a)); // 4.61199e-19f, -9.01663e-20f
10011path.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
10012
10013 SkPath path2(path);
10014 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
10015}

◆ fuzz763_30()

static void fuzz763_30 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11233 of file PathOpsOpTest.cpp.

11233 {
11234 SkPath path;
11235 path.setFillType((SkPathFillType) 1);
11236
11237 SkPath path1(path);
11238 path.reset();
11239 path.setFillType((SkPathFillType) 0);
11240path.moveTo(SkBits2Float(0x1f2108c0), SkBits2Float(0x4b7b0321)); // 3.41003e-20f, 1.64503e+07f
11241path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f
11242path.moveTo(SkBits2Float(0x68305b2d), SkBits2Float(0xf0685527)); // 3.33127e+24f, -2.87614e+29f
11243path.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
11244path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x212a8c55)); // 4.87407e+16f, 5.7784e-19f
11245path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x4b7b28c0)); // 4.7323e-37f, 1.646e+07f
11246path.lineTo(SkBits2Float(0x2a8ced7a), SkBits2Float(0x2d081f21)); // 2.50338e-13f, 7.73762e-12f
11247path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
11248path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
11249path.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
11250path.conicTo(SkBits2Float(0x212a8ced), SkBits2Float(0xed7a6a1f), SkBits2Float(0x3a214793), SkBits2Float(0x3328282a), SkBits2Float(0x3a8a3adf)); // 5.77848e-19f, -4.84372e+27f, 0.000615233f, 3.91521e-08f, 0.00105461f
11251path.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
11252path.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
11253path.lineTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
11254path.close();
11255path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
11256path.quadTo(SkBits2Float(0x3ab38a28), SkBits2Float(0x3ac22c21), SkBits2Float(0x6c401057), SkBits2Float(0x6d6d6b64)); // 0.00136978f, 0.00148142f, 9.28764e+26f, 4.59236e+27f
11257path.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
11258
11259 SkPath path2(path);
11260 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
11261}

◆ fuzz763_31()

static void fuzz763_31 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11263 of file PathOpsOpTest.cpp.

11263 {
11264 SkPath path;
11265 path.setFillType((SkPathFillType) 1);
11266
11267 SkPath path1(path);
11268 path.reset();
11269 path.setFillType((SkPathFillType) 0);
11270path.moveTo(SkBits2Float(0xd72a8c55), SkBits2Float(0x61081f2a)); // -1.8752e+14f, 1.56938e+20f
11271path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x4793ed7a), SkBits2Float(0x282a3a21), SkBits2Float(0xdf3a2128), SkBits2Float(0x471ac575)); // 6.14991e+25f, 75739, 9.4495e-15f, -1.3412e+19f, 39621.5f
11272path.lineTo(SkBits2Float(0x28404040), SkBits2Float(0x552a298a)); // 1.06721e-14f, 1.16935e+13f
11273path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
11274path.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
11275path.lineTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
11276path.close();
11277path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
11278path.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
11279path.lineTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
11280path.close();
11281path.moveTo(SkBits2Float(0x212c685b), SkBits2Float(0x21081f2a)); // 5.8414e-19f, 4.61198e-19f
11282path.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
11283
11284 SkPath path2(path);
11285 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
11286}

◆ fuzz763_32()

static void fuzz763_32 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11335 of file PathOpsOpTest.cpp.

11335 {
11336 SkPath path;
11337 path.setFillType((SkPathFillType) 1);
11338
11339 SkPath path1(path);
11340 path.reset();
11341 path.setFillType((SkPathFillType) 0);
11342path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11343path.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
11344path.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
11345path.moveTo(SkBits2Float(0xe0f2f210), SkBits2Float(0xc3f2eef2)); // -1.40049e+20f, -485.867f
11346path.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
11347path.moveTo(SkBits2Float(0x556c0010), SkBits2Float(0x002a8768)); // 1.62178e+13f, 3.90567e-39f
11348path.quadTo(SkBits2Float(0xf2f22021), SkBits2Float(0xf2f2f56e), SkBits2Float(0xf2f2f2f2), SkBits2Float(0xf22040d9)); // -9.59158e+30f, -9.62459e+30f, -9.6242e+30f, -3.17414e+30f
11349path.lineTo(SkBits2Float(0xc013f2f2), SkBits2Float(0x0000294d)); // -2.3117f, 1.48159e-41f
11350
11351 SkPath path2(path);
11352 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
11353}

◆ fuzz763_33()

static void fuzz763_33 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11288 of file PathOpsOpTest.cpp.

11288 {
11289 SkPath path;
11290 path.setFillType((SkPathFillType) 1);
11291path.moveTo(SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 7.66623e+30f, 7.66608e+30f
11292path.quadTo(SkBits2Float(0x724341bf), SkBits2Float(0x72433fc4), SkBits2Float(0x6d757575), SkBits2Float(0x6d6d6d6d)); // 3.86746e+30f, 3.86731e+30f, 4.74786e+27f, 4.59251e+27f
11293path.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
11294path.conicTo(SkBits2Float(0x6c6c8b72), SkBits2Float(0x00000000), SkBits2Float(0x6c6c6c6c), SkBits2Float(0x00000000), SkBits2Float(0x400812df)); // 1.14386e+27f, 0, 1.14327e+27f, 0, 2.12615f
11295path.quadTo(SkBits2Float(0x72432acb), SkBits2Float(0x72432295), SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 3.86568e+30f, 3.86505e+30f, 7.66623e+30f, 7.66608e+30f
11296path.close();
11297path.moveTo(SkBits2Float(0x72c185d5), SkBits2Float(0x72c184e8)); // 7.66623e+30f, 7.66608e+30f
11298path.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
11299path.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
11300path.close();
11301path.moveTo(SkBits2Float(0x6c6c69d8), SkBits2Float(0x6d20df31)); // 1.14323e+27f, 3.11171e+27f
11302path.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
11303path.lineTo(SkBits2Float(0x6a674231), SkBits2Float(0x6c0c3394)); // 6.98936e+25f, 6.77973e+26f
11304path.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
11305path.close();
11306
11307 SkPath path1(path);
11308 path.reset();
11309 path.setFillType((SkPathFillType) 0);
11310path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11311path.lineTo(SkBits2Float(0x6c6b6ba7), SkBits2Float(0x886b6b6b)); // 1.13842e+27f, -7.0844e-34f
11312path.quadTo(SkBits2Float(0x0000206b), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d)); // 1.16294e-41f, 4.59251e+27f, 4.59251e+27f, 4.59251e+27f
11313path.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
11314path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x95066b78)); // 2.01583e+34f, -2.71459e-26f
11315path.lineTo(SkBits2Float(0x6c6b6ba7), SkBits2Float(0x886b6b6b)); // 1.13842e+27f, -7.0844e-34f
11316path.quadTo(SkBits2Float(0x0000206b), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d), SkBits2Float(0x6d6d6d6d)); // 1.16294e-41f, 4.59251e+27f, 4.59251e+27f, 4.59251e+27f
11317path.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
11318path.lineTo(SkBits2Float(0x8787878f), SkBits2Float(0x87878787)); // -2.03922e-34f, -2.03922e-34f
11319path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
11320path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
11321path.lineTo(SkBits2Float(0x6c105778), SkBits2Float(0x6d406b64)); // 6.97994e+26f, 3.72193e+27f
11322path.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
11323path.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
11324path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
11325path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
11326path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
11327path.lineTo(SkBits2Float(0xb4bcacbc), SkBits2Float(0xbcadbcbc)); // -3.51434e-07f, -0.0212082f
11328path.moveTo(SkBits2Float(0xa03aacbc), SkBits2Float(0x757575a0)); // -1.5812e-19f, 3.11157e+32f
11329path.close();
11330
11331 SkPath path2(path);
11332 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
11333}

◆ fuzz763_34()

static void fuzz763_34 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11355 of file PathOpsOpTest.cpp.

11355 {
11356 SkPath path;
11357 path.setFillType((SkPathFillType) 1);
11358path.moveTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f
11359path.quadTo(SkBits2Float(0x63690f37), SkBits2Float(0x6d0a3d9b), SkBits2Float(0x00000000), SkBits2Float(0x6d3e3e3e)); // 4.29919e+21f, 2.67396e+27f, 0, 3.67984e+27f
11360path.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
11361path.lineTo(SkBits2Float(0x6c6c586c), SkBits2Float(0x00000000)); // 1.1429e+27f, 0
11362path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11363path.conicTo(SkBits2Float(0x6c8c6c6c), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x6cc8e82a), SkBits2Float(0x5b684b68)); // 1.35809e+27f, 0, 0, 1.94305e+27f, 6.53851e+16f
11364path.lineTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f
11365path.close();
11366path.moveTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f
11367path.quadTo(SkBits2Float(0x641ae35f), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 1.14287e+22f, 0, 0, 0
11368path.lineTo(SkBits2Float(0x6c6c586c), SkBits2Float(0x00000000)); // 1.1429e+27f, 0
11369path.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
11370path.lineTo(SkBits2Float(0x63a95a6c), SkBits2Float(0x6cc8e7e2)); // 6.24803e+21f, 1.94304e+27f
11371path.close();
11372
11373 SkPath path1(path);
11374 path.reset();
11375 path.setFillType((SkPathFillType) 0);
11376path.moveTo(SkBits2Float(0x6c3e3e3e), SkBits2Float(0x586c79ff)); // 9.19959e+26f, 1.04003e+15f
11377path.quadTo(SkBits2Float(0x6c6c4a6c), SkBits2Float(0x6c6c6c6c), SkBits2Float(0xc83e6c6c), SkBits2Float(0x3e313e3e)); // 1.14263e+27f, 1.14327e+27f, -194994, 0.173089f
11378
11379 SkPath path2(path);
11380 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
11381}

◆ fuzz763_35()

static void fuzz763_35 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11437 of file PathOpsOpTest.cpp.

11437 {
11438 SkPath path;
11439 path.setFillType((SkPathFillType) 1);
11440
11441 SkPath path1(path);
11442 path.reset();
11443 path.setFillType((SkPathFillType) 0);
11444path.moveTo(SkBits2Float(0x2aed2a8c), SkBits2Float(0x03210a1f)); // 4.21292e-13f, 4.73253e-37f
11445path.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
11446path.quadTo(SkBits2Float(0x74747474), SkBits2Float(0x74747474), SkBits2Float(0x20437474), SkBits2Float(0x43a52b02)); // 7.74708e+31f, 7.74708e+31f, 1.65557e-19f, 330.336f
11447path.moveTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f
11448path.lineTo(SkBits2Float(0x4b7bd603), SkBits2Float(0x6cf33b6a)); // 1.65043e+07f, 2.3524e+27f
11449path.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
11450path.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
11451path.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
11452path.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
11453path.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
11454path.lineTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f
11455path.close();
11456path.moveTo(SkBits2Float(0x3a214781), SkBits2Float(0x2128282a)); // 0.000615232f, 5.69738e-19f
11457path.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
11458path.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
11459path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x742974e8)); // 7.74706e+31f, 5.3703e+31f
11460path.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
11461path.moveTo(SkBits2Float(0x31292768), SkBits2Float(0x212d2aff)); // 2.46151e-09f, 5.86716e-19f
11462path.quadTo(SkBits2Float(0x2128282a), SkBits2Float(0x323adf81), SkBits2Float(0x77291a3a), SkBits2Float(0x00002a49)); // 5.69738e-19f, 1.08774e-08f, 3.42981e+33f, 1.51691e-41f
11463path.moveTo(SkBits2Float(0x7474743e), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f
11464path.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
11465path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f
11466path.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
11467path.lineTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f
11468path.close();
11469path.moveTo(SkBits2Float(0x74747440), SkBits2Float(0x74747474)); // 7.74706e+31f, 7.74708e+31f
11470path.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
11471
11472 SkPath path2(path);
11473 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
11474}

◆ fuzz763_36()

static void fuzz763_36 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11383 of file PathOpsOpTest.cpp.

11383 {
11384 SkPath path;
11385 path.setFillType((SkPathFillType) 0);
11386
11387 SkPath path1(path);
11388 path.reset();
11389 path.setFillType((SkPathFillType) 0);
11390path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
11391path.moveTo(SkBits2Float(0x1f2a312a), SkBits2Float(0xc0032108)); // 3.60396e-20f, -2.04889f
11392path.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
11393path.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
11394path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
11395path.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
11396path.lineTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
11397path.close();
11398path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
11399path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
11400path.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
11401path.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
11402path.lineTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
11403path.close();
11404path.moveTo(SkBits2Float(0xe8355b2d), SkBits2Float(0xf0682955)); // -3.42572e+24f, -2.87402e+29f
11405path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f
11406path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11407path.conicTo(SkBits2Float(0x2a8c555b), SkBits2Float(0x212a1f72), SkBits2Float(0x03210807), SkBits2Float(0x6a4b7b28), SkBits2Float(0x4793ed7a)); // 2.49282e-13f, 5.76399e-19f, 4.73229e-37f, 6.14984e+25f, 75739
11408path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11409path.close();
11410path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11411path.quadTo(SkBits2Float(0x282a282a), SkBits2Float(0x8a3adf21), SkBits2Float(0x284f1a3a), SkBits2Float(0x213ab38a)); // 9.4456e-15f, -8.99754e-33f, 1.14965e-14f, 6.32569e-19f
11412path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11413path.close();
11414path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11415path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x3a20002a), SkBits2Float(0x2a8ced29)); // 2.25206e-21f, 300.343f, 0.000610354f, 2.50336e-13f
11416path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11417path.close();
11418path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11419path.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
11420path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a3b2729), SkBits2Float(0xc4341f20), SkBits2Float(0xecc52a22)); // 2.22225e-15f, 0.000713932f, -720.486f, -1.90686e+27f
11421path.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
11422path.lineTo(SkBits2Float(0x1f2a2a8c), SkBits2Float(0x03210821)); // 3.60341e-20f, 4.7323e-37f
11423path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11424path.close();
11425path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11426path.conicTo(SkBits2Float(0x2eed6a7a), SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28), SkBits2Float(0x4f1a3a8a), SkBits2Float(0x3ab38a28)); // 1.07964e-10f, 9.4495e-15f, 0.000617492f, 2.58753e+09f, 0.00136978f
11427path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11428path.close();
11429path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11430path.quadTo(SkBits2Float(0xe61d2a28), SkBits2Float(0x2a43962b), SkBits2Float(0x29272a81), SkBits2Float(0x2bb02a55)); // -1.85547e+23f, 1.73716e-13f, 3.71183e-14f, 1.25173e-12f
11431path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3ac52729), SkBits2Float(0xc4223b32), SkBits2Float(0x6c2a201f)); // 2.22225e-15f, 0.00150416f, -648.925f, 8.22676e+26f
11432
11433 SkPath path2(path);
11434 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
11435}

◆ fuzz763_37()

static void fuzz763_37 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11476 of file PathOpsOpTest.cpp.

11476 {
11477 SkPath path;
11478 path.setFillType((SkPathFillType) 0);
11479path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x5b2d3368)); // 1.59583e+13f, 4.87517e+16f
11480path.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
11481path.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
11482path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
11483path.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
11484path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
11485path.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
11486path.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
11487path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
11488path.close();
11489path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
11490path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f
11491path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11492path.conicTo(SkBits2Float(0x721f2a5b), SkBits2Float(0x212a8c55), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7b28), SkBits2Float(0x4793ed7a)); // 3.1526e+30f, 5.7784e-19f, 4.7323e-37f, 6.14984e+25f, 75739
11493path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11494path.close();
11495path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11496path.quadTo(SkBits2Float(0x28282a2a), SkBits2Float(0x2c682921), SkBits2Float(0x8c555bf6), SkBits2Float(0x6d03de30)); // 9.33502e-15f, 3.2992e-12f, -1.64366e-31f, 2.5507e+27f
11497path.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
11498path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11499path.close();
11500path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11501path.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
11502path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11503path.close();
11504path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11505path.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
11506path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11507path.close();
11508path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
11509path.lineTo(SkBits2Float(0x8ced293a), SkBits2Float(0x5c5c5c5c)); // -3.65404e-31f, 2.48104e+17f
11510path.moveTo(SkBits2Float(0x21081f21), SkBits2Float(0x4b7bc003)); // 4.61198e-19f, 1.64987e+07f
11511path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 9.43289e-15f, 4.8745e+16f
11512path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f
11513path.lineTo(SkBits2Float(0x682d2952), SkBits2Float(0xee682103)); // 3.27093e+24f, -1.79601e+28f
11514path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x2a3b0355)); // 4.85282e+16f, 1.66101e-13f
11515path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f
11516path.close();
11517path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5a)); // 3.50084e+24f, -2.87489e+29f
11518path.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
11519
11520 SkPath path1(path);
11521 path.reset();
11522 path.setFillType((SkPathFillType) 0);
11523path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11524path.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
11525
11526 SkPath path2(path);
11527 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
11528}

◆ fuzz763_38()

static void fuzz763_38 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11530 of file PathOpsOpTest.cpp.

11530 {
11531 SkPath path;
11532 path.setFillType((SkPathFillType) 0);
11533path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11534path.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
11535path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11536path.close();
11537path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
11538path.close();
11539path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
11540path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x2ac05252), SkBits2Float(0x727fb721)); // 4.80216e+30f, 2.25832e+11f, 3.41632e-13f, 5.06496e+30f
11541path.lineTo(SkBits2Float(0x73727322), SkBits2Float(0x555b2d29)); // 1.92088e+31f, 1.50617e+13f
11542path.lineTo(SkBits2Float(0xab2a212e), SkBits2Float(0x7a27872a)); // -6.04422e-13f, 2.17464e+35f
11543path.moveTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f
11544path.quadTo(SkBits2Float(0x52524852), SkBits2Float(0x72525228), SkBits2Float(0x72727272), SkBits2Float(0x3a727272)); // 2.25789e+11f, 4.16584e+30f, 4.80216e+30f, 0.000924862f
11545path.lineTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f
11546path.close();
11547path.moveTo(SkBits2Float(0x25fffefb), SkBits2Float(0x7bc00321)); // 4.44082e-16f, 1.99397e+36f
11548path.quadTo(SkBits2Float(0x2a292827), SkBits2Float(0x962b0080), SkBits2Float(0x5252752a), SkBits2Float(0x72725252)); // 1.50241e-13f, -1.38134e-25f, 2.25977e+11f, 4.79967e+30f
11549path.quadTo(SkBits2Float(0x72725252), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.79967e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
11550path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda000072), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.00732e+15f, 2.25867e+11f, 2.25831e+11f
11551path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525272), SkBits2Float(0x72525248), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16584e+30f, 4.80216e+30f
11552path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 2.25831e+11f
11553path.quadTo(SkBits2Float(0x86727272), SkBits2Float(0x5252528d), SkBits2Float(0x72525252), SkBits2Float(0x72727227)); // -4.55992e-35f, 2.25832e+11f, 4.16585e+30f, 4.80214e+30f
11554path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x29217272), SkBits2Float(0xc003211c), SkBits2Float(0x556a4b7b)); // 4.80216e+30f, 3.58484e-14f, -2.0489f, 1.61006e+13f
11555path.moveTo(SkBits2Float(0x72557272), SkBits2Float(0x00727272)); // 4.22775e+30f, 1.05103e-38f
11556path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
11557path.close();
11558path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
11559path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x3a727272), SkBits2Float(0x28273ac2), SkBits2Float(0x00802a29)); // 4.80216e+30f, 0.000924862f, 9.2831e-15f, 1.17701e-38f
11560path.lineTo(SkBits2Float(0x52752a96), SkBits2Float(0x72525252)); // 2.63245e+11f, 4.16585e+30f
11561path.quadTo(SkBits2Float(0x72525272), SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72727272)); // 4.16586e+30f, 2.25966e+11f, 2.25831e+11f, 4.80216e+30f
11562path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f
11563path.lineTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
11564path.close();
11565path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
11566path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525272), SkBits2Float(0x72525248), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16584e+30f, 4.80216e+30f
11567path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x72525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 4.16585e+30f
11568path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x72727252), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada)); // 4.80216e+30f, 4.80215e+30f, -9.04113e+15f, 2.25867e+11f
11569path.lineTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
11570path.close();
11571path.moveTo(SkBits2Float(0x5a61dada), SkBits2Float(0x52525252)); // 1.58931e+16f, 2.25831e+11f
11572path.quadTo(SkBits2Float(0x86727272), SkBits2Float(0x5252528d), SkBits2Float(0x72525252), SkBits2Float(0x72727227)); // -4.55992e-35f, 2.25832e+11f, 4.16585e+30f, 4.80214e+30f
11573path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x29217272), SkBits2Float(0xc003211c), SkBits2Float(0x556a4b7b)); // 4.80216e+30f, 3.58484e-14f, -2.0489f, 1.61006e+13f
11574path.moveTo(SkBits2Float(0x72557272), SkBits2Float(0x00727272)); // 4.22775e+30f, 1.05103e-38f
11575path.moveTo(SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 2.34994e+11f, 2.25831e+11f
11576path.close();
11577path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
11578path.close();
11579path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
11580path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
11581path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x52525ada), SkBits2Float(0x52525252)); // 4.80215e+30f, -9.04113e+15f, 2.25867e+11f, 2.25831e+11f
11582path.quadTo(SkBits2Float(0x52525272), SkBits2Float(0x3b3b0052), SkBits2Float(0x5b2d553a), SkBits2Float(0x68556829)); // 2.25832e+11f, 0.00285341f, 4.87889e+16f, 4.03114e+24f
11583
11584 SkPath path1(path);
11585 path.reset();
11586 path.setFillType((SkPathFillType) 0);
11587path.moveTo(SkBits2Float(0x52528c55), SkBits2Float(0x29215252)); // 2.26074e+11f, 3.58206e-14f
11588
11589 SkPath path2(path);
11590 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
11591}

◆ fuzz763_39()

static void fuzz763_39 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11659 of file PathOpsOpTest.cpp.

11659 {
11660 SkPath path;
11661 path.setFillType((SkPathFillType) 0);
11662
11663 SkPath path1(path);
11664 path.reset();
11665 path.setFillType((SkPathFillType) 0);
11666path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11667path.quadTo(SkBits2Float(0x7a057c72), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x055f0089)); // 1.73275e+35f, 4.80216e+30f, 4.34505e+30f, 1.04855e-35f
11668path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xba405e72), SkBits2Float(0x03000074)); // 1.73224e+35f, 4.80216e+30f, -0.000733829f, 3.76163e-37f
11669path.lineTo(SkBits2Float(0x664aff00), SkBits2Float(0x56397d39)); // 2.39655e+23f, 5.09869e+13f
11670path.quadTo(SkBits2Float(0x7a057273), SkBits2Float(0x057300ff), SkBits2Float(0x257c0c9f), SkBits2Float(0x72787257)); // 1.73224e+35f, 1.1426e-35f, 2.18618e-16f, 4.92099e+30f
11671path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x03000093), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8ecff00)); // -0.000836826f, 3.76165e-37f, 1.17894e+32f, -8.95346e+24f
11672path.moveTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d)); // 0.000231069f, 2.53975e+30f
11673path.quadTo(SkBits2Float(0x827a0572), SkBits2Float(0x72727272), SkBits2Float(0x724adf00), SkBits2Float(0x00397d39)); // -1.83687e-37f, 4.80216e+30f, 4.01828e+30f, 5.27954e-39f
11674path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x16f3abab), SkBits2Float(0xfc5b97fc), SkBits2Float(0x47440039)); // 1.73224e+35f, 3.93671e-25f, -4.56078e+36f, 50176.2f
11675path.lineTo(SkBits2Float(0x00710000), SkBits2Float(0x62767201)); // 1.03774e-38f, 1.13653e+21f
11676path.quadTo(SkBits2Float(0x7a05726e), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f
11677
11678 SkPath path2(path);
11679 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
11680}

◆ fuzz763_3a()

static void fuzz763_3a ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10151 of file PathOpsOpTest.cpp.

10151 {
10152 SkPath path;
10153 path.setFillType((SkPathFillType) 1);
10154
10155 SkPath path1(path);
10156 path.reset();
10157 path.setFillType((SkPathFillType) 0);
10158path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10159path.lineTo(SkBits2Float(0x555b292d), SkBits2Float(0x2a212a8c)); // 1.50606e+13f, 1.43144e-13f
10160path.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
10161path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
10162path.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
10163path.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
10164path.moveTo(SkBits2Float(0x8adf2028), SkBits2Float(0x3a219a3a)); // -2.14862e-32f, 0.000616464f
10165path.quadTo(SkBits2Float(0x3ab38e28), SkBits2Float(0x29283ac2), SkBits2Float(0x2be61d2a), SkBits2Float(0x812a4396)); // 0.0013699f, 3.73545e-14f, 1.63506e-12f, -3.12726e-38f
10166
10167 SkPath path2(path);
10168 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
10169}

◆ fuzz763_4()

static void fuzz763_4 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9949 of file PathOpsOpTest.cpp.

9949 {
9950 SkPath path;
9951 path.setFillType((SkPathFillType) 1);
9952
9953 SkPath path1(path);
9954 path.reset();
9955 path.setFillType((SkPathFillType) 0);
9956path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
9957path.lineTo(SkBits2Float(0x555b3a2d), SkBits2Float(0x2a212a8c)); // 1.50652e+13f, 1.43144e-13f
9958path.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
9959path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac2b33a)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148544f
9960path.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
9961path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
9962path.close();
9963path.moveTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f
9964path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x2a21081f)); // 1.43144e-13f, 1.43025e-13f
9965path.conicTo(SkBits2Float(0xde6a4b7b), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // -4.22068e+18f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121589
9966path.lineTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f
9967path.close();
9968path.moveTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f
9969path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
9970path.lineTo(SkBits2Float(0x2928088c), SkBits2Float(0x2be61d2a)); // 3.73109e-14f, 1.63506e-12f
9971path.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
9972path.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
9973path.lineTo(SkBits2Float(0x55685b1f), SkBits2Float(0x5b2d2968)); // 1.59674e+13f, 4.87407e+16f
9974path.close();
9975path.moveTo(SkBits2Float(0x212a8c55), SkBits2Float(0x21081f2a)); // 5.7784e-19f, 4.61198e-19f
9976path.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
9977
9978 SkPath path2(path);
9979 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
9980}

◆ fuzz763_40()

static void fuzz763_40 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11632 of file PathOpsOpTest.cpp.

11632 {
11633 SkPath path;
11634 path.setFillType((SkPathFillType) 1);
11635
11636 SkPath path1(path);
11637 path.reset();
11638 path.setFillType((SkPathFillType) 0);
11639path.moveTo(SkBits2Float(0x10190004), SkBits2Float(0x7272727a)); // 3.01739e-29f, 4.80216e+30f
11640path.quadTo(SkBits2Float(0xf3db5e64), SkBits2Float(0x5b97fc16), SkBits2Float(0x000039fc), SkBits2Float(0x01008000)); // -3.47604e+31f, 8.55598e+16f, 2.08009e-41f, 2.36017e-38f
11641path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x41720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 15.1251f
11642path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f
11643path.lineTo(SkBits2Float(0x01000000), SkBits2Float(0x10010004)); // 2.35099e-38f, 2.54408e-29f
11644path.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
11645path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x63720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 4.46415e+21f
11646path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f
11647path.lineTo(SkBits2Float(0x72000000), SkBits2Float(0x5b5e72b4)); // 2.5353e+30f, 6.26136e+16f
11648path.quadTo(SkBits2Float(0x05720089), SkBits2Float(0x05727272), SkBits2Float(0x7272727a), SkBits2Float(0x5b5e7272)); // 1.13789e-35f, 1.13998e-35f, 4.80216e+30f, 6.26133e+16f
11649path.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
11650path.moveTo(SkBits2Float(0x72008972), SkBits2Float(0x458fe705)); // 2.54594e+30f, 4604.88f
11651path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0xe8727272), SkBits2Float(0xba5b5e03), SkBits2Float(0x03000074)); // 1.73224e+35f, -4.5797e+24f, -0.00083682f, 3.76163e-37f
11652path.lineTo(SkBits2Float(0xf3dbff00), SkBits2Float(0x00397d16)); // -3.48598e+31f, 5.2795e-39f
11653path.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
11654
11655 SkPath path2(path);
11656 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
11657}

◆ fuzz763_41()

static void fuzz763_41 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11593 of file PathOpsOpTest.cpp.

11593 {
11594 SkPath path;
11595 path.setFillType((SkPathFillType) 0);
11596
11597 SkPath path1(path);
11598 path.reset();
11599 path.setFillType((SkPathFillType) 0);
11600path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11601path.quadTo(SkBits2Float(0x7a057c72), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x055f0089)); // 1.73275e+35f, 4.80216e+30f, 4.34505e+30f, 1.04855e-35f
11602path.quadTo(SkBits2Float(0x00057272), SkBits2Float(0x72ff0000), SkBits2Float(0xba405e72), SkBits2Float(0x031b0074)); // 5.00233e-40f, 1.01016e+31f, -0.000733829f, 4.55509e-37f
11603path.lineTo(SkBits2Float(0x664af700), SkBits2Float(0x56397d39)); // 2.39619e+23f, 5.09869e+13f
11604path.quadTo(SkBits2Float(0x7a057273), SkBits2Float(0x057300e4), SkBits2Float(0x257c0c9f), SkBits2Float(0x72400006)); // 1.73224e+35f, 1.1426e-35f, 2.18618e-16f, 3.80295e+30f
11605path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x030000ff), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8ec4000)); // -0.000836826f, 3.7617e-37f, 1.17894e+32f, -8.92527e+24f
11606path.moveTo(SkBits2Float(0x39724aff), SkBits2Float(0x7200397d)); // 0.000231069f, 2.53975e+30f
11607path.quadTo(SkBits2Float(0x827a0572), SkBits2Float(0x08727272), SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // -1.83687e-37f, 7.29588e-34f, 4.09355e-34f, 4.09355e-34f
11608path.lineTo(SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // 4.09355e-34f, 4.09355e-34f
11609path.lineTo(SkBits2Float(0x08080808), SkBits2Float(0x08080808)); // 4.09355e-34f, 4.09355e-34f
11610path.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
11611path.quadTo(SkBits2Float(0x00800039), SkBits2Float(0x72100039), SkBits2Float(0x727a0572), SkBits2Float(0x7a727272)); // 1.1755e-38f, 2.85223e+30f, 4.95218e+30f, 3.14714e+35f
11612path.lineTo(SkBits2Float(0x7272727a), SkBits2Float(0xdb5e6472)); // 4.80216e+30f, -6.25979e+16f
11613path.moveTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f
11614path.lineTo(SkBits2Float(0x666d0100), SkBits2Float(0x726efe62)); // 2.79805e+23f, 4.73376e+30f
11615path.lineTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f
11616path.close();
11617path.moveTo(SkBits2Float(0x440039fc), SkBits2Float(0x0000f647)); // 512.906f, 8.83477e-41f
11618path.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
11619path.quadTo(SkBits2Float(0x72057272), SkBits2Float(0x8c7a3472), SkBits2Float(0x72727272), SkBits2Float(0x00f6475e)); // 2.64319e+30f, -1.92751e-31f, 4.80216e+30f, 2.26171e-38f
11620path.moveTo(SkBits2Float(0x6d106d43), SkBits2Float(0x6efe6266)); // 2.79362e+27f, 3.93641e+28f
11621path.quadTo(SkBits2Float(0x72727a05), SkBits2Float(0xba5b7272), SkBits2Float(0x03000074), SkBits2Float(0x5aff00e8)); // 4.80274e+30f, -0.000837124f, 3.76163e-37f, 3.58886e+16f
11622path.quadTo(SkBits2Float(0x00da0039), SkBits2Float(0x72100039), SkBits2Float(0x727a0572), SkBits2Float(0x7a727272)); // 2.00202e-38f, 2.85223e+30f, 4.95218e+30f, 3.14714e+35f
11623path.lineTo(SkBits2Float(0x7272727a), SkBits2Float(0xdb5e6472)); // 4.80216e+30f, -6.25979e+16f
11624path.lineTo(SkBits2Float(0xfc5b97fc), SkBits2Float(0x47440039)); // -4.56078e+36f, 50176.2f
11625path.lineTo(SkBits2Float(0x00710000), SkBits2Float(0x62766d01)); // 1.03774e-38f, 1.13644e+21f
11626path.quadTo(SkBits2Float(0x7a05726e), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f
11627
11628 SkPath path2(path);
11629 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
11630}

◆ fuzz763_42()

static void fuzz763_42 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11683 of file PathOpsOpTest.cpp.

11683 {
11684 SkPath path;
11685 path.setFillType((SkPathFillType) 0);
11686
11687 SkPath path1(path);
11688 path.reset();
11689 path.setFillType((SkPathFillType) 0);
11690path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11691path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x05720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 1.13789e-35f
11692path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xba405e72), SkBits2Float(0x03000074)); // 1.73224e+35f, 4.80216e+30f, -0.000733829f, 3.76163e-37f
11693path.lineTo(SkBits2Float(0x724aff00), SkBits2Float(0x56397d39)); // 4.02075e+30f, 5.09869e+13f
11694path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0xfa8d00ff), SkBits2Float(0x25727272), SkBits2Float(0x7272727a)); // 1.73224e+35f, -3.66067e+35f, 2.10289e-16f, 4.80216e+30f
11695path.quadTo(SkBits2Float(0xba5b5e72), SkBits2Float(0x03000093), SkBits2Float(0x74ba00e8), SkBits2Float(0xe8e0ff00)); // -0.000836826f, 3.76165e-37f, 1.17894e+32f, -8.50011e+24f
11696path.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
11697path.quadTo(SkBits2Float(0x00397d39), SkBits2Float(0x05727272), SkBits2Float(0x7272727a), SkBits2Float(0x385e7272)); // 5.27954e-39f, 1.13998e-35f, 4.80216e+30f, 5.30355e-05f
11698path.quadTo(SkBits2Float(0x057200ff), SkBits2Float(0x25727272), SkBits2Float(0x7272727a), SkBits2Float(0x5b5e7272)); // 1.1379e-35f, 2.10289e-16f, 4.80216e+30f, 6.26133e+16f
11699path.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
11700path.quadTo(SkBits2Float(0x2b2d16f3), SkBits2Float(0x0039fc4d), SkBits2Float(0x68800000), SkBits2Float(0x0100fafa)); // 6.14938e-13f, 5.32513e-39f, 4.8357e+24f, 2.369e-38f
11701path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0x725b5e72), SkBits2Float(0x63720089)); // 1.73224e+35f, 4.80216e+30f, 4.34505e+30f, 4.46415e+21f
11702path.lineTo(SkBits2Float(0x63636363), SkBits2Float(0x63606363)); // 4.19457e+21f, 4.13923e+21f
11703path.lineTo(SkBits2Float(0x72720000), SkBits2Float(0xff725b5e)); // 4.7933e+30f, -3.22148e+38f
11704path.moveTo(SkBits2Float(0x72720572), SkBits2Float(0x5b5e2572)); // 4.79373e+30f, 6.25286e+16f
11705path.quadTo(SkBits2Float(0x05720089), SkBits2Float(0x25727272), SkBits2Float(0x72728c7a), SkBits2Float(0x5b5e7272)); // 1.13789e-35f, 2.10289e-16f, 4.80417e+30f, 6.26133e+16f
11706path.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
11707path.quadTo(SkBits2Float(0x97fc16f3), SkBits2Float(0x0039fc5b), SkBits2Float(0x00f6472e), SkBits2Float(0x01008000)); // -1.62909e-24f, 5.32515e-39f, 2.26171e-38f, 2.36017e-38f
11708path.quadTo(SkBits2Float(0x7a057272), SkBits2Float(0x72727272), SkBits2Float(0xf3db5e64), SkBits2Float(0x4a5afc16)); // 1.73224e+35f, 4.80216e+30f, -3.47604e+31f, 3.58785e+06f
11709
11710 SkPath path2(path);
11711 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
11712}

◆ fuzz763_43()

static void fuzz763_43 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11714 of file PathOpsOpTest.cpp.

11714 {
11715 SkPath path;
11716 path.setFillType((SkPathFillType) 1);
11717
11718 SkPath path1(path);
11719 path.reset();
11720 path.setFillType((SkPathFillType) 0);
11721path.moveTo(SkBits2Float(0x5c386c3a), SkBits2Float(0x4e691a3e)); // 2.07642e+17f, 9.77703e+08f
11722path.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
11723path.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
11724path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f
11725path.close();
11726path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f
11727path.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
11728path.lineTo(SkBits2Float(0x438a0b9c), SkBits2Float(0x60a1d2c8)); // 276.091f, 9.32848e+19f
11729path.quadTo(SkBits2Float(0xe13fb902), SkBits2Float(0x07ee536f), SkBits2Float(0x971d8ac1), SkBits2Float(0x2f9f174b)); // -2.21041e+20f, 3.58593e-34f, -5.09046e-25f, 2.89385e-10f
11730path.lineTo(SkBits2Float(0x0f2cf5d8), SkBits2Float(0xe271654c)); // 8.5276e-30f, -1.11324e+21f
11731path.lineTo(SkBits2Float(0xe6cf24d2), SkBits2Float(0xd9537742)); // -4.89105e+23f, -3.72015e+15f
11732path.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
11733path.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
11734path.lineTo(SkBits2Float(0xda45ad4e), SkBits2Float(0xedce4a04)); // -1.39103e+16f, -7.98042e+27f
11735path.lineTo(SkBits2Float(0xac0e45da), SkBits2Float(0x8f632841)); // -2.02182e-12f, -1.11997e-29f
11736path.lineTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f
11737path.close();
11738path.moveTo(SkBits2Float(0xcc2084b7), SkBits2Float(0x19f68bdb)); // -4.20789e+07f, 2.54923e-23f
11739path.quadTo(SkBits2Float(0xf35c4ad5), SkBits2Float(0x0692f251), SkBits2Float(0x69632126), SkBits2Float(0xb927af67)); // -1.74534e+31f, 5.52751e-35f, 1.71614e+25f, -0.000159917f
11740path.moveTo(SkBits2Float(0x6534bff9), SkBits2Float(0x434a9986)); // 5.3348e+22f, 202.6f
11741path.quadTo(SkBits2Float(0x37c603e5), SkBits2Float(0xa0683953), SkBits2Float(0x751915e4), SkBits2Float(0x831c911a)); // 2.36053e-05f, -1.96701e-19f, 1.94059e+32f, -4.60108e-37f
11742path.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
11743path.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
11744
11745 SkPath path2(path);
11746 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
11747}

◆ fuzz763_44()

static void fuzz763_44 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11749 of file PathOpsOpTest.cpp.

11749 {
11750 SkPath path;
11751 path.setFillType((SkPathFillType) 1);
11752path.moveTo(SkBits2Float(0x7c223bab), SkBits2Float(0x7cf35966)); // 3.36945e+36f, 1.01083e+37f
11753path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0x7ccaca6d), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 8.4236e+36f, 0, 0
11754path.lineTo(SkBits2Float(0x7d7d7d7d), SkBits2Float(0x00000000)); // 2.10591e+37f, 0
11755path.quadTo(SkBits2Float(0x7ccacab0), SkBits2Float(0x7d1817f4), SkBits2Float(0x7c223bab), SkBits2Float(0x7cf35966)); // 8.42364e+36f, 1.26354e+37f, 3.36945e+36f, 1.01083e+37f
11756path.close();
11757
11758 SkPath path1(path);
11759 path.reset();
11760 path.setFillType((SkPathFillType) 0);
11761path.moveTo(SkBits2Float(0x109d0000), SkBits2Float(0xff7bc000)); // 6.19256e-29f, -3.34633e+38f
11762path.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
11763path.quadTo(SkBits2Float(0x72728302), SkBits2Float(0x8b727272), SkBits2Float(0x72727272), SkBits2Float(0xc00308f6)); // 4.80344e+30f, -4.66936e-32f, 4.80216e+30f, -2.04742f
11764path.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
11765
11766 SkPath path2(path);
11767 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
11768}

◆ fuzz763_45()

static void fuzz763_45 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11770 of file PathOpsOpTest.cpp.

11770 {
11771 SkPath path;
11772 path.setFillType((SkPathFillType) 0);
11773
11774 SkPath path1(path);
11775 path.reset();
11776 path.setFillType((SkPathFillType) 0);
11777path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11778path.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
11779path.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
11780path.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
11781path.moveTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
11782path.moveTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f
11783path.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
11784path.lineTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f
11785path.close();
11786path.moveTo(SkBits2Float(0x77773030), SkBits2Float(0x30303030)); // 5.01357e+33f, 6.40969e-10f
11787path.lineTo(SkBits2Float(0x7f303030), SkBits2Float(0x7a303030)); // 2.34194e+38f, 2.28705e+35f
11788path.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
11789path.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
11790path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
11791path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 6.40969e-10f
11792path.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
11793path.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
11794path.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
11795path.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
11796path.moveTo(SkBits2Float(0x77303030), SkBits2Float(0xff303030)); // 3.57352e+33f, -2.34194e+38f
11797path.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
11798path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x77303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f, 3.57352e+33f, 6.40969e-10f
11799path.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
11800path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x30303030), SkBits2Float(0x7a7a3030)); // 6.40969e-10f, 6.40969e-10f, 6.40969e-10f, 3.24763e+35f
11801 SkPath path2(path);
11802 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
11803}

◆ fuzz763_46()

static void fuzz763_46 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11805 of file PathOpsOpTest.cpp.

11805 {
11806 SkPath path;
11807 path.setFillType((SkPathFillType) 0);
11808
11809 SkPath path1(path);
11810 path.reset();
11811 path.setFillType((SkPathFillType) 0);
11812path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11813 path.conicTo(SkBits2Float(0x44444444), SkBits2Float(0x44444444), SkBits2Float(0x44263030), SkBits2Float(0x44304430), SkBits2Float(0x4c444430)); // 785.067f, 785.067f, 664.753f, 705.065f, 5.145e+07f
11814path.moveTo(SkBits2Float(0x44444444), SkBits2Float(0x44444444)); // 785.067f, 785.067f
11815path.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
11816 SkPath path2(path);
11817 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
11818}

◆ fuzz763_47()

static void fuzz763_47 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11820 of file PathOpsOpTest.cpp.

11820 {
11821 SkPath path;
11822 path.setFillType((SkPathFillType) 1);
11823
11824 SkPath path1(path);
11825 path.reset();
11826 path.setFillType((SkPathFillType) 0);
11827path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11828path.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
11829path.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
11830path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11831path.close();
11832path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11833path.lineTo(SkBits2Float(0x2a212a8c), SkBits2Float(0x7272081f)); // 1.43144e-13f, 4.79393e+30f
11834path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x5974fa80), SkBits2Float(0x00747474), SkBits2Float(0x59585264)); // 4.80216e+30f, 4.30971e+15f, 1.06947e-38f, 3.80557e+15f
11835path.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
11836path.quadTo(SkBits2Float(0x80807d80), SkBits2Float(0x80808080), SkBits2Float(0xff7f0000), SkBits2Float(0x80808080)); // -1.18e-38f, -1.1801e-38f, -3.38953e+38f, -1.1801e-38f
11837path.quadTo(SkBits2Float(0x80808080), SkBits2Float(0x80808080), SkBits2Float(0xed842b00), SkBits2Float(0x7252ff6d)); // -1.1801e-38f, -1.1801e-38f, -5.113e+27f, 4.17924e+30f
11838path.quadTo(SkBits2Float(0x72577200), SkBits2Float(0x55525352), SkBits2Float(0x2a212a8c), SkBits2Float(0x7272081f)); // 4.26733e+30f, 1.44535e+13f, 1.43144e-13f, 4.79393e+30f
11839path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x6f740080), SkBits2Float(0x8c556874), SkBits2Float(0x2982ffff)); // 4.80216e+30f, 7.55149e+28f, -1.64404e-31f, 5.81757e-14f
11840
11841 SkPath path2(path);
11842 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
11843}

◆ fuzz763_48()

static void fuzz763_48 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11845 of file PathOpsOpTest.cpp.

11845 {
11846 SkPath path;
11847 path.setFillType((SkPathFillType) 1);
11848
11849 SkPath path1(path);
11850 path.reset();
11851 path.setFillType((SkPathFillType) 0);
11852path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11853path.lineTo(SkBits2Float(0xed0081bc), SkBits2Float(0x1b2d8040)); // -2.48568e+27f, 1.43517e-22f
11854path.moveTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f
11855path.close();
11856path.moveTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f
11857path.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
11858path.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
11859path.lineTo(SkBits2Float(0x74747403), SkBits2Float(0x29747474)); // 7.74703e+31f, 5.42799e-14f
11860path.close();
11861path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
11862path.close();
11863path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
11864path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52524872), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.2579e+11f, 4.16585e+30f, 4.80216e+30f
11865path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0x80406666), SkBits2Float(0x68291b2d), SkBits2Float(0x0315ff80)); // 4.80215e+30f, -5.91421e-39f, 3.19432e+24f, 4.40805e-37f
11866path.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
11867path.lineTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
11868path.close();
11869path.moveTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
11870path.quadTo(SkBits2Float(0x72727227), SkBits2Float(0x72727272), SkBits2Float(0x74727272), SkBits2Float(0x55747421)); // 4.80214e+30f, 4.80216e+30f, 7.68345e+31f, 1.67987e+13f
11871path.lineTo(SkBits2Float(0xa5252620), SkBits2Float(0x52b4adad)); // -1.43244e-16f, 3.88004e+11f
11872path.close();
11873path.moveTo(SkBits2Float(0x724b0000), SkBits2Float(0x00725f72)); // 4.02083e+30f, 1.05035e-38f
11874path.lineTo(SkBits2Float(0x52525252), SkBits2Float(0x72725252)); // 2.25831e+11f, 4.79967e+30f
11875path.quadTo(SkBits2Float(0x26727272), SkBits2Float(0x0303a525), SkBits2Float(0x52005c03), SkBits2Float(0x72525252)); // 8.41157e-16f, 3.8687e-37f, 1.37825e+11f, 4.16585e+30f
11876path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x1ff07255), SkBits2Float(0x2a8c5572), SkBits2Float(0x21082a21)); // 4.80216e+30f, 1.01833e-19f, 2.49283e-13f, 4.61343e-19f
11877path.lineTo(SkBits2Float(0x2a2a3a21), SkBits2Float(0x29212828)); // 1.51192e-13f, 3.5784e-14f
11878
11879 SkPath path2(path);
11880 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
11881}

◆ fuzz763_49()

static void fuzz763_49 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11883 of file PathOpsOpTest.cpp.

11883 {
11884 SkPath path;
11885 path.setFillType((SkPathFillType) 0);
11886
11887 SkPath path1(path);
11888 path.reset();
11889 path.setFillType((SkPathFillType) 0);
11890path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11891path.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
11892path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
11893path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
11894path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 2.01583e+34f, 2.01583e+34f
11895path.quadTo(SkBits2Float(0x30303030), SkBits2Float(0x78787878), SkBits2Float(0x78787878), SkBits2Float(0x78787878)); // 6.40969e-10f, 2.01583e+34f, 2.01583e+34f, 2.01583e+34f
11896path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
11897path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
11898path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
11899path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
11900path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
11901path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
11902path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
11903path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
11904path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
11905path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
11906path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
11907path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
11908path.lineTo(SkBits2Float(0x30303030), SkBits2Float(0x30303030)); // 6.40969e-10f, 6.40969e-10f
11909path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x7878788d)); // 2.01583e+34f, 2.01584e+34f
11910path.lineTo(SkBits2Float(0x78787878), SkBits2Float(0x30303030)); // 2.01583e+34f, 6.40969e-10f
11911
11912 SkPath path2(path);
11913 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
11914}

◆ fuzz763_5()

static void fuzz763_5 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10017 of file PathOpsOpTest.cpp.

10017 {
10018 SkPath path;
10019 path.setFillType((SkPathFillType) 1);
10020
10021 SkPath path1(path);
10022 path.reset();
10023 path.setFillType((SkPathFillType) 0);
10024path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
10025path.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
10026path.conicTo(SkBits2Float(0x3a2147ed), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21), SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3)); // 0.000615238f, -1.2117e+19f, 0.00105459f, -8.10388e-33f, 0.00148185f
10027path.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
10028path.lineTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
10029path.close();
10030path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
10031path.conicTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x2a8ced7a), SkBits2Float(0x21081f21), SkBits2Float(0x3a7bc003), SkBits2Float(0x47ed7a6a)); // 6.14991e+25f, 2.50338e-13f, 4.61198e-19f, 0.00096035f, 121589
10032path.lineTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
10033path.close();
10034path.moveTo(SkBits2Float(0x5b292d55), SkBits2Float(0x2a2a8c55)); // 4.76191e+16f, 1.51477e-13f
10035path.quadTo(SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3b21), SkBits2Float(0x28ee4f9a), SkBits2Float(0x68293b78)); // -1.2117e+19f, 0.00105462f, 2.64578e-14f, 3.19671e+24f
10036path.lineTo(SkBits2Float(0x5b2d2968), SkBits2Float(0x5b2d8c55)); // 4.87407e+16f, 4.88495e+16f
10037
10038 SkPath path2(path);
10039 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
10040}

◆ fuzz763_50()

static void fuzz763_50 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11916 of file PathOpsOpTest.cpp.

11916 {
11917 SkPath path;
11918 path.setFillType((SkPathFillType) 1);
11919path.moveTo(SkBits2Float(0x70621ede), SkBits2Float(0x00000000)); // 2.79924e+29f, 0
11920path.conicTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x74fc5b97), SkBits2Float(0x7d458fe4)); // 0, 0, 0, 1.59951e+32f, 1.64128e+37f
11921path.lineTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0
11922path.lineTo(SkBits2Float(0x70621ede), SkBits2Float(0x00000000)); // 2.79924e+29f, 0
11923path.close();
11924path.moveTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0
11925path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11926path.lineTo(SkBits2Float(0xefea1ffe), SkBits2Float(0x00000000)); // -1.44916e+29f, 0
11927path.close();
11928
11929 SkPath path1(path);
11930 path.reset();
11931 path.setFillType((SkPathFillType) 0);
11932
11933 SkPath path2(path);
11934 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
11935}

◆ fuzz763_51()

static void fuzz763_51 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11937 of file PathOpsOpTest.cpp.

11937 {
11938 SkPath path;
11939 path.setFillType((SkPathFillType) 1);
11940
11941 SkPath path1(path);
11942 path.reset();
11943 path.setFillType((SkPathFillType) 0);
11944path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11945path.quadTo(SkBits2Float(0x868b5aae), SkBits2Float(0x626c45ab), SkBits2Float(0xefea1ffe), SkBits2Float(0x0029fc76)); // -5.24192e-35f, 1.08961e+21f, -1.44916e+29f, 3.85582e-39f
11946path.moveTo(SkBits2Float(0xfacbff01), SkBits2Float(0x56fc5b97)); // -5.29604e+35f, 1.38735e+14f
11947path.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
11948
11949 SkPath path2(path);
11950 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
11951}

◆ fuzz763_52()

static void fuzz763_52 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11953 of file PathOpsOpTest.cpp.

11953 {
11954 SkPath path;
11955 path.setFillType((SkPathFillType) 1);
11956
11957 SkPath path1(path);
11958 path.reset();
11959 path.setFillType((SkPathFillType) 0);
11960path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11961path.quadTo(SkBits2Float(0x29ff4bae), SkBits2Float(0xa1d75590), SkBits2Float(0x9fd6f6c3), SkBits2Float(0x70621ede)); // 1.13374e-13f, -1.45916e-18f, -9.10408e-20f, 2.79924e+29f
11962path.quadTo(SkBits2Float(0x57a839d3), SkBits2Float(0x1a80d34b), SkBits2Float(0x0147a31b), SkBits2Float(0xff7fffff)); // 3.69933e+14f, 5.32809e-23f, 3.66675e-38f, -3.40282e+38f
11963path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11964path.close();
11965path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
11966path.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
11967path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
11968path.close();
11969path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
11970path.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
11971path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
11972path.close();
11973path.moveTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
11974path.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
11975path.lineTo(SkBits2Float(0x1ab8e97c), SkBits2Float(0x94fbe3ef)); // 7.64778e-23f, -2.54344e-26f
11976path.close();
11977
11978 SkPath path2(path);
11979 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
11980}

◆ fuzz763_53()

static void fuzz763_53 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 11982 of file PathOpsOpTest.cpp.

11982 {
11983 SkPath path;
11984 path.setFillType((SkPathFillType) 1);
11985path.moveTo(SkBits2Float(0x7644b829), SkBits2Float(0x00000000)); // 9.97486e+32f, 0
11986path.lineTo(SkBits2Float(0x74fc5b97), SkBits2Float(0x77df944a)); // 1.59951e+32f, 9.06945e+33f
11987path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xf8fbe3ff)); // 0, -4.08716e+34f
11988path.lineTo(SkBits2Float(0x7644b829), SkBits2Float(0x00000000)); // 9.97486e+32f, 0
11989path.close();
11990
11991 SkPath path1(path);
11992 path.reset();
11993 path.setFillType((SkPathFillType) 0);
11994path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
11995path.quadTo(SkBits2Float(0x45ab86ae), SkBits2Float(0xd6d6626c), SkBits2Float(0xd6d6d6d6), SkBits2Float(0x7644d6d6)); // 5488.83f, -1.17859e+14f, -1.18109e+14f, 9.98093e+32f
11996path.moveTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0xd6d6d6d6)); // -1.18109e+14f, -1.18109e+14f
11997path.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
11998path.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
11999path.lineTo(SkBits2Float(0xd6d6d6d6), SkBits2Float(0xd6d6d6d6)); // -1.18109e+14f, -1.18109e+14f
12000path.close();
12001path.moveTo(SkBits2Float(0xef08a412), SkBits2Float(0x5aaeff7f)); // -4.22883e+28f, 2.46288e+16f
12002path.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
12003path.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
12004path.lineTo(SkBits2Float(0xef08a412), SkBits2Float(0x5aaeff7f)); // -4.22883e+28f, 2.46288e+16f
12005path.close();
12006
12007 SkPath path2(path);
12008 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
12009}

◆ fuzz763_54()

static void fuzz763_54 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 12012 of file PathOpsOpTest.cpp.

12012 {
12013 SkPath path;
12014 path.setFillType((SkPathFillType) 0);
12015path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12016path.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
12017path.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
12018path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12019path.close();
12020path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12021path.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
12022path.quadTo(SkBits2Float(0xd7da0000), SkBits2Float(0x5252525a), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // -4.79387e+14f, 2.25831e+11f, 4.16585e+30f, 4.80216e+30f
12023path.quadTo(SkBits2Float(0x48525252), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255)); // 215369, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f
12024path.quadTo(SkBits2Float(0xdada007b), SkBits2Float(0x5252525a), SkBits2Float(0x72675252), SkBits2Float(0x72727272)); // -3.0681e+16f, 2.25831e+11f, 4.5818e+30f, 4.80216e+30f
12025path.quadTo(SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272), SkBits2Float(0x72727272)); // 2.25831e+11f, 3.36289e-15f, 4.80216e+30f, 4.80216e+30f
12026path.quadTo(SkBits2Float(0x1c292172), SkBits2Float(0x7bc00321), SkBits2Float(0x9aaaaaaa), SkBits2Float(0x8c556a4b)); // 5.59606e-22f, 1.99397e+36f, -7.05861e-23f, -1.64409e-31f
12027path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f
12028path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12029path.close();
12030path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
12031path.close();
12032path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
12033path.quadTo(SkBits2Float(0x72725570), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.79991e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
12034path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0x555bb672), SkBits2Float(0x29686968), SkBits2Float(0x252a081f)); // 4.80215e+30f, 1.50985e+13f, 5.16058e-14f, 1.47479e-16f
12035path.moveTo(SkBits2Float(0x5d68392a), SkBits2Float(0x01002780)); // 1.04584e+18f, 2.35382e-38f
12036path.moveTo(SkBits2Float(0x72727200), SkBits2Float(0x72725252)); // 4.80212e+30f, 4.79967e+30f
12037path.quadTo(SkBits2Float(0x5adada00), SkBits2Float(0xa5252652), SkBits2Float(0x727272ad), SkBits2Float(0xda007b72)); // 3.08006e+16f, -1.43245e-16f, 4.80218e+30f, -9.04113e+15f
12038path.lineTo(SkBits2Float(0x5252525a), SkBits2Float(0x72525252)); // 2.25831e+11f, 4.16585e+30f
12039path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
12040path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x74217472), SkBits2Float(0x005b5574), SkBits2Float(0x72680000)); // 4.80216e+30f, 5.11671e+31f, 8.38768e-39f, 4.59523e+30f
12041path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x007b7272), SkBits2Float(0x525adada)); // 4.80216e+30f, 2.25831e+11f, 1.13368e-38f, 2.34994e+11f
12042path.lineTo(SkBits2Float(0x72727200), SkBits2Float(0x72725252)); // 4.80212e+30f, 4.79967e+30f
12043path.close();
12044
12045 SkPath path1(path);
12046 path.reset();
12047 path.setFillType((SkPathFillType) 0);
12048
12049 SkPath path2(path);
12050 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
12051}

◆ fuzz763_55()

static void fuzz763_55 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 12055 of file PathOpsOpTest.cpp.

12055 {
12056 SkPath path;
12057 path.setFillType((SkPathFillType) 0);
12058path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f
12059path.lineTo(SkBits2Float(0x55555568), SkBits2Float(0x55555555)); // 1.46602e+13f, 1.46602e+13f
12060path.lineTo(SkBits2Float(0x98989898), SkBits2Float(0x55989898)); // -3.94452e-24f, 2.09726e+13f
12061path.lineTo(SkBits2Float(0xf6f65555), SkBits2Float(0x101006f6)); // -2.49812e+33f, 2.84044e-29f
12062path.quadTo(SkBits2Float(0xdca33f10), SkBits2Float(0xf6f6f6f6), SkBits2Float(0xf621f6f6), SkBits2Float(0xf70ff6f6)); // -3.67598e+17f, -2.50452e+33f, -8.21259e+32f, -2.91995e+33f
12063path.lineTo(SkBits2Float(0x9400f6f6), SkBits2Float(0x10530000)); // -6.51105e-27f, 4.16124e-29f
12064path.quadTo(SkBits2Float(0x0f101010), SkBits2Float(0x00101010), SkBits2Float(0xf610f720), SkBits2Float(0xf6f6f6f6)); // 7.10284e-30f, 1.47513e-39f, -7.35062e+32f, -2.50452e+33f
12065path.lineTo(SkBits2Float(0x105352f6), SkBits2Float(0x1cf6ff10)); // 4.16763e-29f, 1.63448e-21f
12066path.lineTo(SkBits2Float(0xf6f6220a), SkBits2Float(0x003700f6)); // -2.49608e+33f, 5.0513e-39f
12067path.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
12068path.quadTo(SkBits2Float(0x10101007), SkBits2Float(0x10f7fd10), SkBits2Float(0xf6f6f6f6), SkBits2Float(0xf6f645e0)); // 2.84113e-29f, 9.78142e-29f, -2.50452e+33f, -2.4975e+33f
12069path.lineTo(SkBits2Float(0xed9ef6f6), SkBits2Float(0x53535353)); // -6.14965e+27f, 9.07636e+11f
12070path.lineTo(SkBits2Float(0x53006cf6), SkBits2Float(0x53295353)); // 5.51584e+11f, 7.27247e+11f
12071path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f
12072path.close();
12073path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x55415500)); // 0, 1.32857e+13f
12074path.lineTo(SkBits2Float(0xf6f6f6f6), SkBits2Float(0x5353d9f6)); // -2.50452e+33f, 9.09895e+11f
12075
12076 SkPath path1(path);
12077 path.reset();
12078 path.setFillType((SkPathFillType) 0);
12079
12080 SkPath path2(path);
12081 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
12082}

◆ fuzz763_56()

static void fuzz763_56 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 12085 of file PathOpsOpTest.cpp.

12085 {
12086 SkPath path;
12087 path.setFillType((SkPathFillType) 0);
12088path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12089path.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
12090path.quadTo(SkBits2Float(0x525252c7), SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255)); // 2.25833e+11f, 4.79967e+30f, 4.80216e+30f, 4.80215e+30f
12091path.quadTo(SkBits2Float(0xd7da0000), SkBits2Float(0x5adada00), SkBits2Float(0x52525252), SkBits2Float(0x00005252)); // -4.79387e+14f, 3.08006e+16f, 2.25831e+11f, 2.9531e-41f
12092path.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
12093path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12094path.close();
12095path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12096path.quadTo(SkBits2Float(0x72725252), SkBits2Float(0x72727272), SkBits2Float(0x72727255), SkBits2Float(0xda007b72)); // 4.79967e+30f, 4.80216e+30f, 4.80215e+30f, -9.04113e+15f
12097path.lineTo(SkBits2Float(0x5252525a), SkBits2Float(0x72525252)); // 2.25831e+11f, 4.16585e+30f
12098path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
12099path.lineTo(SkBits2Float(0x7bc00321), SkBits2Float(0x9aaaaaaa)); // 1.99397e+36f, -7.05861e-23f
12100path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0x00007272), SkBits2Float(0x525adada), SkBits2Float(0x52525252)); // 4.79991e+30f, 4.10552e-41f, 2.34994e+11f, 2.25831e+11f
12101path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12102path.close();
12103path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
12104path.close();
12105path.moveTo(SkBits2Float(0xa5252600), SkBits2Float(0x52b4adad)); // -1.43243e-16f, 3.88004e+11f
12106path.quadTo(SkBits2Float(0x72727270), SkBits2Float(0x52525272), SkBits2Float(0x72525252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25832e+11f, 4.16585e+30f, 4.80216e+30f
12107path.quadTo(SkBits2Float(0x72727255), SkBits2Float(0xda007b72), SkBits2Float(0x26525ada), SkBits2Float(0x72ada525)); // 4.80215e+30f, -9.04113e+15f, 7.29815e-16f, 6.87879e+30f
12108path.quadTo(SkBits2Float(0x007b7272), SkBits2Float(0x525adada), SkBits2Float(0x52525252), SkBits2Float(0x72727252)); // 1.13368e-38f, 2.34994e+11f, 2.25831e+11f, 4.80215e+30f
12109path.quadTo(SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72722772), SkBits2Float(0x72727272)); // 2.25966e+11f, 2.25831e+11f, 4.79636e+30f, 4.80216e+30f
12110path.quadTo(SkBits2Float(0x74727272), SkBits2Float(0x55747421), SkBits2Float(0x0000005b), SkBits2Float(0x72727268)); // 7.68345e+31f, 1.67987e+13f, 1.27518e-43f, 4.80216e+30f
12111path.quadTo(SkBits2Float(0x52527272), SkBits2Float(0x52525252), SkBits2Float(0x72727272), SkBits2Float(0x72557272)); // 2.25966e+11f, 2.25831e+11f, 4.80216e+30f, 4.22775e+30f
12112path.quadTo(SkBits2Float(0x5adada72), SkBits2Float(0x52525252), SkBits2Float(0x72725252), SkBits2Float(0x72727272)); // 3.08009e+16f, 2.25831e+11f, 4.79967e+30f, 4.80216e+30f
12113
12114 SkPath path1(path);
12115 path.reset();
12116 path.setFillType((SkPathFillType) 0);
12117
12118 SkPath path2(path);
12119 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
12120}

◆ fuzz763_57()

static void fuzz763_57 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 12122 of file PathOpsOpTest.cpp.

12122 {
12123 SkPath path;
12124 path.setFillType((SkPathFillType) 0);
12125
12126 SkPath path1(path);
12127 path.reset();
12128 path.setFillType((SkPathFillType) 0);
12129path.moveTo(SkBits2Float(0x68546829), SkBits2Float(0x555b2d29)); // 4.01225e+24f, 1.50617e+13f
12130path.moveTo(SkBits2Float(0x1f2a322a), SkBits2Float(0x4b7b2108)); // 3.60404e-20f, 1.6458e+07f
12131path.lineTo(SkBits2Float(0x2829ed84), SkBits2Float(0x5b2d2d55)); // 9.43289e-15f, 4.8745e+16f
12132path.moveTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f
12133path.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
12134path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x3b2a8c55)); // 4.85282e+16f, 0.00260236f
12135path.lineTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f
12136path.close();
12137path.moveTo(SkBits2Float(0x6838552d), SkBits2Float(0xf0684f5b)); // 3.48195e+24f, -2.87586e+29f
12138path.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
12139path.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
12140path.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
12141path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
12142path.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
12143path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
12144path.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
12145path.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
12146path.lineTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
12147path.close();
12148path.moveTo(SkBits2Float(0x6839552d), SkBits2Float(0xf0683b5b)); // 3.50084e+24f, -2.87489e+29f
12149path.lineTo(SkBits2Float(0x6829ed27), SkBits2Float(0x2d555b2d)); // 3.20982e+24f, 1.21279e-11f
12150path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
12151path.conicTo(SkBits2Float(0x721f2a5b), SkBits2Float(0x212a8c55), SkBits2Float(0x0321082a), SkBits2Float(0x6a4b7b28), SkBits2Float(0x4797ed7a)); // 3.1526e+30f, 5.7784e-19f, 4.7323e-37f, 6.14984e+25f, 77787
12152path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
12153path.close();
12154path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
12155path.quadTo(SkBits2Float(0x2828102a), SkBits2Float(0x2c682921), SkBits2Float(0x8c555bf6), SkBits2Float(0x6d03de30)); // 9.32938e-15f, 3.2992e-12f, -1.64366e-31f, 2.5507e+27f
12156path.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
12157path.lineTo(SkBits2Float(0x3a803adf), SkBits2Float(0x8a294f1a)); // 0.000978317f, -8.15193e-33f
12158path.quadTo(SkBits2Float(0x291d9628), SkBits2Float(0x2a43e62b), SkBits2Float(0x093a2a81), SkBits2Float(0x5c5c8ced)); // 3.49912e-14f, 1.73993e-13f, 2.24089e-33f, 2.48318e+17f
12159path.lineTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
12160path.close();
12161path.moveTo(SkBits2Float(0x68275b2d), SkBits2Float(0xf0685527)); // 3.16127e+24f, -2.87614e+29f
12162path.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
12163path.lineTo(SkBits2Float(0x1f212a8c), SkBits2Float(0xc0032108)); // 3.41283e-20f, -2.04889f
12164path.lineTo(SkBits2Float(0xed847b4b), SkBits2Float(0x2d552829)); // -5.12513e+27f, 1.21166e-11f
12165path.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
12166
12167 SkPath path2(path);
12168 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
12169}

◆ fuzz763_5a()

static void fuzz763_5a ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10172 of file PathOpsOpTest.cpp.

10172 {
10173 SkPath path;
10174 path.setFillType((SkPathFillType) 1);
10175path.moveTo(SkBits2Float(0x38bd8610), SkBits2Float(0x00000000)); // 9.03719e-05f, 0
10176path.conicTo(SkBits2Float(0x4183d871), SkBits2Float(0x41fea321), SkBits2Float(0xb700ff00), SkBits2Float(0x4240b8b8), SkBits2Float(0x3b058283)); // 16.4807f, 31.8297f, -7.68877e-06f, 48.1804f, 0.0020372f
10177path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f
10178path.conicTo(SkBits2Float(0x3a455ec8), SkBits2Float(0xb8b8b8b3), SkBits2Float(0x38b2418d), SkBits2Float(0xb730d014), SkBits2Float(0x3f7ffff3)); // 0.000752908f, -8.80821e-05f, 8.49991e-05f, -1.05389e-05f, 0.999999f
10179path.quadTo(SkBits2Float(0x3a51246a), SkBits2Float(0xb6da45a3), SkBits2Float(0x38bc5c3c), SkBits2Float(0x00000000)); // 0.000797814f, -6.50501e-06f, 8.98172e-05f, 0
10180path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f
10181path.quadTo(SkBits2Float(0x39a32d2d), SkBits2Float(0x00000000), SkBits2Float(0xb8a13a00), SkBits2Float(0x00000000)); // 0.000311234f, 0, -7.68788e-05f, 0
10182path.lineTo(SkBits2Float(0x3a3a3ab8), SkBits2Float(0xb8b8b8b8)); // 0.000710409f, -8.80821e-05f
10183path.quadTo(SkBits2Float(0x39ba814c), SkBits2Float(0xb838fed2), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0.00035573f, -4.41063e-05f, 0, 0
10184path.lineTo(SkBits2Float(0x38bd8610), SkBits2Float(0x00000000)); // 9.03719e-05f, 0
10185path.close();
10186
10187 SkPath path1(path);
10188 path.reset();
10189 path.setFillType((SkPathFillType) 0);
10190
10191 SkPath path2(path);
10192 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 4, filename);
10193}

◆ fuzz763_6()

static void fuzz763_6 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10288 of file PathOpsOpTest.cpp.

10288 {
10289 SkPath path;
10290 path.setFillType((SkPathFillType) 1);
10291path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f)); // 0, 5.14279e+25f
10292path.cubicTo(SkBits2Float(0x68295b2d), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x68556829)); // 3.19905e+24f, 0, 0, 0, 0, 4.03114e+24f
10293path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x68555b2a)); // 0, 4.03018e+24f
10294path.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
10295path.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
10296path.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
10297path.conicTo(SkBits2Float(0x68295b02), SkBits2Float(0x60f7f28b), SkBits2Float(0x00000000), SkBits2Float(0x6a2a291f), SkBits2Float(0x42784f5a)); // 3.19903e+24f, 1.42932e+20f, 0, 5.14279e+25f, 62.0775f
10298path.close();
10299path.moveTo(SkBits2Float(0x654d6d10), SkBits2Float(0x00000000)); // 6.06311e+22f, 0
10300path.lineTo(SkBits2Float(0x6a4b7bc0), SkBits2Float(0x00000000)); // 6.14991e+25f, 0
10301path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6a4b7bc0)); // 0, 6.14991e+25f
10302path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
10303
10304 SkPath path1(path);
10305 path.reset();
10306 path.setFillType((SkPathFillType) 0);
10307path.moveTo(SkBits2Float(0x3ac23a55), SkBits2Float(0x2a292827)); // 0.00148184f, 1.50241e-13f
10308path.lineTo(SkBits2Float(0x63962be6), SkBits2Float(0x272a812a)); // 5.54035e+21f, 2.36623e-15f
10309
10310 SkPath path2(path);
10311 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
10312}

◆ fuzz763_7()

static void fuzz763_7 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10314 of file PathOpsOpTest.cpp.

10314 {
10315 SkPath path;
10316 path.setFillType((SkPathFillType) 0);
10317
10318 SkPath path1(path);
10319 path.reset();
10320 path.setFillType((SkPathFillType) 0);
10321path.moveTo(SkBits2Float(0x68556829), SkBits2Float(0x555b2d29)); // 4.03114e+24f, 1.50617e+13f
10322path.moveTo(SkBits2Float(0x0f2a312a), SkBits2Float(0xc0032108)); // 8.39112e-30f, -2.04889f
10323path.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
10324path.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
10325path.moveTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f
10326path.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
10327path.lineTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f
10328path.close();
10329path.moveTo(SkBits2Float(0x68345b2d), SkBits2Float(0xf0682955)); // 3.40683e+24f, -2.87402e+29f
10330path.lineTo(SkBits2Float(0x5b2c6829), SkBits2Float(0x212a8c55)); // 4.85282e+16f, 5.7784e-19f
10331path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10332path.lineTo(SkBits2Float(0x3a8a3adf), SkBits2Float(0x8a281a4f)); // 0.00105461f, -8.09385e-33f
10333path.quadTo(SkBits2Float(0x1d2a2928), SkBits2Float(0x43962be6), SkBits2Float(0x272a812a), SkBits2Float(0x3a2a5529)); // 2.25206e-21f, 300.343f, 2.36623e-15f, 0.000649768f
10334path.lineTo(SkBits2Float(0x213b1e2a), SkBits2Float(0x27292720)); // 6.3398e-19f, 2.34747e-15f
10335path.conicTo(SkBits2Float(0xba1f203a), SkBits2Float(0xc422c538), SkBits2Float(0x215d5927), SkBits2Float(0x70ec2ac2), SkBits2Float(0x2a51523a)); // -0.000607017f, -651.082f, 7.49957e-19f, 5.84721e+29f, 1.85915e-13f
10336path.quadTo(SkBits2Float(0x633ad912), SkBits2Float(0x29c80927), SkBits2Float(0x272927b0), SkBits2Float(0x683a5b2d)); // 3.44674e+21f, 8.88337e-14f, 2.3475e-15f, 3.52017e+24f
10337path.lineTo(SkBits2Float(0x295b2d68), SkBits2Float(0x29685568)); // 4.86672e-14f, 5.15884e-14f
10338path.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
10339path.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
10340path.quadTo(SkBits2Float(0x68295b21), SkBits2Float(0x2d296855), SkBits2Float(0x2a8c555b), SkBits2Float(0x081f2a21)); // 3.19904e+24f, 9.6297e-12f, 2.49282e-13f, 4.78968e-34f
10341path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10342path.close();
10343path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10344path.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
10345path.moveTo(SkBits2Float(0x2d212d08), SkBits2Float(0x5568295b)); // 9.16179e-12f, 1.5954e+13f
10346path.moveTo(SkBits2Float(0x5529685b), SkBits2Float(0x11295b68)); // 1.16416e+13f, 1.33599e-28f
10347path.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
10348path.moveTo(SkBits2Float(0x555b8c55), SkBits2Float(0x21682929)); // 1.50872e+13f, 7.86591e-19f
10349path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10350path.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
10351path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10352path.close();
10353path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10354path.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
10355path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10356path.close();
10357path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10358path.quadTo(SkBits2Float(0x2d28282a), SkBits2Float(0x5568295b), SkBits2Float(0x3a21df68), SkBits2Float(0x4f9a3a8a)); // 9.55861e-12f, 1.5954e+13f, 0.000617495f, 5.17506e+09f
10359path.lineTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10360path.close();
10361path.moveTo(SkBits2Float(0x0321081f), SkBits2Float(0x6a4b7bc0)); // 4.7323e-37f, 6.14991e+25f
10362path.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
10363
10364 SkPath path2(path);
10365 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
10366}

◆ fuzz763_9()

static void fuzz763_9 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9921 of file PathOpsOpTest.cpp.

9921 {
9922 SkPath path;
9923 path.setFillType((SkPathFillType) 1);
9924
9925 SkPath path1(path);
9926 path.reset();
9927 path.setFillType((SkPathFillType) 0);
9928path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
9929path.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
9930path.lineTo(SkBits2Float(0x7bc00321), SkBits2Float(0xed7a6a4b)); // 1.99397e+36f, -4.84373e+27f
9931path.lineTo(SkBits2Float(0x282a3a21), SkBits2Float(0x3a21df28)); // 9.4495e-15f, 0.000617492f
9932path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
9933path.close();
9934path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
9935path.quadTo(SkBits2Float(0x8a284f9a), SkBits2Float(0x3ac23ab3), SkBits2Float(0x1d2a2928), SkBits2Float(0x63962be6)); // -8.10388e-33f, 0.00148185f, 2.25206e-21f, 5.54035e+21f
9936path.moveTo(SkBits2Float(0x29272a81), SkBits2Float(0x2ab03a55)); // 3.71183e-14f, 3.13044e-13f
9937path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a214729), SkBits2Float(0xdf28282a), SkBits2Float(0x8a2f2121)); // 2.22225e-15f, 0.000615227f, -1.2117e+19f, -8.43217e-33f
9938path.quadTo(SkBits2Float(0x373b3a27), SkBits2Float(0x201fc4c1), SkBits2Float(0x27576c2a), SkBits2Float(0x5921c25d)); // 1.11596e-05f, 1.35329e-19f, 2.98959e-15f, 2.8457e+15f
9939path.quadTo(SkBits2Float(0x2720213b), SkBits2Float(0x3a214729), SkBits2Float(0xdf28282a), SkBits2Float(0x3a8a3a21)); // 2.22225e-15f, 0.000615227f, -1.2117e+19f, 0.00105459f
9940path.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
9941path.quadTo(SkBits2Float(0xd912102a), SkBits2Float(0x284f9a28), SkBits2Float(0xb38a1f30), SkBits2Float(0x3a3ac23a)); // -2.56957e+15f, 1.15242e-14f, -6.4318e-08f, 0.000712428f
9942path.lineTo(SkBits2Float(0xc809272a), SkBits2Float(0x29b02829)); // -140445, 7.82294e-14f
9943
9944 SkPath path2(path);
9945 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
9946}

◆ fuzz767834()

static void fuzz767834 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9517 of file PathOpsOpTest.cpp.

9517 {
9518 SkPath one;
9519 SkPath two;
9520one.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
9521
9522one.conicTo(SkBits2Float(0x02807252), SkBits2Float(0xee23000a), SkBits2Float(0x00000000), SkBits2Float(0x0fe00008), SkBits2Float(0x52526831)); // 1.88735e-37f, -1.26115e+28f, 0, 2.20881e-29f, 2.25923e+11f
9523
9524one.cubicTo(SkBits2Float(0x474d475a), SkBits2Float(0x72727252), SkBits2Float(0x72267272), SkBits2Float(0x535202ff), SkBits2Float(0x53535353), SkBits2Float(0x58943353)); // 52551.4f, 4.80215e+30f, 3.29682e+30f, 9.01993e+11f, 9.07636e+11f, 1.30359e+15f
9525
9526one.quadTo(SkBits2Float(0x52727272), SkBits2Float(0x52595252), SkBits2Float(0x8e460900), SkBits2Float(0x7272db72)); // 2.60326e+11f, 2.33347e+11f, -2.44097e-30f, 4.81028e+30f
9527
9528one.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
9529
9530one.close();
9531
9532one.moveTo(SkBits2Float(0x72000400), SkBits2Float(0x72727272)); // 2.53561e+30f, 4.80216e+30f
9533
9534one.quadTo(SkBits2Float(0x60727272), SkBits2Float(0x72727272), SkBits2Float(0x2a527272), SkBits2Float(0x72525252)); // 6.98806e+19f, 4.80216e+30f, 1.86915e-13f, 4.16585e+30f
9535
9536one.cubicTo(SkBits2Float(0x72727251), SkBits2Float(0x52617272), SkBits2Float(0x46032352), SkBits2Float(0x7272728e), SkBits2Float(0x5c527272), SkBits2Float(0x72726552)); // 4.80215e+30f, 2.42072e+11f, 8392.83f, 4.80217e+30f, 2.36942e+17f, 4.80114e+30f
9537
9538one.cubicTo(SkBits2Float(0x2b7280ff), SkBits2Float(0x7240ffff), SkBits2Float(0x72724960), SkBits2Float(0x52008072), SkBits2Float(0x72725230), SkBits2Float(0x5f727272)); // 8.61547e-13f, 3.82276e+30f, 4.79898e+30f, 1.37978e+11f, 4.79966e+30f, 1.74702e+19f
9539
9540one.lineTo(SkBits2Float(0x72000400), SkBits2Float(0x72727272)); // 2.53561e+30f, 4.80216e+30f
9541
9542one.close();
9543
9544one.moveTo(SkBits2Float(0x8e524603), SkBits2Float(0x72727272)); // -2.59182e-30f, 4.80216e+30f
9545
9546one.close();
9547
9548one.moveTo(SkBits2Float(0x8e524603), SkBits2Float(0x72727272)); // -2.59182e-30f, 4.80216e+30f
9549
9550one.quadTo(SkBits2Float(0x72725d72), SkBits2Float(0x52008072), SkBits2Float(0x00016552), SkBits2Float(0x72724000)); // 4.80053e+30f, 1.37978e+11f, 1.28182e-40f, 4.79826e+30f
9551
9552one.quadTo(SkBits2Float(0x00807272), SkBits2Float(0x392a5b25), SkBits2Float(0x72685768), SkBits2Float(0x000000ff)); // 1.1796e-38f, 0.000162464f, 4.602e+30f, 3.57331e-43f
9553
9554one.moveTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f
9555
9556one.quadTo(SkBits2Float(0x72727272), SkBits2Float(0xd2008072), SkBits2Float(0x8e460900), SkBits2Float(0x72727072)); // 4.80216e+30f, -1.37978e+11f, -2.44097e-30f, 4.802e+30f
9557
9558one.cubicTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x58943303), SkBits2Float(0x72727272), SkBits2Float(0x59525252), SkBits2Float(0x00090052), SkBits2Float(0x72000000)); // -1.29345e+20f, 1.30357e+15f, 4.80216e+30f, 3.70002e+15f, 8.26634e-40f, 2.5353e+30f
9559
9560one.quadTo(SkBits2Float(0x005252ec), SkBits2Float(0x72000400), SkBits2Float(0x72727272), SkBits2Float(0x72727272)); // 7.56026e-39f, 2.53561e+30f, 4.80216e+30f, 4.80216e+30f
9561
9562one.lineTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f
9563
9564one.close();
9565
9566one.moveTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f
9567
9568one.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x522a5272), SkBits2Float(0x20725252), SkBits2Float(0x72727251)); // 4.80216e+30f, 1.82882e+11f, 2.05254e-19f, 4.80215e+30f
9569
9570one.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x59525252), SkBits2Float(0x46090052), SkBits2Float(0x72db728e)); // 4.80216e+30f, 3.70002e+15f, 8768.08f, 8.69321e+30f
9571
9572one.quadTo(SkBits2Float(0x005252ec), SkBits2Float(0x72000400), SkBits2Float(0x72727272), SkBits2Float(0x72727272)); // 7.56026e-39f, 2.53561e+30f, 4.80216e+30f, 4.80216e+30f
9573
9574one.lineTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f
9575
9576one.close();
9577
9578one.moveTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f
9579
9580one.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x522a5272), SkBits2Float(0x20725252), SkBits2Float(0x72727251)); // 4.80216e+30f, 1.82882e+11f, 2.05254e-19f, 4.80215e+30f
9581
9582one.quadTo(SkBits2Float(0x52526172), SkBits2Float(0x8e460323), SkBits2Float(0x72727272), SkBits2Float(0x525c5272)); // 2.25894e+11f, -2.44069e-30f, 4.80216e+30f, 2.36569e+11f
9583
9584one.conicTo(SkBits2Float(0xff727272), SkBits2Float(0xff2b549b), SkBits2Float(0x607240ff), SkBits2Float(0x72727249), SkBits2Float(0x30520080)); // -3.22267e+38f, -2.27737e+38f, 6.98249e+19f, 4.80215e+30f, 7.63983e-10f
9585
9586one.lineTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f
9587
9588one.close();
9589
9590one.moveTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f
9591
9592one.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x0052525f), SkBits2Float(0x8e524603), SkBits2Float(0x72727272)); // 4.80216e+30f, 7.56006e-39f, -2.59182e-30f, 4.80216e+30f
9593
9594one.lineTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f
9595
9596one.close();
9597
9598one.moveTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f
9599
9600one.quadTo(SkBits2Float(0x72725d72), SkBits2Float(0x52008072), SkBits2Float(0x00016552), SkBits2Float(0x72724000)); // 4.80053e+30f, 1.37978e+11f, 1.28182e-40f, 4.79826e+30f
9601
9602one.quadTo(SkBits2Float(0x00807272), SkBits2Float(0x392a5b25), SkBits2Float(0x72685768), SkBits2Float(0x000000ff)); // 1.1796e-38f, 0.000162464f, 4.602e+30f, 3.57331e-43f
9603
9604one.moveTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f
9605
9606one.quadTo(SkBits2Float(0x72727272), SkBits2Float(0xd2008072), SkBits2Float(0x8e460900), SkBits2Float(0x72727072)); // 4.80216e+30f, -1.37978e+11f, -2.44097e-30f, 4.802e+30f
9607
9608one.cubicTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x58943303), SkBits2Float(0x72727272), SkBits2Float(0x59525252), SkBits2Float(0x46090052), SkBits2Float(0x72db728e)); // -1.29345e+20f, 1.30357e+15f, 4.80216e+30f, 3.70002e+15f, 8768.08f, 8.69321e+30f
9609
9610one.quadTo(SkBits2Float(0x005252ec), SkBits2Float(0x72000400), SkBits2Float(0x72727272), SkBits2Float(0x72727272)); // 7.56026e-39f, 2.53561e+30f, 4.80216e+30f, 4.80216e+30f
9611
9612one.lineTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f
9613
9614one.close();
9615
9616one.moveTo(SkBits2Float(0xe0e060e0), SkBits2Float(0x728f5740)); // -1.29345e+20f, 5.67831e+30f
9617
9618one.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x522a5272), SkBits2Float(0x20725252), SkBits2Float(0x72727251)); // 4.80216e+30f, 1.82882e+11f, 2.05254e-19f, 4.80215e+30f
9619
9620 testPathOpFuzz(reporter, two, one, kIntersect_SkPathOp, filename);
9621}
SkPath::quadTo
SkPath & quadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2)
Definition SkPath.cpp:736

◆ fuzzhang_1()

static void fuzzhang_1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 12171 of file PathOpsOpTest.cpp.

12171 {
12172 SkPath path;
12173 path.setFillType((SkPathFillType) 1);
12174path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12175path.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
12176path.conicTo(SkBits2Float(0x66f837a9), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x00000000), SkBits2Float(0x3f823406)); // 5.86087e+23f, 0, 0, 0, 1.01721f
12177path.close();
12178path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12179path.quadTo(SkBits2Float(0x675b1bfe), SkBits2Float(0x00000000), SkBits2Float(0x67d76c42), SkBits2Float(0x6292c469)); // 1.03471e+24f, 0, 2.03461e+24f, 1.35369e+21f
12180path.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
12181path.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
12182path.quadTo(SkBits2Float(0x679e1b26), SkBits2Float(0x687703c4), SkBits2Float(0x00000000), SkBits2Float(0x687d2968)); // 1.49327e+24f, 4.66598e+24f, 0, 4.78209e+24f
12183path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12184path.close();
12185
12186 SkPath path1(path);
12187 path.reset();
12188 path.setFillType((SkPathFillType) 0);
12189path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12190path.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
12191path.quadTo(SkBits2Float(0xf8f8c0ed), SkBits2Float(0xf8f8f8f8), SkBits2Float(0x9f9f9f9f), SkBits2Float(0x3014149f)); // -4.03626e+34f, -4.03981e+34f, -6.76032e-20f, 5.38714e-10f
12192
12193 SkPath path2(path);
12194 testPathOp(reporter, path1, path2, (SkPathOp) 0, filename);
12195}

◆ fuzzhang_2()

static void fuzzhang_2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 12273 of file PathOpsOpTest.cpp.

12273 {
12274 SkPath path;
12275 path.setFillType((SkPathFillType) 0);
12276path.setFillType(SkPathFillType::kWinding);
12277path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
12278path.quadTo(SkBits2Float(0xe0e02972), SkBits2Float(0xe0e060e0), SkBits2Float(0x728e4603), SkBits2Float(0x72727272)); // -1.29221e+20f, -1.29345e+20f, 5.63603e+30f, 4.80216e+30f
12279path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
12280path.close();
12281path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
12282path.quadTo(SkBits2Float(0x68720052), SkBits2Float(0x52527372), SkBits2Float(0x00527252), SkBits2Float(0x728e4601)); // 4.57127e+24f, 2.2597e+11f, 7.57152e-39f, 5.63603e+30f
12283path.quadTo(SkBits2Float(0x52ec7272), SkBits2Float(0x6265527f), SkBits2Float(0x8e460152), SkBits2Float(0x72ff8072)); // 5.07766e+11f, 1.05756e+21f, -2.4406e-30f, 1.01215e+31f
12284path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
12285path.close();
12286path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
12287path.lineTo(SkBits2Float(0x52626552), SkBits2Float(0x72727272)); // 2.43091e+11f, 4.80216e+30f
12288path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x62727272), SkBits2Float(0x39393939), SkBits2Float(0x728bc739)); // 4.80216e+30f, 1.11809e+21f, 0.000176643f, 5.53719e+30f
12289path.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
12290path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x56727272), SkBits2Float(0x72720152), SkBits2Float(0x72727270)); // 4.80216e+30f, 6.66433e+13f, 4.79341e+30f, 4.80216e+30f
12291path.quadTo(SkBits2Float(0x52526172), SkBits2Float(0x8e460300), SkBits2Float(0x72727272), SkBits2Float(0x52525272)); // 2.25894e+11f, -2.44068e-30f, 4.80216e+30f, 2.25832e+11f
12292path.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
12293path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
12294path.close();
12295path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
12296path.lineTo(SkBits2Float(0x72727272), SkBits2Float(0x52525f72)); // 4.80216e+30f, 2.25886e+11f
12297path.lineTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
12298path.close();
12299path.moveTo(SkBits2Float(0x5568392a), SkBits2Float(0x72837268)); // 1.59583e+13f, 5.20715e+30f
12300path.quadTo(SkBits2Float(0x52727272), SkBits2Float(0x64655252), SkBits2Float(0x72c1c152), SkBits2Float(0x72727272)); // 2.60326e+11f, 1.69209e+22f, 7.67543e+30f, 4.80216e+30f
12301
12302 SkPath path1(path);
12303 path.reset();
12304 path.setFillType((SkPathFillType) 0);
12305path.setFillType(SkPathFillType::kWinding);
12306
12307 SkPath path2(path);
12308 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 1, filename);
12309}

◆ fuzzhang_3()

static void fuzzhang_3 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 12311 of file PathOpsOpTest.cpp.

12311 {
12312 SkPath path;
12313 path.setFillType((SkPathFillType) 0);
12314path.setFillType(SkPathFillType::kWinding);
12315
12316 SkPath path1(path);
12317 path.reset();
12318 path.setFillType((SkPathFillType) 0);
12319path.setFillType(SkPathFillType::kWinding);
12320path.moveTo(SkBits2Float(0x46090052), SkBits2Float(0x7270726c)); // 8768.08f, 4.76254e+30f
12321path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
12322path.close();
12323path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
12324path.lineTo(SkBits2Float(0x77727272), SkBits2Float(0x52520072)); // 4.91741e+33f, 2.25488e+11f
12325path.lineTo(SkBits2Float(0x46090052), SkBits2Float(0x727272ce)); // 8768.08f, 4.80219e+30f
12326path.quadTo(SkBits2Float(0x725252ec), SkBits2Float(0x72727272), SkBits2Float(0x72727272), SkBits2Float(0x39393962)); // 4.16589e+30f, 4.80216e+30f, 4.80216e+30f, 0.000176644f
12327path.lineTo(SkBits2Float(0x6c460900), SkBits2Float(0x72727072)); // 9.57639e+26f, 4.802e+30f
12328path.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
12329path.quadTo(SkBits2Float(0x725252ec), SkBits2Float(0x72727272), SkBits2Float(0x72727272), SkBits2Float(0x39393962)); // 4.16589e+30f, 4.80216e+30f, 4.80216e+30f, 0.000176644f
12330path.lineTo(SkBits2Float(0x0052ca00), SkBits2Float(0x728e4603)); // 7.60297e-39f, 5.63603e+30f
12331path.quadTo(SkBits2Float(0xff727272), SkBits2Float(0x52527272), SkBits2Float(0x39392072), SkBits2Float(0xe0393939)); // -3.22267e+38f, 2.25966e+11f, 0.000176551f, -5.3387e+19f
12332path.lineTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
12333path.close();
12334path.moveTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
12335path.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
12336path.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
12337path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0xdada0072), SkBits2Float(0x52524b5a), SkBits2Float(0x72528000)); // 4.79991e+30f, -3.0681e+16f, 2.25802e+11f, 4.16938e+30f
12338path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0xca005252), SkBits2Float(0x46030052), SkBits2Float(0x7272728e)); // 4.80216e+30f, -2.10242e+06f, 8384.08f, 4.80217e+30f
12339path.quadTo(SkBits2Float(0x7272ff72), SkBits2Float(0x20725252), SkBits2Float(0x39393939), SkBits2Float(0xd76ee039)); // 4.81307e+30f, 2.05254e-19f, 0.000176643f, -2.62647e+14f
12340path.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
12341path.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
12342path.quadTo(SkBits2Float(0x72725572), SkBits2Float(0xdada0072), SkBits2Float(0x52524b5a), SkBits2Float(0x72528000)); // 4.79991e+30f, -3.0681e+16f, 2.25802e+11f, 4.16938e+30f
12343path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
12344path.quadTo(SkBits2Float(0x72667254), SkBits2Float(0x00000040), SkBits2Float(0x00a70155), SkBits2Float(0x726800ff)); // 4.56447e+30f, 8.96831e-44f, 1.5337e-38f, 4.59531e+30f
12345path.quadTo(SkBits2Float(0x7b727272), SkBits2Float(0xad000c52), SkBits2Float(0x1c10adad), SkBits2Float(0x72728d8a)); // 1.25886e+36f, -7.27869e-12f, 4.78701e-22f, 4.80425e+30f
12346path.quadTo(SkBits2Float(0xff056546), SkBits2Float(0x727205ff), SkBits2Float(0x524b5aff), SkBits2Float(0x64005252)); // -1.77313e+38f, 4.79377e+30f, 2.18351e+11f, 9.46846e+21f
12347path.quadTo(SkBits2Float(0x72524872), SkBits2Float(0xdada7272), SkBits2Float(0x5252525a), SkBits2Float(0x72727252)); // 4.16508e+30f, -3.07437e+16f, 2.25831e+11f, 4.80215e+30f
12348path.quadTo(SkBits2Float(0x72724172), SkBits2Float(0xdad10072), SkBits2Float(0x52524b5a), SkBits2Float(0x725b8000)); // 4.79837e+30f, -2.94144e+16f, 2.25802e+11f, 4.34765e+30f
12349path.quadTo(SkBits2Float(0x72727272), SkBits2Float(0x52525252), SkBits2Float(0x27725252), SkBits2Float(0x72727272)); // 4.80216e+30f, 2.25831e+11f, 3.36289e-15f, 4.80216e+30f
12350path.quadTo(SkBits2Float(0x72728372), SkBits2Float(0x00000040), SkBits2Float(0xf6a70147), SkBits2Float(0xc2c2c256)); // 4.80347e+30f, 8.96831e-44f, -1.69363e+33f, -97.3796f
12351path.lineTo(SkBits2Float(0xe0437272), SkBits2Float(0x03e0e060)); // -5.63338e+19f, 1.32171e-36f
12352path.close();
12353path.moveTo(SkBits2Float(0x7a787a7a), SkBits2Float(0x7a3a7a7a)); // 3.22543e+35f, 2.42063e+35f
12354path.lineTo(SkBits2Float(0x8f4603e0), SkBits2Float(0x72727272)); // -9.7629e-30f, 4.80216e+30f
12355path.quadTo(SkBits2Float(0x00807272), SkBits2Float(0x46090052), SkBits2Float(0x7270726c), SkBits2Float(0x60e04372)); // 1.1796e-38f, 8768.08f, 4.76254e+30f, 1.29279e+20f
12356path.moveTo(SkBits2Float(0x943603e0), SkBits2Float(0x77727272)); // -9.18942e-27f, 4.91741e+33f
12357path.quadTo(SkBits2Float(0x5c525200), SkBits2Float(0x46090052), SkBits2Float(0x727272ce), SkBits2Float(0x5252ec72)); // 2.368e+17f, 8768.08f, 4.80219e+30f, 2.26478e+11f
12358
12359 SkPath path2(path);
12360 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 3, filename);
12361}

◆ fuzzX_392()

static void fuzzX_392 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5217 of file PathOpsOpTest.cpp.

5217 {
5218 SkPath path;
5219 path.setFillType(SkPathFillType::kEvenOdd);
5220path.moveTo(SkBits2Float(0x41e80000), SkBits2Float(0x43bde212)); // 29, 379.766f
5221path.lineTo(SkBits2Float(0x41e80000), SkBits2Float(0x43bdc7ef)); // 29, 379.562f
5222path.conicTo(SkBits2Float(0x42a5861e), SkBits2Float(0x43c61f86), SkBits2Float(0x430b0610), SkBits2Float(0x43c61f86), SkBits2Float(0x3f7d23f3)); // 82.7619f, 396.246f, 139.024f, 396.246f, 0.98883f
5223path.conicTo(SkBits2Float(0x42a58e20), SkBits2Float(0x43c61f86), SkBits2Float(0x41e80000), SkBits2Float(0x43bde212), SkBits2Float(0x3f7d2cf5)); // 82.7776f, 396.246f, 29, 379.766f, 0.988967f
5224path.close();
5225
5226 SkPath path1(path);
5227 path.setFillType(SkPathFillType::kWinding);
5228path.moveTo(SkBits2Float(0xc36c7bd8), SkBits2Float(0xc3a31d72)); // -236.484f, -326.23f
5229path.lineTo(SkBits2Float(0xc367a4ae), SkBits2Float(0xc3a31d72)); // -231.643f, -326.23f
5230path.lineTo(SkBits2Float(0x430b0610), SkBits2Float(0x43c61f86)); // 139.024f, 396.246f
5231path.lineTo(SkBits2Float(0xc36c7bd8), SkBits2Float(0x43c61f86)); // -236.484f, 396.246f
5232
5233 SkPath path2(path);
5234 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename);
5235}

◆ grshapearcs1()

static void grshapearcs1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5819 of file PathOpsOpTest.cpp.

5819 {
5820SkPath path, path1;
5821path.setFillType(SkPathFillType::kWinding);
5822path.moveTo(25.0098f, 23.1973f);
5823path.lineTo(25.5689f, 22.3682f);
5824path.conicTo(26.1281f, 21.5392f, 26.9572f, 22.0984f, 0.707107f);
5825path.conicTo(27.7862f, 22.6576f, 27.227f, 23.4866f, 0.707107f);
5826path.lineTo(26.6678f, 24.3156f);
5827path.conicTo(26.1086f, 25.1447f, 25.2796f, 24.5855f, 0.707107f);
5828path.conicTo(24.4506f, 24.0263f, 25.0098f, 23.1973f, 0.707107f);
5829path.close();
5830path.moveTo(26.6873f, 20.7101f);
5831path.lineTo(27.2465f, 19.8811f);
5832path.conicTo(27.8057f, 19.0521f, 28.6348f, 19.6113f, 0.707107f);
5833path.conicTo(29.4638f, 20.1704f, 28.9046f, 20.9995f, 0.707107f);
5834path.lineTo(28.3454f, 21.8285f);
5835path.conicTo(27.7862f, 22.6576f, 26.9572f, 22.0984f, 0.707107f);
5836path.conicTo(26.1281f, 21.5392f, 26.6873f, 20.7101f, 0.707107f);
5837path.close();
5838path.moveTo(28.3649f, 18.223f);
5839path.lineTo(28.9241f, 17.394f);
5840path.conicTo(29.4833f, 16.565f, 30.3123f, 17.1241f, 0.707107f);
5841path.conicTo(31.1414f, 17.6833f, 30.5822f, 18.5124f, 0.707107f);
5842path.lineTo(30.023f, 19.3414f);
5843path.conicTo(29.4638f, 20.1704f, 28.6348f, 19.6113f, 0.707107f);
5844path.conicTo(27.8057f, 19.0521f, 28.3649f, 18.223f, 0.707107f);
5845path.close();
5846path.moveTo(30.0425f, 15.7359f);
5847path.lineTo(30.6017f, 14.9069f);
5848path.conicTo(31.1609f, 14.0778f, 31.9899f, 14.637f, 0.707107f);
5849path.conicTo(32.8189f, 15.1962f, 32.2598f, 16.0253f, 0.707107f);
5850path.lineTo(31.7006f, 16.8543f);
5851path.conicTo(31.1414f, 17.6833f, 30.3123f, 17.1241f, 0.707107f);
5852path.conicTo(29.4833f, 16.565f, 30.0425f, 15.7359f, 0.707107f);
5853path.close();
5854path.moveTo(31.7201f, 13.2488f);
5855path.lineTo(32.2793f, 12.4198f);
5856path.conicTo(32.8385f, 11.5907f, 33.6675f, 12.1499f, 0.707107f);
5857path.conicTo(34.4965f, 12.7091f, 33.9373f, 13.5381f, 0.707107f);
5858path.lineTo(33.3781f, 14.3672f);
5859path.conicTo(32.8189f, 15.1962f, 31.9899f, 14.637f, 0.707107f);
5860path.conicTo(31.1609f, 14.0778f, 31.7201f, 13.2488f, 0.707107f);
5861path.close();
5862path.moveTo(33.3976f, 10.7617f);
5863path.lineTo(33.9568f, 9.93265f);
5864path.conicTo(34.516f, 9.10361f, 35.3451f, 9.6628f, 0.707107f);
5865path.conicTo(36.1741f, 10.222f, 35.6149f, 11.051f, 0.707107f);
5866path.lineTo(35.0557f, 11.8801f);
5867path.conicTo(34.4965f, 12.7091f, 33.6675f, 12.1499f, 0.707107f);
5868path.conicTo(32.8385f, 11.5907f, 33.3976f, 10.7617f, 0.707107f);
5869path.close();
5870path.moveTo(35.0752f, 8.27457f);
5871path.lineTo(35.6344f, 7.44554f);
5872path.conicTo(36.1936f, 6.6165f, 37.0226f, 7.17569f, 0.707107f);
5873path.conicTo(37.8517f, 7.73488f, 37.2925f, 8.56392f, 0.707107f);
5874path.lineTo(36.7333f, 9.39296f);
5875path.conicTo(36.1741f, 10.222f, 35.3451f, 9.6628f, 0.707107f);
5876path.conicTo(34.516f, 9.10361f, 35.0752f, 8.27457f, 0.707107f);
5877path.close();
5878path.moveTo(36.7528f, 5.78746f);
5879path.lineTo(37.312f, 4.95842f);
5880path.conicTo(37.8712f, 4.12939f, 38.7002f, 4.68858f, 0.707107f);
5881path.conicTo(39.5293f, 5.24777f, 38.9701f, 6.07681f, 0.707107f);
5882path.lineTo(38.4109f, 6.90585f);
5883path.conicTo(37.8517f, 7.73488f, 37.0226f, 7.17569f, 0.707107f);
5884path.conicTo(36.1936f, 6.6165f, 36.7528f, 5.78746f, 0.707107f);
5885path.close();
5886path.moveTo(39.9447f, 3.72429f);
5887path.quadTo(40.3524f, 4.01069f, 40.7489f, 4.31248f);
5888path.conicTo(41.5445f, 4.9182f, 40.9388f, 5.71387f, 0.707107f);
5889path.conicTo(40.3331f, 6.50955f, 39.5374f, 5.90383f, 0.707107f);
5890path.quadTo(39.1714f, 5.62521f, 38.7951f, 5.36088f);
5891path.conicTo(37.9768f, 4.78608f, 38.5516f, 3.96779f, 0.707107f);
5892path.conicTo(39.1264f, 3.14949f, 39.9447f, 3.72429f, 0.707107f);
5893path.close();
5894path.moveTo(42.3194f, 5.60826f);
5895path.quadTo(42.707f, 5.95446f, 43.0804f, 6.31583f);
5896path.conicTo(43.7991f, 7.01122f, 43.1037f, 7.72985f, 0.707107f);
5897path.conicTo(42.4083f, 8.44848f, 41.6896f, 7.75308f, 0.707107f);
5898path.quadTo(41.3448f, 7.41944f, 40.9871f, 7.09992f);
5899path.conicTo(40.2413f, 6.43379f, 40.9074f, 5.68796f, 0.707107f);
5900path.conicTo(41.5735f, 4.94212f, 42.3194f, 5.60826f, 0.707107f);
5901path.close();
5902path.moveTo(44.5406f, 7.84871f);
5903path.quadTo(44.8959f, 8.25352f, 45.2341f, 8.67266f);
5904path.conicTo(45.862f, 9.4509f, 45.0838f, 10.0789f, 0.707107f);
5905path.conicTo(44.3056f, 10.7068f, 43.6776f, 9.9286f, 0.707107f);
5906path.quadTo(43.3654f, 9.54174f, 43.0374f, 9.16805f);
5907path.conicTo(42.3778f, 8.41649f, 43.1293f, 7.75682f, 0.707107f);
5908path.conicTo(43.8809f, 7.09715f, 44.5406f, 7.84871f, 0.707107f);
5909path.close();
5910path.moveTo(46.528f, 10.4211f);
5911path.quadTo(46.815f, 10.8449f, 47.0851f, 11.2796f);
5912path.conicTo(47.6128f, 12.129f, 46.7633f, 12.6567f, 0.707107f);
5913path.conicTo(45.9139f, 13.1844f, 45.3862f, 12.335f, 0.707107f);
5914path.quadTo(45.1369f, 11.9337f, 44.872f, 11.5426f);
5915path.conicTo(44.3113f, 10.7146f, 45.1393f, 10.1538f, 0.707107f);
5916path.conicTo(45.9673f, 9.5931f, 46.528f, 10.4211f, 0.707107f);
5917path.close();
5918path.moveTo(48.1056f, 13.0782f);
5919path.quadTo(48.3449f, 13.542f, 48.5654f, 14.015f);
5920path.conicTo(48.9879f, 14.9213f, 48.0816f, 15.3438f, 0.707107f);
5921path.conicTo(47.1752f, 15.7663f, 46.7527f, 14.86f, 0.707107f);
5922path.quadTo(46.5492f, 14.4234f, 46.3283f, 13.9953f);
5923path.conicTo(45.8698f, 13.1066f, 46.7584f, 12.6481f, 0.707107f);
5924path.conicTo(47.6471f, 12.1895f, 48.1056f, 13.0782f, 0.707107f);
5925path.close();
5926path.moveTo(49.3755f, 15.9538f);
5927path.quadTo(49.5594f, 16.4493f, 49.7229f, 16.9516f);
5928path.conicTo(50.0325f, 17.9025f, 49.0816f, 18.2121f, 0.707107f);
5929path.conicTo(48.1307f, 18.5216f, 47.8212f, 17.5707f, 0.707107f);
5930path.quadTo(47.6702f, 17.1069f, 47.5005f, 16.6497f);
5931path.conicTo(47.1526f, 15.7122f, 48.0901f, 15.3642f, 0.707107f);
5932path.conicTo(49.0276f, 15.0163f, 49.3755f, 15.9538f, 0.707107f);
5933path.close();
5934path.moveTo(50.2964f, 18.9923f);
5935path.quadTo(50.4191f, 19.5089f, 50.5206f, 20.0302f);
5936path.conicTo(50.7117f, 21.0117f, 49.7302f, 21.2029f, 0.707107f);
5937path.conicTo(48.7486f, 21.394f, 48.5575f, 20.4125f, 0.707107f);
5938path.quadTo(48.4638f, 19.9313f, 48.3505f, 19.4544f);
5939path.conicTo(48.1194f, 18.4815f, 49.0924f, 18.2504f, 0.707107f);
5940path.conicTo(50.0653f, 18.0193f, 50.2964f, 18.9923f, 0.707107f);
5941path.close();
5942path.moveTo(50.8373f, 22.0956f);
5943path.quadTo(50.8955f, 22.6138f, 50.933f, 23.1341f);
5944path.conicTo(51.0047f, 24.1315f, 50.0073f, 24.2033f, 0.707107f);
5945path.conicTo(49.0099f, 24.275f, 48.9381f, 23.2776f, 0.707107f);
5946path.quadTo(48.9036f, 22.7975f, 48.8498f, 22.3191f);
5947path.conicTo(48.7381f, 21.3253f, 49.7318f, 21.2136f, 0.707107f);
5948path.conicTo(50.7255f, 21.1019f, 50.8373f, 22.0956f, 0.707107f);
5949path.close();
5950path.moveTo(50.9992f, 25.2099f);
5951path.quadTo(50.9949f, 25.7358f, 50.9694f, 26.2608f);
5952path.conicTo(50.9209f, 27.2596f, 49.9221f, 27.2111f, 0.707107f);
5953path.conicTo(48.9233f, 27.1626f, 48.9718f, 26.1638f, 0.707107f);
5954path.quadTo(48.9953f, 25.679f, 48.9992f, 25.1938f);
5955path.conicTo(49.0073f, 24.1938f, 50.0073f, 24.2019f, 0.707107f);
5956path.conicTo(51.0072f, 24.21f, 50.9992f, 25.2099f, 0.707107f);
5957path.close();
5958path.moveTo(50.7839f, 28.3454f);
5959path.quadTo(50.7172f, 28.8596f, 50.63f, 29.3708f);
5960path.conicTo(50.4619f, 30.3565f, 49.4761f, 30.1884f, 0.707107f);
5961path.conicTo(48.4903f, 30.0203f, 48.6584f, 29.0346f, 0.707107f);
5962path.quadTo(48.7389f, 28.5627f, 48.8005f, 28.088f);
5963path.conicTo(48.9292f, 27.0963f, 49.9209f, 27.225f, 0.707107f);
5964path.conicTo(50.9126f, 27.3537f, 50.7839f, 28.3454f, 0.707107f);
5965path.close();
5966path.moveTo(50.1906f, 31.437f);
5967path.quadTo(50.0558f, 31.9646f, 49.899f, 32.4861f);
5968path.conicTo(49.611f, 33.4438f, 48.6534f, 33.1558f, 0.707107f);
5969path.conicTo(47.6957f, 32.8679f, 47.9837f, 31.9103f, 0.707107f);
5970path.quadTo(48.1284f, 31.4289f, 48.2528f, 30.9418f);
5971path.conicTo(48.5004f, 29.9729f, 49.4693f, 30.2205f, 0.707107f);
5972path.conicTo(50.4382f, 30.4681f, 50.1906f, 31.437f, 0.707107f);
5973path.close();
5974path.moveTo(49.1978f, 34.5114f);
5975path.quadTo(49.0051f, 35.0016f, 48.7927f, 35.4837f);
5976path.conicTo(48.3895f, 36.3988f, 47.4744f, 35.9956f, 0.707107f);
5977path.conicTo(46.5593f, 35.5923f, 46.9625f, 34.6772f, 0.707107f);
5978path.quadTo(47.1586f, 34.2323f, 47.3364f, 33.7797f);
5979path.conicTo(47.7023f, 32.849f, 48.6329f, 33.2149f, 0.707107f);
5980path.conicTo(49.5636f, 33.5807f, 49.1978f, 34.5114f, 0.707107f);
5981path.close();
5982path.moveTo(47.8852f, 37.3397f);
5983path.quadTo(47.6449f, 37.7853f, 47.3876f, 38.2211f);
5984path.conicTo(46.879f, 39.0821f, 46.018f, 38.5736f, 0.707107f);
5985path.conicTo(45.1569f, 38.0651f, 45.6655f, 37.204f, 0.707107f);
5986path.quadTo(45.903f, 36.8018f, 46.1248f, 36.3906f);
5987path.conicTo(46.5993f, 35.5103f, 47.4796f, 35.9849f, 0.707107f);
5988path.conicTo(48.3598f, 36.4595f, 47.8852f, 37.3397f, 0.707107f);
5989path.close();
5990path.moveTo(46.3154f, 39.8881f);
5991path.quadTo(46.0303f, 40.2962f, 45.7299f, 40.693f);
5992path.conicTo(45.1264f, 41.4903f, 44.3291f, 40.8867f, 0.707107f);
5993path.conicTo(43.5318f, 40.2831f, 44.1353f, 39.4858f, 0.707107f);
5994path.quadTo(44.4126f, 39.1195f, 44.6757f, 38.7428f);
5995path.conicTo(45.2483f, 37.923f, 46.0682f, 38.4956f, 0.707107f);
5996path.conicTo(46.888f, 39.0682f, 46.3154f, 39.8881f, 0.707107f);
5997path.close();
5998path.moveTo(44.4398f, 42.2654f);
5999path.quadTo(44.095f, 42.6536f, 43.7349f, 43.0278f);
6000path.conicTo(43.0415f, 43.7484f, 42.321f, 43.055f, 0.707107f);
6001path.conicTo(41.6004f, 42.3616f, 42.2938f, 41.641f, 0.707107f);
6002path.quadTo(42.6261f, 41.2957f, 42.9444f, 40.9374f);
6003path.conicTo(43.6084f, 40.1897f, 44.3561f, 40.8537f, 0.707107f);
6004path.conicTo(45.1038f, 41.5177f, 44.4398f, 42.2654f, 0.707107f);
6005path.close();
6006path.moveTo(42.2075f, 44.4911f);
6007path.quadTo(41.804f, 44.8473f, 41.3862f, 45.1865f);
6008path.conicTo(40.6098f, 45.8167f, 39.9795f, 45.0403f, 0.707107f);
6009path.conicTo(39.3493f, 44.2639f, 40.1257f, 43.6336f, 0.707107f);
6010path.quadTo(40.5114f, 43.3205f, 40.8838f, 42.9918f);
6011path.conicTo(41.6335f, 42.3299f, 42.2953f, 43.0796f, 0.707107f);
6012path.conicTo(42.9572f, 43.8292f, 42.2075f, 44.4911f, 0.707107f);
6013path.close();
6014path.moveTo(39.6379f, 46.488f);
6015path.quadTo(39.2151f, 46.776f, 38.7814f, 47.0471f);
6016path.conicTo(37.9334f, 47.5771f, 37.4034f, 46.7292f, 0.707107f);
6017path.conicTo(36.8733f, 45.8812f, 37.7213f, 45.3511f, 0.707107f);
6018path.quadTo(38.1217f, 45.1009f, 38.5119f, 44.835f);
6019path.conicTo(39.3383f, 44.2721f, 39.9013f, 45.0985f, 0.707107f);
6020path.conicTo(40.4643f, 45.925f, 39.6379f, 46.488f, 0.707107f);
6021path.close();
6022path.moveTo(36.9864f, 48.0722f);
6023path.quadTo(36.5234f, 48.3127f, 36.0513f, 48.5344f);
6024path.conicTo(35.1461f, 48.9595f, 34.7211f, 48.0543f, 0.707107f);
6025path.conicTo(34.296f, 47.1491f, 35.2012f, 46.7241f, 0.707107f);
6026path.quadTo(35.6371f, 46.5194f, 36.0644f, 46.2974f);
6027path.conicTo(36.9518f, 45.8364f, 37.4128f, 46.7238f, 0.707107f);
6028path.conicTo(37.8738f, 47.6112f, 36.9864f, 48.0722f, 0.707107f);
6029path.close();
6030path.moveTo(34.1153f, 49.3498f);
6031path.quadTo(33.6206f, 49.535f, 33.1187f, 49.6999f);
6032path.conicTo(32.1687f, 50.0122f, 31.8565f, 49.0622f, 0.707107f);
6033path.conicTo(31.5442f, 48.1122f, 32.4942f, 47.7999f, 0.707107f);
6034path.quadTo(32.9575f, 47.6477f, 33.4141f, 47.4767f);
6035path.conicTo(34.3507f, 47.1261f, 34.7012f, 48.0627f, 0.707107f);
6036path.conicTo(35.0518f, 48.9992f, 34.1153f, 49.3498f, 0.707107f);
6037path.close();
6038path.moveTo(31.08f, 50.2791f);
6039path.quadTo(30.5637f, 50.4033f, 30.0427f, 50.5063f);
6040path.conicTo(29.0617f, 50.7002f, 28.8678f, 49.7192f, 0.707107f);
6041path.conicTo(28.6738f, 48.7382f, 29.6548f, 48.5443f, 0.707107f);
6042path.quadTo(30.1357f, 48.4492f, 30.6122f, 48.3346f);
6043path.conicTo(31.5845f, 48.1007f, 31.8184f, 49.073f, 0.707107f);
6044path.conicTo(32.0522f, 50.0453f, 31.08f, 50.2791f, 0.707107f);
6045path.close();
6046path.moveTo(27.9769f, 50.829f);
6047path.quadTo(27.4588f, 50.8887f, 26.9386f, 50.9276f);
6048path.conicTo(25.9414f, 51.0022f, 25.8668f, 50.005f, 0.707107f);
6049path.conicTo(25.7923f, 49.0078f, 26.7895f, 48.9332f, 0.707107f);
6050path.quadTo(27.2696f, 48.8973f, 27.7479f, 48.8422f);
6051path.conicTo(28.7413f, 48.7277f, 28.8558f, 49.7211f, 0.707107f);
6052path.conicTo(28.9703f, 50.7145f, 27.9769f, 50.829f, 0.707107f);
6053path.close();
6054path.moveTo(24.8625f, 50.9996f);
6055path.quadTo(24.3373f, 50.9969f, 23.8128f, 50.9729f);
6056path.conicTo(22.8138f, 50.9272f, 22.8595f, 49.9283f, 0.707107f);
6057path.conicTo(22.9051f, 48.9293f, 23.9041f, 48.975f, 0.707107f);
6058path.quadTo(24.3884f, 48.9971f, 24.8731f, 48.9997f);
6059path.conicTo(25.8731f, 49.005f, 25.8678f, 50.005f, 0.707107f);
6060path.conicTo(25.8624f, 51.0049f, 24.8625f, 50.9996f, 0.707107f);
6061path.close();
6062path.moveTo(21.7268f, 50.7931f);
6063path.quadTo(21.2121f, 50.7278f, 20.7005f, 50.642f);
6064path.conicTo(19.7143f, 50.4767f, 19.8796f, 49.4905f, 0.707107f);
6065path.conicTo(20.045f, 48.5042f, 21.0312f, 48.6696f, 0.707107f);
6066path.quadTo(21.5036f, 48.7488f, 21.9786f, 48.8091f);
6067path.conicTo(22.9707f, 48.9349f, 22.8448f, 49.927f, 0.707107f);
6068path.conicTo(22.7189f, 50.919f, 21.7268f, 50.7931f, 0.707107f);
6069path.close();
6070path.moveTo(18.6372f, 50.2094f);
6071path.quadTo(18.1089f, 50.0761f, 17.5865f, 49.9207f);
6072path.conicTo(16.628f, 49.6356f, 16.9132f, 48.6771f, 0.707107f);
6073path.conicTo(17.1983f, 47.7186f, 18.1568f, 48.0037f, 0.707107f);
6074path.quadTo(18.639f, 48.1472f, 19.1267f, 48.2702f);
6075path.conicTo(20.0963f, 48.515f, 19.8516f, 49.4846f, 0.707107f);
6076path.conicTo(19.6068f, 50.4542f, 18.6372f, 50.2094f, 0.707107f);
6077path.close();
6078path.moveTo(15.5577f, 49.2248f);
6079path.quadTo(15.0665f, 49.0334f, 14.5834f, 48.8222f);
6080path.conicTo(13.6672f, 48.4215f, 14.0678f, 47.5053f, 0.707107f);
6081path.conicTo(14.4684f, 46.589f, 15.3847f, 46.9897f, 0.707107f);
6082path.quadTo(15.8306f, 47.1846f, 16.284f, 47.3614f);
6083path.conicTo(17.2158f, 47.7246f, 16.8526f, 48.6563f, 0.707107f);
6084path.conicTo(16.4894f, 49.588f, 15.5577f, 49.2248f, 0.707107f);
6085path.close();
6086path.moveTo(12.7231f, 47.9189f);
6087path.quadTo(12.2765f, 47.6797f, 11.8395f, 47.4233f);
6088path.conicTo(10.9771f, 46.9171f, 11.4833f, 46.0547f, 0.707107f);
6089path.conicTo(11.9894f, 45.1922f, 12.8519f, 45.6984f, 0.707107f);
6090path.quadTo(13.2552f, 45.9351f, 13.6675f, 46.156f);
6091path.conicTo(14.549f, 46.6282f, 14.0768f, 47.5096f, 0.707107f);
6092path.conicTo(13.6046f, 48.3911f, 12.7231f, 47.9189f, 0.707107f);
6093path.close();
6094path.moveTo(10.1686f, 46.3548f);
6095path.quadTo(9.76024f, 46.0712f, 9.363f, 45.7722f);
6096path.conicTo(8.56406f, 45.1708f, 9.16549f, 44.3718f, 0.707107f);
6097path.conicTo(9.76691f, 43.5729f, 10.5658f, 44.1743f, 0.707107f);
6098path.quadTo(10.9325f, 44.4504f, 11.3095f, 44.7122f);
6099path.conicTo(12.1308f, 45.2826f, 11.5604f, 46.1039f, 0.707107f);
6100path.conicTo(10.9899f, 46.9253f, 10.1686f, 46.3548f, 0.707107f);
6101path.close();
6102path.moveTo(7.78853f, 44.4876f);
6103path.quadTo(7.39972f, 44.1442f, 7.02492f, 43.7855f);
6104path.conicTo(6.3024f, 43.0942f, 6.99374f, 42.3717f, 0.707107f);
6105path.conicTo(7.68509f, 41.6492f, 8.40761f, 42.3405f, 0.707107f);
6106path.quadTo(8.7536f, 42.6715f, 9.11249f, 42.9885f);
6107path.conicTo(9.86201f, 43.6505f, 9.20003f, 44.4f, 0.707107f);
6108path.conicTo(8.53805f, 45.1496f, 7.78853f, 44.4876f, 0.707107f);
6109path.close();
6110path.moveTo(5.55855f, 42.2635f);
6111path.quadTo(5.20148f, 41.8614f, 4.86131f, 41.4449f);
6112path.conicTo(4.22883f, 40.6703f, 5.0034f, 40.0378f, 0.707107f);
6113path.conicTo(5.77797f, 39.4053f, 6.41046f, 40.1799f, 0.707107f);
6114path.quadTo(6.72443f, 40.5644f, 7.05403f, 40.9356f);
6115path.conicTo(7.71802f, 41.6833f, 6.97028f, 42.3473f, 0.707107f);
6116path.conicTo(6.22254f, 43.0113f, 5.55855f, 42.2635f, 0.707107f);
6117path.close();
6118path.moveTo(3.55261f, 39.6973f);
6119path.quadTo(3.26341f, 39.2752f, 2.99107f, 38.8422f);
6120path.conicTo(2.45867f, 37.9957f, 3.30517f, 37.4633f, 0.707107f);
6121path.conicTo(4.15167f, 36.9309f, 4.68406f, 37.7774f, 0.707107f);
6122path.quadTo(4.93548f, 38.1772f, 5.20241f, 38.5667f);
6123path.conicTo(5.76769f, 39.3916f, 4.94279f, 39.9569f, 0.707107f);
6124path.conicTo(4.11789f, 40.5222f, 3.55261f, 39.6973f, 0.707107f);
6125path.close();
6126path.moveTo(1.96145f, 37.0509f);
6127path.quadTo(1.71975f, 36.5889f, 1.49677f, 36.1175f);
6128path.conicTo(1.06917f, 35.2135f, 1.97315f, 34.7859f, 0.707107f);
6129path.conicTo(2.87712f, 34.3583f, 3.30471f, 35.2623f, 0.707107f);
6130path.quadTo(3.51053f, 35.6974f, 3.73364f, 36.1239f);
6131path.conicTo(4.19714f, 37.01f, 3.31105f, 37.4735f, 0.707107f);
6132path.conicTo(2.42495f, 37.937f, 1.96145f, 37.0509f, 0.707107f);
6133path.close();
6134path.moveTo(0.676191f, 34.1844f);
6135path.quadTo(0.489621f, 33.6902f, 0.323275f, 33.189f);
6136path.conicTo(0.00831527f, 32.2399f, 0.95742f, 31.9249f, 0.707107f);
6137path.conicTo(1.90653f, 31.6099f, 2.22149f, 32.559f, 0.707107f);
6138path.quadTo(2.37504f, 33.0218f, 2.54726f, 33.4779f);
6139path.conicTo(2.9005f, 34.4134f, 1.96497f, 34.7666f, 0.707107f);
6140path.conicTo(1.02943f, 35.1199f, 0.676191f, 34.1844f, 0.707107f);
6141path.close();
6142path.moveTo(-0.261658f, 31.1521f);
6143path.quadTo(-0.387304f, 30.6362f, -0.491779f, 30.1156f);
6144path.conicTo(-0.68853f, 29.1351f, 0.291923f, 28.9384f, 0.707107f);
6145path.conicTo(1.27238f, 28.7416f, 1.46913f, 29.7221f, 0.707107f);
6146path.quadTo(1.56557f, 30.2026f, 1.68155f, 30.6789f);
6147path.conicTo(1.91817f, 31.6505f, 0.946565f, 31.8871f, 0.707107f);
6148path.conicTo(-0.0250367f, 32.1237f, -0.261658f, 31.1521f, 0.707107f);
6149path.close();
6150path.moveTo(-0.820549f, 28.0495f);
6151path.quadTo(-0.881733f, 27.5314f, -0.922089f, 27.0113f);
6152path.conicTo(-0.999449f, 26.0143f, -0.00244591f, 25.9369f, 0.707107f);
6153path.conicTo(0.994557f, 25.8596f, 1.07192f, 26.8566f, 0.707107f);
6154path.quadTo(1.10917f, 27.3367f, 1.16565f, 27.8149f);
6155path.conicTo(1.28293f, 28.808f, 0.289834f, 28.9253f, 0.707107f);
6156path.conicTo(-0.703265f, 29.0426f, -0.820549f, 28.0495f, 0.707107f);
6157path.close();
6158path.moveTo(-0.999918f, 24.9349f);
6159path.quadTo(-0.998605f, 24.4104f, -0.976138f, 23.8863f);
6160path.conicTo(-0.933305f, 22.8873f, 0.0657772f, 22.9301f, 0.707107f);
6161path.conicTo(1.06486f, 22.9729f, 1.02203f, 23.972f, 0.707107f);
6162path.quadTo(1.00129f, 24.4557f, 1.00008f, 24.9399f);
6163path.conicTo(0.997572f, 25.9399f, -0.0024244f, 25.9374f, 0.707107f);
6164path.conicTo(-1.00242f, 25.9349f, -0.999918f, 24.9349f, 0.707107f);
6165path.close();
6166path.moveTo(-0.802212f, 21.7991f);
6167path.quadTo(-0.738311f, 21.284f, -0.653903f, 20.7719f);
6168path.conicTo(-0.491283f, 19.7852f, 0.495406f, 19.9478f, 0.707107f);
6169path.conicTo(1.48209f, 20.1104f, 1.31948f, 21.0971f, 0.707107f);
6170path.quadTo(1.24156f, 21.5698f, 1.18257f, 22.0453f);
6171path.conicTo(1.05946f, 23.0377f, 0.0670681f, 22.9146f, 0.707107f);
6172path.conicTo(-0.925325f, 22.7915f, -0.802212f, 21.7991f, 0.707107f);
6173path.close();
6174path.moveTo(-0.228066f, 18.7115f);
6175path.quadTo(-0.096172f, 18.1824f, 0.0577899f, 17.6593f);
6176path.conicTo(0.340124f, 16.7f, 1.29944f, 16.9823f, 0.707107f);
6177path.conicTo(2.25876f, 17.2646f, 1.97642f, 18.2239f, 0.707107f);
6178path.quadTo(1.8343f, 18.7068f, 1.71255f, 19.1953f);
6179path.conicTo(1.47069f, 20.1656f, 0.50038f, 19.9237f, 0.707107f);
6180path.conicTo(-0.46993f, 19.6819f, -0.228066f, 18.7115f, 0.707107f);
6181path.close();
6182path.moveTo(0.74831f, 15.6269f);
6183path.quadTo(0.938539f, 15.1347f, 1.14857f, 14.6506f);
6184path.conicTo(1.54662f, 13.7333f, 2.46398f, 14.1313f, 0.707107f);
6185path.conicTo(3.38135f, 14.5294f, 2.9833f, 15.4467f, 0.707107f);
6186path.quadTo(2.78942f, 15.8936f, 2.61382f, 16.3479f);
6187path.conicTo(2.25331f, 17.2806f, 1.32056f, 16.9201f, 0.707107f);
6188path.conicTo(0.387801f, 16.5596f, 0.74831f, 15.6269f, 0.707107f);
6189path.close();
6190path.moveTo(2.04744f, 12.7861f);
6191path.quadTo(2.28569f, 12.3384f, 2.5412f, 11.9003f);
6192path.conicTo(3.04504f, 11.0365f, 3.90884f, 11.5403f, 0.707107f);
6193path.conicTo(4.77264f, 12.0442f, 4.26881f, 12.908f, 0.707107f);
6194path.quadTo(4.03293f, 13.3123f, 3.81302f, 13.7256f);
6195path.conicTo(3.34325f, 14.6084f, 2.46046f, 14.1386f, 0.707107f);
6196path.conicTo(1.57767f, 13.6689f, 2.04744f, 12.7861f, 0.707107f);
6197path.close();
6198path.moveTo(3.60589f, 10.2253f);
6199path.quadTo(3.88812f, 9.81661f, 4.18576f, 9.419f);
6200path.conicTo(4.78503f, 8.61845f, 5.58558f, 9.21772f, 0.707107f);
6201path.conicTo(6.38613f, 9.81699f, 5.78686f, 10.6175f, 0.707107f);
6202path.quadTo(5.51211f, 10.9846f, 5.25159f, 11.3618f);
6203path.conicTo(4.68333f, 12.1847f, 3.86048f, 11.6164f, 0.707107f);
6204path.conicTo(3.03763f, 11.0481f, 3.60589f, 10.2253f, 0.707107f);
6205path.close();
6206path.moveTo(5.46482f, 7.84259f);
6207path.quadTo(5.80682f, 7.4532f, 6.16407f, 7.07773f);
6208path.conicTo(6.85339f, 6.35327f, 7.57785f, 7.04259f, 0.707107f);
6209path.conicTo(8.30231f, 7.73191f, 7.61299f, 8.45636f, 0.707107f);
6210path.quadTo(7.28322f, 8.80295f, 6.96752f, 9.16239f);
6211path.conicTo(6.30762f, 9.91375f, 5.55627f, 9.25385f, 0.707107f);
6212path.conicTo(4.80492f, 8.59395f, 5.46482f, 7.84259f, 0.707107f);
6213path.close();
6214path.moveTo(7.68062f, 5.60827f);
6215path.quadTo(8.08142f, 5.25031f, 8.49666f, 4.90921f);
6216path.conicTo(9.26938f, 4.27447f, 9.90412f, 5.04719f, 0.707107f);
6217path.conicTo(10.5389f, 5.81992f, 9.76614f, 6.45466f, 0.707107f);
6218path.quadTo(9.38285f, 6.76951f, 9.01289f, 7.09994f);
6219path.conicTo(8.26705f, 7.76607f, 7.60092f, 7.02024f, 0.707107f);
6220path.conicTo(6.93479f, 6.2744f, 7.68062f, 5.60827f, 0.707107f);
6221path.close();
6222path.moveTo(10.2392f, 3.59627f);
6223path.quadTo(10.6626f, 3.30433f, 11.0971f, 3.02935f);
6224path.conicTo(11.9421f, 2.49463f, 12.4768f, 3.33965f, 0.707107f);
6225path.conicTo(13.0116f, 4.18467f, 12.1666f, 4.7194f, 0.707107f);
6226path.quadTo(11.7654f, 4.97322f, 11.3747f, 5.24271f);
6227path.conicTo(10.5515f, 5.81043f, 9.98373f, 4.98721f, 0.707107f);
6228path.conicTo(9.41601f, 4.16399f, 10.2392f, 3.59627f, 0.707107f);
6229path.close();
6230path.moveTo(12.8847f, 1.99524f);
6231path.quadTo(13.3459f, 1.75234f, 13.8165f, 1.52812f);
6232path.conicTo(14.7193f, 1.09799f, 15.1494f, 2.00075f, 0.707107f);
6233path.conicTo(15.5795f, 2.90352f, 14.6768f, 3.33365f, 0.707107f);
6234path.quadTo(14.2424f, 3.54063f, 13.8166f, 3.76484f);
6235path.conicTo(12.9318f, 4.23081f, 12.4658f, 3.34601f, 0.707107f);
6236path.conicTo(11.9999f, 2.46122f, 12.8847f, 1.99524f, 0.707107f);
6237path.close();
6238path.moveTo(15.7467f, 0.702339f);
6239path.quadTo(16.2402f, 0.514409f, 16.7409f, 0.346672f);
6240path.conicTo(17.6891f, 0.029011f, 18.0067f, 0.977215f, 0.707107f);
6241path.conicTo(18.3244f, 1.92542f, 17.3762f, 2.24308f, 0.707107f);
6242path.quadTo(16.914f, 2.39792f, 16.4585f, 2.57139f);
6243path.conicTo(15.524f, 2.92729f, 15.1681f, 1.99276f, 0.707107f);
6244path.conicTo(14.8122f, 1.05824f, 15.7467f, 0.702339f, 0.707107f);
6245path.close();
6246path.moveTo(18.7758f, -0.24399f);
6247path.quadTo(19.2913f, -0.371107f, 19.8116f, -0.477061f);
6248path.conicTo(20.7915f, -0.676608f, 20.9911f, 0.303281f, 0.707107f);
6249path.conicTo(21.1906f, 1.28317f, 20.2107f, 1.48272f, 0.707107f);
6250path.quadTo(19.7304f, 1.58052f, 19.2546f, 1.69785f);
6251path.conicTo(18.2836f, 1.93725f, 18.0443f, 0.966329f, 0.707107f);
6252path.conicTo(17.8049f, -0.00459272f, 18.7758f, -0.24399f, 0.707107f);
6253path.close();
6254path.moveTo(21.878f, -0.811882f);
6255path.quadTo(22.396f, -0.874528f, 22.916f, -0.916348f);
6256path.conicTo(23.9128f, -0.996504f, 23.993f, 0.000278629f, 0.707107f);
6257path.conicTo(24.0731f, 0.997061f, 23.0764f, 1.07722f, 0.707107f);
6258path.quadTo(22.5963f, 1.11582f, 22.1182f, 1.17365f);
6259path.conicTo(21.1254f, 1.29372f, 21.0053f, 0.300958f, 0.707107f);
6260path.conicTo(20.8853f, -0.691807f, 21.878f, -0.811882f, 0.707107f);
6261path.close();
6262path.moveTo(24.9926f, -0.999999f);
6263path.quadTo(25.5166f, -1.00015f, 26.0401f, -0.979188f);
6264path.conicTo(27.0393f, -0.939179f, 26.9992f, 0.0600199f, 0.707107f);
6265path.conicTo(26.9592f, 1.05922f, 25.96f, 1.01921f, 0.707107f);
6266path.quadTo(25.4768f, 0.999863f, 24.9932f, 1);
6267path.conicTo(23.9932f, 1.00029f, 23.9929f, 0.000287339f, 0.707107f);
6268path.conicTo(23.9926f, -0.999713f, 24.9926f, -0.999999f, 0.707107f);
6269path.close();
6270path.moveTo(28.1286f, -0.811081f);
6271path.quadTo(28.6441f, -0.748593f, 29.1567f, -0.665572f);
6272path.conicTo(30.1439f, -0.505698f, 29.984f, 0.48144f, 0.707107f);
6273path.conicTo(29.8241f, 1.46858f, 28.837f, 1.3087f, 0.707107f);
6274path.quadTo(28.3638f, 1.23207f, 27.8879f, 1.17439f);
6275path.conicTo(26.8952f, 1.05406f, 27.0155f, 0.0613233f, 0.707107f);
6276path.conicTo(27.1359f, -0.931411f, 28.1286f, -0.811081f, 0.707107f);
6277path.close();
6278path.moveTo(31.214f, -0.246499f);
6279path.quadTo(31.7439f, -0.116076f, 32.2679f, 0.0364622f);
6280path.conicTo(33.228f, 0.315996f, 32.9485f, 1.27613f, 0.707107f);
6281path.conicTo(32.6689f, 2.23627f, 31.7088f, 1.95673f, 0.707107f);
6282path.quadTo(31.2252f, 1.81593f, 30.736f, 1.69554f);
6283path.conicTo(29.765f, 1.45654f, 30.004f, 0.48552f, 0.707107f);
6284path.conicTo(30.243f, -0.485499f, 31.214f, -0.246499f, 0.707107f);
6285path.close();
6286path.moveTo(34.3038f, 0.721629f);
6287path.quadTo(34.797f, 0.910612f, 35.282f, 1.11946f);
6288path.conicTo(36.2005f, 1.51493f, 35.805f, 2.43341f, 0.707107f);
6289path.conicTo(35.4096f, 3.35189f, 34.4911f, 2.95642f, 0.707107f);
6290path.quadTo(34.0434f, 2.76365f, 33.5881f, 2.5892f);
6291path.conicTo(32.6543f, 2.23137f, 33.0122f, 1.29758f, 0.707107f);
6292path.conicTo(33.37f, 0.363796f, 34.3038f, 0.721629f, 0.707107f);
6293path.close();
6294path.moveTo(37.1508f, 2.01396f);
6295path.quadTo(37.5996f, 2.2512f, 38.0388f, 2.50578f);
6296path.conicTo(38.904f, 3.00727f, 38.4025f, 3.87244f, 0.707107f);
6297path.conicTo(37.901f, 4.7376f, 37.0358f, 4.23612f, 0.707107f);
6298path.quadTo(36.6304f, 4.00111f, 36.2161f, 3.78211f);
6299path.conicTo(35.332f, 3.31476f, 35.7994f, 2.43069f, 0.707107f);
6300path.conicTo(36.2667f, 1.54661f, 37.1508f, 2.01396f, 0.707107f);
6301path.close();
6302path.moveTo(39.718f, 3.56681f);
6303path.quadTo(40.1269f, 3.84765f, 40.5249f, 4.14392f);
6304path.conicTo(41.3271f, 4.74104f, 40.73f, 5.54319f, 0.707107f);
6305path.conicTo(40.1329f, 6.34535f, 39.3307f, 5.74823f, 0.707107f);
6306path.quadTo(38.9634f, 5.47478f, 38.5858f, 5.21552f);
6307path.conicTo(37.7615f, 4.64945f, 38.3275f, 3.82509f, 0.707107f);
6308path.conicTo(38.8936f, 3.00074f, 39.718f, 3.56681f, 0.707107f);
6309path.close();
6310path.moveTo(42.1033f, 5.41741f);
6311path.quadTo(42.4933f, 5.75802f, 42.8694f, 6.11388f);
6312path.conicTo(43.5958f, 6.80115f, 42.9085f, 7.52755f, 0.707107f);
6313path.conicTo(42.2212f, 8.25394f, 41.4948f, 7.56667f, 0.707107f);
6314path.quadTo(41.1476f, 7.23817f, 40.7876f, 6.92375f);
6315path.conicTo(40.0345f, 6.26593f, 40.6923f, 5.51275f, 0.707107f);
6316path.conicTo(41.3501f, 4.75958f, 42.1033f, 5.41741f, 0.707107f);
6317path.close();
6318path.moveTo(44.3419f, 7.62498f);
6319path.quadTo(44.7007f, 8.02444f, 45.0428f, 8.43835f);
6320path.conicTo(45.6797f, 9.20922f, 44.9089f, 9.84622f, 0.707107f);
6321path.conicTo(44.138f, 10.4832f, 43.501f, 9.71234f, 0.707107f);
6322path.quadTo(43.1852f, 9.3302f, 42.854f, 8.96151f);
6323path.conicTo(42.1858f, 8.21759f, 42.9297f, 7.54932f, 0.707107f);
6324path.conicTo(43.6736f, 6.88106f, 44.3419f, 7.62498f, 0.707107f);
6325path.close();
6326path.moveTo(46.3599f, 10.1759f);
6327path.quadTo(46.6546f, 10.6005f, 46.9322f, 11.0366f);
6328path.conicTo(47.4693f, 11.8801f, 46.6257f, 12.4172f, 0.707107f);
6329path.conicTo(45.7822f, 12.9542f, 45.2451f, 12.1107f, 0.707107f);
6330path.quadTo(44.9889f, 11.7082f, 44.7168f, 11.3162f);
6331path.conicTo(44.1467f, 10.4947f, 44.9682f, 9.92452f, 0.707107f);
6332path.conicTo(45.7897f, 9.35435f, 46.3599f, 10.1759f, 0.707107f);
6333path.close();
6334path.moveTo(47.9708f, 12.8204f);
6335path.quadTo(48.2149f, 13.2808f, 48.4403f, 13.7506f);
6336path.conicTo(48.873f, 14.6521f, 47.9715f, 15.0848f, 0.707107f);
6337path.conicTo(47.0699f, 15.5174f, 46.6372f, 14.6159f, 0.707107f);
6338path.quadTo(46.4291f, 14.1822f, 46.2038f, 13.7573f);
6339path.conicTo(45.7354f, 12.8738f, 46.6188f, 12.4054f, 0.707107f);
6340path.conicTo(47.5023f, 11.9369f, 47.9708f, 12.8204f, 0.707107f);
6341path.close();
6342path.moveTo(49.2713f, 15.6778f);
6343path.quadTo(49.4606f, 16.1706f, 49.6297f, 16.6708f);
6344path.conicTo(49.9501f, 17.6181f, 49.0028f, 17.9384f, 0.707107f);
6345path.conicTo(48.0555f, 18.2588f, 47.7351f, 17.3115f, 0.707107f);
6346path.quadTo(47.5791f, 16.8499f, 47.4043f, 16.3949f);
6347path.conicTo(47.0458f, 15.4614f, 47.9793f, 15.1029f, 0.707107f);
6348path.conicTo(48.9128f, 14.7443f, 49.2713f, 15.6778f, 0.707107f);
6349path.close();
6350path.moveTo(50.2261f, 18.7037f);
6351path.quadTo(50.3547f, 19.2188f, 50.4621f, 19.7388f);
6352path.conicTo(50.6645f, 20.7182f, 49.6852f, 20.9205f, 0.707107f);
6353path.conicTo(48.7059f, 21.1229f, 48.5035f, 20.1436f, 0.707107f);
6354path.quadTo(48.4043f, 19.6636f, 48.2856f, 19.1881f);
6355path.conicTo(48.0435f, 18.2178f, 49.0137f, 17.9757f, 0.707107f);
6356path.conicTo(49.984f, 17.7335f, 50.2261f, 18.7037f, 0.707107f);
6357path.close();
6358path.moveTo(50.803f, 21.8055f);
6359path.quadTo(50.8671f, 22.3234f, 50.9104f, 22.8434f);
6360path.conicTo(50.9934f, 23.8399f, 49.9968f, 23.9229f, 0.707107f);
6361path.conicTo(49.0002f, 24.0058f, 48.9173f, 23.0093f, 0.707107f);
6362path.quadTo(48.8773f, 22.5293f, 48.8182f, 22.0513f);
6363path.conicTo(48.6953f, 21.0588f, 49.6877f, 20.936f, 0.707107f);
6364path.conicTo(50.6801f, 20.8131f, 50.803f, 21.8055f, 0.707107f);
6365path.close();
6366path.moveTo(50.9999f, 24.9202f);
6367path.quadTo(51.0015f, 25.4434f, 50.982f, 25.9664f);
6368path.conicTo(50.9449f, 26.9657f, 49.9456f, 26.9286f, 0.707107f);
6369path.conicTo(48.9463f, 26.8914f, 48.9834f, 25.8921f, 0.707107f);
6370path.quadTo(49.0014f, 25.4094f, 48.9999f, 24.9263f);
6371path.conicTo(48.9968f, 23.9263f, 49.9968f, 23.9232f, 0.707107f);
6372path.conicTo(50.9968f, 23.9202f, 50.9999f, 24.9202f, 0.707107f);
6373path.close();
6374path.moveTo(50.8198f, 28.0562f);
6375path.quadTo(50.7587f, 28.5721f, 50.677f, 29.0852f);
6376path.conicTo(50.5199f, 30.0728f, 49.5323f, 29.9157f, 0.707107f);
6377path.conicTo(48.5448f, 29.7586f, 48.7019f, 28.771f, 0.707107f);
6378path.quadTo(48.7772f, 28.2974f, 48.8336f, 27.8211f);
6379path.conicTo(48.9512f, 26.8281f, 49.9442f, 26.9456f, 0.707107f);
6380path.conicTo(50.9373f, 27.0632f, 50.8198f, 28.0562f, 0.707107f);
6381path.close();
6382path.moveTo(50.2647f, 31.1395f);
6383path.quadTo(50.1358f, 31.6701f, 49.9847f, 32.1949f);
6384path.conicTo(49.7079f, 33.1558f, 48.747f, 32.8791f, 0.707107f);
6385path.conicTo(47.786f, 32.6024f, 48.0628f, 31.6414f, 0.707107f);
6386path.quadTo(48.2022f, 31.1571f, 48.3213f, 30.6672f);
6387path.conicTo(48.5574f, 29.6955f, 49.5291f, 29.9317f, 0.707107f);
6388path.conicTo(50.5009f, 30.1678f, 50.2647f, 31.1395f, 0.707107f);
6389path.close();
6390path.moveTo(49.3049f, 34.2343f);
6391path.quadTo(49.1171f, 34.7285f, 48.9095f, 35.2145f);
6392path.conicTo(48.5166f, 36.1341f, 47.597f, 35.7412f, 0.707107f);
6393path.conicTo(46.6774f, 35.3483f, 47.0703f, 34.4288f, 0.707107f);
6394path.quadTo(47.262f, 33.9801f, 47.4353f, 33.524f);
6395path.conicTo(47.7904f, 32.5892f, 48.7252f, 32.9444f, 0.707107f);
6396path.conicTo(49.66f, 33.2995f, 49.3049f, 34.2343f, 0.707107f);
6397path.close();
6398path.moveTo(48.0194f, 37.0875f);
6399path.quadTo(47.7831f, 37.5374f, 47.5295f, 37.9777f);
6400path.conicTo(47.0304f, 38.8443f, 46.1638f, 38.3451f, 0.707107f);
6401path.conicTo(45.2973f, 37.846f, 45.7965f, 36.9795f, 0.707107f);
6402path.quadTo(46.0306f, 36.5729f, 46.2487f, 36.1577f);
6403path.conicTo(46.7136f, 35.2723f, 47.5989f, 35.7372f, 0.707107f);
6404path.conicTo(48.4843f, 36.2021f, 48.0194f, 37.0875f, 0.707107f);
6405path.close();
6406path.moveTo(46.4721f, 39.6612f);
6407path.quadTo(46.1926f, 40.0705f, 45.8977f, 40.4688f);
6408path.conicTo(45.3028f, 41.2726f, 44.499f, 40.6776f, 0.707107f);
6409path.conicTo(43.6953f, 40.0827f, 44.2902f, 39.2789f, 0.707107f);
6410path.quadTo(44.5624f, 38.9112f, 44.8204f, 38.5334f);
6411path.conicTo(45.3843f, 37.7075f, 46.2101f, 38.2714f, 0.707107f);
6412path.conicTo(47.036f, 38.8353f, 46.4721f, 39.6612f, 0.707107f);
6413path.close();
6414path.moveTo(44.6298f, 42.0491f);
6415path.quadTo(44.2906f, 42.4396f, 43.9361f, 42.8164f);
6416path.conicTo(43.2509f, 43.5447f, 42.5226f, 42.8595f, 0.707107f);
6417path.conicTo(41.7942f, 42.1742f, 42.4795f, 41.4459f, 0.707107f);
6418path.quadTo(42.8067f, 41.0981f, 43.1198f, 40.7376f);
6419path.conicTo(43.7756f, 39.9826f, 44.5306f, 40.6383f, 0.707107f);
6420path.conicTo(45.2856f, 41.2941f, 44.6298f, 42.0491f, 0.707107f);
6421path.close();
6422path.moveTo(42.4305f, 44.2919f);
6423path.quadTo(42.0324f, 44.6516f, 41.6198f, 44.9946f);
6424path.conicTo(40.8507f, 45.6338f, 40.2115f, 44.8648f, 0.707107f);
6425path.conicTo(39.5723f, 44.0958f, 40.3413f, 43.4566f, 0.707107f);
6426path.quadTo(40.7222f, 43.1399f, 41.0897f, 42.8079f);
6427path.conicTo(41.8317f, 42.1375f, 42.5021f, 42.8795f, 0.707107f);
6428path.conicTo(43.1725f, 43.6215f, 42.4305f, 44.2919f, 0.707107f);
6429path.close();
6430path.moveTo(39.8873f, 46.3159f);
6431path.quadTo(39.4613f, 46.6134f, 39.0238f, 46.8936f);
6432path.conicTo(38.1818f, 47.433f, 37.6424f, 46.5909f, 0.707107f);
6433path.conicTo(37.103f, 45.7489f, 37.9451f, 45.2095f, 0.707107f);
6434path.quadTo(38.3489f, 44.9508f, 38.7421f, 44.6763f);
6435path.conicTo(39.5619f, 44.1037f, 40.1345f, 44.9235f, 0.707107f);
6436path.conicTo(40.7071f, 45.7434f, 39.8873f, 46.3159f, 0.707107f);
6437path.close();
6438path.moveTo(37.2437f, 47.9367f);
6439path.quadTo(36.7842f, 48.182f, 36.3153f, 48.4086f);
6440path.conicTo(35.415f, 48.8439f, 34.9797f, 47.9435f, 0.707107f);
6441path.conicTo(34.5445f, 47.0432f, 35.4449f, 46.608f, 0.707107f);
6442path.quadTo(35.8778f, 46.3987f, 36.3019f, 46.1723f);
6443path.conicTo(37.1841f, 45.7014f, 37.655f, 46.5836f, 0.707107f);
6444path.conicTo(38.1259f, 47.4658f, 37.2437f, 47.9367f, 0.707107f);
6445path.close();
6446path.moveTo(34.3909f, 49.2448f);
6447path.quadTo(33.8988f, 49.4354f, 33.3992f, 49.606f);
6448path.conicTo(32.4528f, 49.929f, 32.1298f, 48.9826f, 0.707107f);
6449path.conicTo(31.8068f, 48.0362f, 32.7532f, 47.7132f, 0.707107f);
6450path.quadTo(33.2142f, 47.5558f, 33.6685f, 47.3798f);
6451path.conicTo(34.601f, 47.0186f, 34.9622f, 47.9511f, 0.707107f);
6452path.conicTo(35.3234f, 48.8836f, 34.3909f, 49.2448f, 0.707107f);
6453path.close();
6454path.moveTo(31.3682f, 50.208f);
6455path.quadTo(30.8535f, 50.3381f, 30.3338f, 50.447f);
6456path.conicTo(29.3551f, 50.6521f, 29.15f, 49.6734f, 0.707107f);
6457path.conicTo(28.9448f, 48.6947f, 29.9236f, 48.4895f, 0.707107f);
6458path.quadTo(30.4033f, 48.389f, 30.8784f, 48.269f);
6459path.conicTo(31.8479f, 48.024f, 32.0929f, 48.9936f, 0.707107f);
6460path.conicTo(32.3378f, 49.9631f, 31.3682f, 50.208f, 0.707107f);
6461path.close();
6462path.moveTo(28.2669f, 50.7939f);
6463path.quadTo(27.7491f, 50.8595f, 27.2292f, 50.9043f);
6464path.conicTo(26.2329f, 50.99f, 26.1472f, 49.9937f, 0.707107f);
6465path.conicTo(26.0615f, 48.9973f, 27.0578f, 48.9116f, 0.707107f);
6466path.quadTo(27.5378f, 48.8703f, 28.0156f, 48.8098f);
6467path.conicTo(29.0077f, 48.6841f, 29.1334f, 49.6762f, 0.707107f);
6468path.conicTo(29.259f, 50.6683f, 28.2669f, 50.7939f, 0.707107f);
6469path.close();
6470path.moveTo(25.1523f, 50.9996f);
6471path.quadTo(24.6297f, 51.0026f, 24.1072f, 50.9847f);
6472path.conicTo(23.1078f, 50.9503f, 23.1422f, 49.9509f, 0.707107f);
6473path.conicTo(23.1765f, 48.9515f, 24.1759f, 48.9858f, 0.707107f);
6474path.quadTo(24.658f, 49.0024f, 25.1406f, 48.9996f);
6475path.conicTo(26.1406f, 48.9937f, 26.1464f, 49.9937f, 0.707107f);
6476path.conicTo(26.1523f, 50.9937f, 25.1523f, 50.9996f, 0.707107f);
6477path.close();
6478path.moveTo(22.0162f, 50.8282f);
6479path.quadTo(21.4999f, 50.7686f, 20.9863f, 50.6883f);
6480path.conicTo(19.9983f, 50.5339f, 20.1527f, 49.5459f, 0.707107f);
6481path.conicTo(20.307f, 48.5579f, 21.295f, 48.7123f, 0.707107f);
6482path.quadTo(21.7691f, 48.7864f, 22.2457f, 48.8414f);
6483path.conicTo(23.2391f, 48.9562f, 23.1243f, 49.9496f, 0.707107f);
6484path.conicTo(23.0096f, 50.943f, 22.0162f, 50.8282f, 0.707107f);
6485path.close();
6486path.moveTo(18.9351f, 50.2827f);
6487path.quadTo(18.4037f, 50.1553f, 17.8782f, 50.0056f);
6488path.conicTo(16.9164f, 49.7317f, 17.1904f, 48.7699f, 0.707107f);
6489path.conicTo(17.4643f, 47.8082f, 18.426f, 48.0821f, 0.707107f);
6490path.quadTo(18.9112f, 48.2203f, 19.4016f, 48.3379f);
6491path.conicTo(20.374f, 48.5712f, 20.1408f, 49.5436f, 0.707107f);
6492path.conicTo(19.9075f, 50.516f, 18.9351f, 50.2827f, 0.707107f);
6493path.close();
6494path.moveTo(15.8352f, 49.3312f);
6495path.quadTo(15.3403f, 49.1448f, 14.8531f, 48.9383f);
6496path.conicTo(13.9324f, 48.548f, 14.3227f, 47.6273f, 0.707107f);
6497path.conicTo(14.713f, 46.7066f, 15.6337f, 47.0969f, 0.707107f);
6498path.quadTo(16.0832f, 47.2874f, 16.5402f, 47.4596f);
6499path.conicTo(17.476f, 47.812f, 17.1235f, 48.7479f, 0.707107f);
6500path.conicTo(16.771f, 49.6837f, 15.8352f, 49.3312f, 0.707107f);
6501path.close();
6502path.moveTo(12.9759f, 48.0526f);
6503path.quadTo(12.5249f, 47.8173f, 12.0835f, 47.5647f);
6504path.conicTo(11.2156f, 47.0679f, 11.7124f, 46.2f, 0.707107f);
6505path.conicTo(12.2092f, 45.3321f, 13.0771f, 45.8289f, 0.707107f);
6506path.quadTo(13.4846f, 46.0622f, 13.9009f, 46.2793f);
6507path.conicTo(14.7875f, 46.7418f, 14.325f, 47.6284f, 0.707107f);
6508path.conicTo(13.8626f, 48.5151f, 12.9759f, 48.0526f, 0.707107f);
6509path.close();
6510path.moveTo(10.3957f, 46.5108f);
6511path.quadTo(9.9861f, 46.2327f, 9.58733f, 45.9392f);
6512path.conicTo(8.78198f, 45.3464f, 9.37478f, 44.541f, 0.707107f);
6513path.conicTo(9.96757f, 43.7357f, 10.7729f, 44.3285f, 0.707107f);
6514path.quadTo(11.141f, 44.5994f, 11.5191f, 44.8561f);
6515path.conicTo(12.3464f, 45.4178f, 11.7847f, 46.2451f, 0.707107f);
6516path.conicTo(11.223f, 47.0725f, 10.3957f, 46.5108f, 0.707107f);
6517path.close();
6518path.moveTo(8.00525f, 44.6769f);
6519path.quadTo(7.6141f, 44.339f, 7.23672f, 43.9859f);
6520path.conicTo(6.50649f, 43.3027f, 7.18969f, 42.5725f, 0.707107f);
6521path.conicTo(7.87289f, 41.8423f, 8.60312f, 42.5255f, 0.707107f);
6522path.quadTo(8.95149f, 42.8514f, 9.31254f, 43.1632f);
6523path.conicTo(10.0693f, 43.8169f, 9.4157f, 44.5737f, 0.707107f);
6524path.conicTo(8.76206f, 45.3305f, 8.00525f, 44.6769f, 0.707107f);
6525path.close();
6526path.moveTo(5.75818f, 42.4858f);
6527path.quadTo(5.39763f, 42.089f, 5.05371f, 41.6777f);
6528path.conicTo(4.41226f, 40.9105f, 5.17942f, 40.2691f, 0.707107f);
6529path.conicTo(5.94658f, 39.6276f, 6.58804f, 40.3948f, 0.707107f);
6530path.quadTo(6.90548f, 40.7744f, 7.23832f, 41.1407f);
6531path.conicTo(7.91085f, 41.8808f, 7.17078f, 42.5533f, 0.707107f);
6532path.conicTo(6.43071f, 43.2258f, 5.75818f, 42.4858f, 0.707107f);
6533path.close();
6534path.moveTo(3.72821f, 39.9503f);
6535path.quadTo(3.42794f, 39.523f, 3.1451f, 39.0842f);
6536path.conicTo(2.6034f, 38.2436f, 3.44397f, 37.7019f, 0.707107f);
6537path.conicTo(4.28454f, 37.1602f, 4.82624f, 38.0008f, 0.707107f);
6538path.quadTo(5.08734f, 38.4059f, 5.3645f, 38.8003f);
6539path.conicTo(5.93951f, 39.6184f, 5.12137f, 40.1934f, 0.707107f);
6540path.conicTo(4.30322f, 40.7684f, 3.72821f, 39.9503f, 0.707107f);
6541path.close();
6542path.moveTo(2.09762f, 37.3078f);
6543path.quadTo(1.85114f, 36.8491f, 1.62324f, 36.381f);
6544path.conicTo(1.18551f, 35.4819f, 2.08461f, 35.0442f, 0.707107f);
6545path.conicTo(2.98372f, 34.6064f, 3.42145f, 35.5055f, 0.707107f);
6546path.quadTo(3.63184f, 35.9377f, 3.85934f, 36.361f);
6547path.conicTo(4.33272f, 37.2419f, 3.45185f, 37.7153f, 0.707107f);
6548path.conicTo(2.57099f, 38.1886f, 2.09762f, 37.3078f, 0.707107f);
6549path.close();
6550path.moveTo(0.781912f, 34.4596f);
6551path.quadTo(0.589924f, 33.9681f, 0.418029f, 33.4692f);
6552path.conicTo(0.0922952f, 32.5237f, 1.03776f, 32.198f, 0.707107f);
6553path.conicTo(1.98322f, 31.8722f, 2.30895f, 32.8177f, 0.707107f);
6554path.quadTo(2.46761f, 33.2782f, 2.64484f, 33.7319f);
6555path.conicTo(3.00867f, 34.6634f, 2.07721f, 35.0272f, 0.707107f);
6556path.conicTo(1.14575f, 35.3911f, 0.781912f, 34.4596f, 0.707107f);
6557path.close();
6558path.moveTo(-0.189761f, 31.4402f);
6559path.quadTo(-0.321263f, 30.9258f, -0.431662f, 30.4065f);
6560path.conicTo(-0.639608f, 29.4284f, 0.338532f, 29.2205f, 0.707107f);
6561path.conicTo(1.31667f, 29.0125f, 1.52462f, 29.9906f, 0.707107f);
6562path.quadTo(1.62653f, 30.47f, 1.74791f, 30.9448f);
6563path.conicTo(1.99561f, 31.9136f, 1.02677f, 32.1613f, 0.707107f);
6564path.conicTo(0.0579369f, 32.409f, -0.189761f, 31.4402f, 0.707107f);
6565path.close();
6566path.moveTo(-0.784658f, 28.3394f);
6567path.quadTo(-0.851693f, 27.8218f, -0.897902f, 27.3019f);
6568path.conicTo(-0.986437f, 26.3058f, 0.00963629f, 26.2173f, 0.707107f);
6569path.conicTo(1.00571f, 26.1288f, 1.09424f, 27.1248f, 0.707107f);
6570path.quadTo(1.1369f, 27.6047f, 1.19878f, 28.0825f);
6571path.conicTo(1.32721f, 29.0742f, 0.335496f, 29.2027f, 0.707107f);
6572path.conicTo(-0.656222f, 29.3311f, -0.784658f, 28.3394f, 0.707107f);
6573path.close();
6574path.moveTo(-0.999031f, 25.2248f);
6575path.quadTo(-1.00354f, 24.7027f, -0.987098f, 24.1809f);
6576path.conicTo(-0.955596f, 23.1814f, 0.0439078f, 23.2129f, 0.707107f);
6577path.conicTo(1.04341f, 23.2444f, 1.01191f, 24.2439f, 0.707107f);
6578path.quadTo(0.996728f, 24.7256f, 1.00089f, 25.2075f);
6579path.conicTo(1.00954f, 26.2075f, 0.00957754f, 26.2161f, 0.707107f);
6580path.conicTo(-0.990385f, 26.2248f, -0.999031f, 25.2248f, 0.707107f);
6581path.close();
6582path.moveTo(-0.836492f, 22.0887f);
6583path.quadTo(-0.778263f, 21.5719f, -0.699419f, 21.0579f);
6584path.conicTo(-0.5478f, 20.0695f, 0.440639f, 20.2211f, 0.707107f);
6585path.conicTo(1.42908f, 20.3727f, 1.27746f, 21.3612f, 0.707107f);
6586path.quadTo(1.20468f, 21.8356f, 1.15093f, 22.3126f);
6587path.conicTo(1.03896f, 23.3063f, 0.0452449f, 23.1944f, 0.707107f);
6588path.conicTo(-0.948466f, 23.0824f, -0.836492f, 22.0887f, 0.707107f);
6589path.close();
6590path.moveTo(-0.300548f, 19.0098f);
6591path.quadTo(-0.174573f, 18.4777f, -0.0263361f, 17.9514f);
6592path.conicTo(0.244762f, 16.9889f, 1.20731f, 17.26f, 0.707107f);
6593path.conicTo(2.16987f, 17.5311f, 1.89877f, 18.4936f, 0.707107f);
6594path.quadTo(1.76193f, 18.9794f, 1.64565f, 19.4706f);
6595path.conicTo(1.41526f, 20.4437f, 0.442159f, 20.2133f, 0.707107f);
6596path.conicTo(-0.530939f, 19.9829f, -0.300548f, 19.0098f, 0.707107f);
6597path.close();
6598path.moveTo(0.642658f, 15.9049f);
6599path.quadTo(0.827861f, 15.409f, 1.0331f, 14.9209f);
6600path.conicTo(1.42076f, 13.9991f, 2.34256f, 14.3868f, 0.707107f);
6601path.conicTo(3.26437f, 14.7744f, 2.87671f, 15.6962f, 0.707107f);
6602path.quadTo(2.68726f, 16.1467f, 2.5163f, 16.6046f);
6603path.conicTo(2.16648f, 17.5414f, 1.22967f, 17.1916f, 0.707107f);
6604path.conicTo(0.292846f, 16.8418f, 0.642658f, 15.9049f, 0.707107f);
6605path.close();
6606path.moveTo(1.91434f, 13.0395f);
6607path.quadTo(2.14856f, 12.5875f, 2.40031f, 12.1449f);
6608path.conicTo(2.89473f, 11.2757f, 3.76395f, 11.7701f, 0.707107f);
6609path.conicTo(4.63317f, 12.2645f, 4.13875f, 13.1337f, 0.707107f);
6610path.quadTo(3.90637f, 13.5423f, 3.69016f, 13.9596f);
6611path.conicTo(3.23014f, 14.8475f, 2.34223f, 14.3875f, 0.707107f);
6612path.conicTo(1.45432f, 13.9275f, 1.91434f, 13.0395f, 0.707107f);
6613path.close();
6614path.moveTo(3.45073f, 10.4525f);
6615path.quadTo(3.72744f, 10.0426f, 4.01954f, 9.64356f);
6616path.conicTo(4.61017f, 8.83661f, 5.41711f, 9.42725f, 0.707107f);
6617path.conicTo(6.22405f, 10.0179f, 5.63342f, 10.8248f, 0.707107f);
6618path.quadTo(5.36379f, 11.1932f, 5.10836f, 11.5716f);
6619path.conicTo(4.54884f, 12.4004f, 3.72003f, 11.8409f, 0.707107f);
6620path.conicTo(2.89121f, 11.2813f, 3.45073f, 10.4525f, 0.707107f);
6621path.close();
6622path.moveTo(5.2763f, 8.05964f);
6623path.quadTo(5.61273f, 7.66793f, 5.96445f, 7.2899f);
6624path.conicTo(6.6456f, 6.55776f, 7.37774f, 7.23892f, 0.707107f);
6625path.conicTo(8.10988f, 7.92008f, 7.42872f, 8.65221f, 0.707107f);
6626path.quadTo(7.10407f, 9.00116f, 6.79351f, 9.36274f);
6627path.conicTo(6.14196f, 10.1213f, 5.38336f, 9.46979f, 0.707107f);
6628path.conicTo(4.62475f, 8.81824f, 5.2763f, 8.05964f, 0.707107f);
6629path.close();
6630path.moveTo(7.45913f, 5.80839f);
6631path.quadTo(7.85457f, 5.44696f, 8.26455f, 5.10214f);
6632path.conicTo(9.02985f, 4.45847f, 9.67352f, 5.22377f, 0.707107f);
6633path.conicTo(10.3172f, 5.98907f, 9.5519f, 6.63274f, 0.707107f);
6634path.quadTo(9.17345f, 6.95105f, 8.80843f, 7.28467f);
6635path.conicTo(8.07029f, 7.95931f, 7.39564f, 7.22117f, 0.707107f);
6636path.conicTo(6.72099f, 6.48303f, 7.45913f, 5.80839f, 0.707107f);
6637path.close();
6638path.moveTo(9.98688f, 3.77251f);
6639path.quadTo(10.4153f, 3.46948f, 10.8557f, 3.18397f);
6640path.conicTo(11.6948f, 2.63996f, 12.2388f, 3.47904f, 0.707107f);
6641path.conicTo(12.7828f, 4.31812f, 11.9437f, 4.86213f, 0.707107f);
6642path.quadTo(11.5373f, 5.12566f, 11.1417f, 5.40539f);
6643path.conicTo(10.3253f, 5.98282f, 9.74787f, 5.16638f, 0.707107f);
6644path.conicTo(9.17044f, 4.34994f, 9.98688f, 3.77251f, 0.707107f);
6645path.close();
6646path.moveTo(12.6283f, 2.13208f);
6647path.quadTo(13.0861f, 1.88442f, 13.5534f, 1.65529f);
6648path.conicTo(14.4513f, 1.21504f, 14.8915f, 2.11291f, 0.707107f);
6649path.conicTo(15.3318f, 3.01078f, 14.4339f, 3.45104f, 0.707107f);
6650path.quadTo(14.0025f, 3.66255f, 13.58f, 3.89115f);
6651path.conicTo(12.7005f, 4.36698f, 12.2246f, 3.48744f, 0.707107f);
6652path.conicTo(11.7488f, 2.60791f, 12.6283f, 2.13208f, 0.707107f);
6653path.close();
6654path.moveTo(15.4718f, 0.808815f);
6655path.quadTo(15.9627f, 0.615476f, 16.461f, 0.442208f);
6656path.conicTo(17.4055f, 0.113784f, 17.7339f, 1.05831f, 0.707107f);
6657path.conicTo(18.0624f, 2.00284f, 17.1178f, 2.33127f, 0.707107f);
6658path.quadTo(16.6578f, 2.49121f, 16.2047f, 2.66968f);
6659path.conicTo(15.2743f, 3.03614f, 14.9078f, 2.10571f, 0.707107f);
6660path.conicTo(14.5414f, 1.17528f, 15.4718f, 0.808815f, 0.707107f);
6661path.close();
6662path.moveTo(18.4879f, -0.171272f);
6663path.quadTo(19.0019f, -0.304236f, 19.5208f, -0.416111f);
6664path.conicTo(20.4984f, -0.62685f, 20.7091f, 0.350692f, 0.707107f);
6665path.conicTo(20.9198f, 1.32823f, 19.9423f, 1.53897f, 0.707107f);
6666path.quadTo(19.4633f, 1.64224f, 18.9889f, 1.76498f);
6667path.conicTo(18.0207f, 2.01544f, 17.7703f, 1.04732f, 0.707107f);
6668path.conicTo(17.5198f, 0.0791926f, 18.4879f, -0.171272f, 0.707107f);
6669path.close();
6670path.moveTo(21.5882f, -0.77517f);
6671path.quadTo(22.1056f, -0.843665f, 22.6254f, -0.891339f);
6672path.conicTo(23.6212f, -0.982672f, 23.7126f, 0.0131486f, 0.707107f);
6673path.conicTo(23.8039f, 1.00897f, 22.8081f, 1.1003f, 0.707107f);
6674path.quadTo(22.3283f, 1.14431f, 21.8506f, 1.20754f);
6675path.conicTo(20.8592f, 1.33876f, 20.728f, 0.347405f, 0.707107f);
6676path.conicTo(20.5968f, -0.643948f, 21.5882f, -0.77517f, 0.707107f);
6677path.close();
6678path.moveTo(24.7026f, -0.998301f);
6679path.quadTo(25.2241f, -1.00426f, 25.7453f, -0.989316f);
6680path.conicTo(26.7449f, -0.960651f, 26.7162f, 0.0389383f, 0.707107f);
6681path.conicTo(26.6876f, 1.03853f, 25.688f, 1.00986f, 0.707107f);
6682path.quadTo(25.2068f, 0.996064f, 24.7255f, 1.00157f);
6683path.conicTo(23.7256f, 1.013f, 23.7141f, 0.0130688f, 0.707107f);
6684path.conicTo(23.7027f, -0.986866f, 24.7026f, -0.998301f, 0.707107f);
6685path.close();
6686path.moveTo(27.8388f, -0.844563f);
6687path.quadTo(28.3559f, -0.787759f, 28.8704f, -0.710314f);
6688path.conicTo(29.8592f, -0.561454f, 29.7104f, 0.427404f, 0.707107f);
6689path.conicTo(29.5615f, 1.41626f, 28.5726f, 1.2674f, 0.707107f);
6690path.quadTo(28.0978f, 1.19591f, 27.6204f, 1.14348f);
6691path.conicTo(26.6264f, 1.0343f, 26.7356f, 0.0402742f, 0.707107f);
6692path.conicTo(26.8447f, -0.953747f, 27.8388f, -0.844563f, 0.707107f);
6693path.close();
6694path.moveTo(30.9153f, -0.318153f);
6695path.quadTo(31.4481f, -0.193671f, 31.9752f, -0.046875f);
6696path.conicTo(32.9386f, 0.221405f, 32.6703f, 1.18475f, 0.707107f);
6697path.conicTo(32.402f, 2.14809f, 31.4387f, 1.87981f, 0.707107f);
6698path.quadTo(30.9521f, 1.74431f, 30.4603f, 1.6294f);
6699path.conicTo(29.4865f, 1.40189f, 29.714f, 0.428111f, 0.707107f);
6700path.conicTo(29.9416f, -0.545664f, 30.9153f, -0.318153f, 0.707107f);
6701path.close();
6702path.moveTo(34.0252f, 0.616677f);
6703path.quadTo(34.5221f, 0.800609f, 35.0111f, 1.00465f);
6704path.conicTo(35.934f, 1.3897f, 35.549f, 2.31259f, 0.707107f);
6705path.conicTo(35.1639f, 3.23549f, 34.241f, 2.85044f, 0.707107f);
6706path.quadTo(33.7896f, 2.66211f, 33.3309f, 2.49232f);
6707path.conicTo(32.3931f, 2.1452f, 32.7402f, 1.20738f, 0.707107f);
6708path.conicTo(33.0873f, 0.269559f, 34.0252f, 0.616677f, 0.707107f);
6709path.close();
6710path.moveTo(36.8967f, 1.88141f);
6711path.quadTo(37.3499f, 2.11462f, 37.7936f, 2.3654f);
6712path.conicTo(38.6641f, 2.85746f, 38.1721f, 3.72802f, 0.707107f);
6713path.conicTo(37.68f, 4.59858f, 36.8094f, 4.10652f, 0.707107f);
6714path.quadTo(36.3999f, 3.87504f, 35.9815f, 3.65976f);
6715path.conicTo(35.0924f, 3.2022f, 35.5499f, 2.31302f, 0.707107f);
6716path.conicTo(36.0075f, 1.42384f, 36.8967f, 1.88141f, 0.707107f);
6717path.close();
6718path.moveTo(39.4914f, 3.413f);
6719path.lineTo(39.5381f, 3.44439f);
6720path.quadTo(39.9244f, 3.70494f, 40.3002f, 3.97845f);
6721path.conicTo(41.1087f, 4.56692f, 40.5202f, 5.37544f, 0.707107f);
6722path.conicTo(39.9317f, 6.18396f, 39.1232f, 5.59549f, 0.707107f);
6723path.quadTo(38.7763f, 5.34298f, 38.4215f, 5.10371f);
6724path.lineTo(38.3749f, 5.07232f);
6725path.conicTo(37.5452f, 4.51406f, 38.1035f, 3.68439f, 0.707107f);
6726path.conicTo(38.6618f, 2.85473f, 39.4914f, 3.413f, 0.707107f);
6727path.close();
6728path.moveTo(41.8859f, 5.22965f);
6729path.quadTo(42.2782f, 5.56471f, 42.6568f, 5.91499f);
6730path.conicTo(43.3908f, 6.5941f, 42.7117f, 7.32814f, 0.707107f);
6731path.conicTo(42.0326f, 8.06218f, 41.2986f, 7.38308f, 0.707107f);
6732path.quadTo(40.949f, 7.05968f, 40.587f, 6.75043f);
6733path.conicTo(39.8266f, 6.10097f, 40.476f, 5.34058f, 0.707107f);
6734path.conicTo(41.1255f, 4.58018f, 41.8859f, 5.22965f, 0.707107f);
6735path.close();
6736path.moveTo(44.1413f, 7.40421f);
6737path.quadTo(44.5035f, 7.79829f, 44.8493f, 8.20695f);
6738path.conicTo(45.4952f, 8.97038f, 44.7317f, 9.61627f, 0.707107f);
6739path.conicTo(43.9683f, 10.2622f, 43.3224f, 9.49874f, 0.707107f);
6740path.quadTo(43.0033f, 9.1215f, 42.6689f, 8.75773f);
6741path.conicTo(41.9921f, 8.02152f, 42.7283f, 7.34476f, 0.707107f);
6742path.conicTo(43.4645f, 6.668f, 44.1413f, 7.40421f, 0.707107f);
6743path.close();
6744path.moveTo(46.183f, 9.9242f);
6745path.quadTo(46.4888f, 10.3539f, 46.777f, 10.7957f);
6746path.conicTo(47.3233f, 11.6332f, 46.4857f, 12.1796f, 0.707107f);
6747path.conicTo(45.6482f, 12.7259f, 45.1018f, 11.8883f, 0.707107f);
6748path.quadTo(44.8358f, 11.4805f, 44.5535f, 11.0839f);
6749path.conicTo(43.9737f, 10.2691f, 44.7884f, 9.6893f, 0.707107f);
6750path.conicTo(45.6032f, 9.10947f, 46.183f, 9.9242f, 0.707107f);
6751path.close();
6752path.moveTo(47.8333f, 12.5645f);
6753path.quadTo(48.0821f, 13.0214f, 48.3125f, 13.4879f);
6754path.conicTo(48.7552f, 14.3845f, 47.8586f, 14.8273f, 0.707107f);
6755path.conicTo(46.962f, 15.2701f, 46.5192f, 14.3734f, 0.707107f);
6756path.quadTo(46.3065f, 13.9428f, 46.0769f, 13.5211f);
6757path.conicTo(45.5986f, 12.6429f, 46.4768f, 12.1646f, 0.707107f);
6758path.conicTo(47.355f, 11.6863f, 47.8333f, 12.5645f, 0.707107f);
6759path.close();
6760path.moveTo(49.1641f, 15.4033f);
6761path.quadTo(49.3588f, 15.8935f, 49.5334f, 16.3912f);
6762path.conicTo(49.8645f, 17.3348f, 48.9209f, 17.6659f, 0.707107f);
6763path.conicTo(47.9773f, 17.997f, 47.6462f, 17.0534f, 0.707107f);
6764path.quadTo(47.485f, 16.5939f, 47.3053f, 16.1415f);
6765path.conicTo(46.9362f, 15.2121f, 47.8656f, 14.843f, 0.707107f);
6766path.conicTo(48.795f, 14.4739f, 49.1641f, 15.4033f, 0.707107f);
6767path.close();
6768path.moveTo(50.1526f, 18.4161f);
6769path.quadTo(50.287f, 18.9296f, 50.4003f, 19.4482f);
6770path.conicTo(50.6139f, 20.4252f, 49.6369f, 20.6387f, 0.707107f);
6771path.conicTo(48.66f, 20.8522f, 48.4465f, 19.8753f, 0.707107f);
6772path.quadTo(48.3419f, 19.3966f, 48.2178f, 18.9225f);
6773path.conicTo(47.9645f, 17.9551f, 48.9319f, 17.7019f, 0.707107f);
6774path.conicTo(49.8993f, 17.4487f, 50.1526f, 18.4161f, 0.707107f);
6775path.close();
6776path.moveTo(50.7655f, 21.5157f);
6777path.quadTo(50.8354f, 22.033f, 50.8846f, 22.5528f);
6778path.conicTo(50.9787f, 23.5483f, 49.9831f, 23.6425f, 0.707107f);
6779path.conicTo(48.9876f, 23.7366f, 48.8935f, 22.741f, 0.707107f);
6780path.quadTo(48.8481f, 22.2613f, 48.7835f, 21.7837f);
6781path.conicTo(48.6495f, 20.7928f, 49.6405f, 20.6587f, 0.707107f);
6782path.conicTo(50.6315f, 20.5247f, 50.7655f, 21.5157f, 0.707107f);
6783path.close();
6784path.moveTo(50.9974f, 24.6301f);
6785path.quadTo(51.0048f, 25.1509f, 50.9913f, 25.6715f);
6786path.conicTo(50.9655f, 26.6712f, 49.9658f, 26.6454f, 0.707107f);
6787path.conicTo(48.9662f, 26.6196f, 48.992f, 25.6199f, 0.707107f);
6788path.quadTo(49.0044f, 25.1393f, 48.9976f, 24.6585f);
6789path.conicTo(48.9834f, 23.6586f, 49.9833f, 23.6444f, 0.707107f);
6790path.conicTo(50.9832f, 23.6302f, 50.9974f, 24.6301f, 0.707107f);
6791path.close();
6792path.moveTo(50.8524f, 27.7662f);
6793path.quadTo(50.7971f, 28.2837f, 50.721f, 28.7986f);
6794path.conicTo(50.5749f, 29.7879f, 49.5856f, 29.6418f, 0.707107f);
6795path.conicTo(48.5963f, 29.4957f, 48.7425f, 28.5064f, 0.707107f);
6796path.quadTo(48.8127f, 28.0311f, 48.8638f, 27.5534f);
6797path.conicTo(48.9702f, 26.5591f, 49.9645f, 26.6655f, 0.707107f);
6798path.conicTo(50.9588f, 26.7718f, 50.8524f, 27.7662f, 0.707107f);
6799path.close();
6800path.moveTo(50.3355f, 30.8404f);
6801path.quadTo(50.2125f, 31.3739f, 50.0672f, 31.9018f);
6802path.conicTo(49.8018f, 32.8659f, 48.8376f, 32.6005f, 0.707107f);
6803path.conicTo(47.8735f, 32.335f, 48.139f, 31.3709f, 0.707107f);
6804path.quadTo(48.2731f, 30.8836f, 48.3867f, 30.3912f);
6805path.conicTo(48.6113f, 29.4167f, 49.5857f, 29.6413f, 0.707107f);
6806path.conicTo(50.5602f, 29.866f, 50.3355f, 30.8404f, 0.707107f);
6807path.close();
6808path.moveTo(49.4091f, 33.9552f);
6809path.quadTo(49.2264f, 34.4531f, 49.0236f, 34.9431f);
6810path.conicTo(48.6412f, 35.8671f, 47.7172f, 35.4846f, 0.707107f);
6811path.conicTo(46.7932f, 35.1022f, 47.1757f, 34.1782f, 0.707107f);
6812path.quadTo(47.3629f, 33.7259f, 47.5315f, 33.2663f);
6813path.conicTo(47.8759f, 32.3275f, 48.8147f, 32.672f, 0.707107f);
6814path.conicTo(49.7535f, 33.0164f, 49.4091f, 33.9552f, 0.707107f);
6815path.close();
6816path.moveTo(48.1514f, 36.8328f);
6817path.quadTo(47.9191f, 37.2871f, 47.6694f, 37.7318f);
6818path.conicTo(47.1797f, 38.6038f, 46.3078f, 38.1141f, 0.707107f);
6819path.conicTo(45.4359f, 37.6244f, 45.9256f, 36.7525f, 0.707107f);
6820path.quadTo(46.1562f, 36.3418f, 46.3705f, 35.9226f);
6821path.conicTo(46.8256f, 35.0321f, 47.716f, 35.4872f, 0.707107f);
6822path.conicTo(48.6065f, 35.9423f, 48.1514f, 36.8328f, 0.707107f);
6823path.close();
6824path.moveTo(46.6245f, 39.4354f);
6825path.lineTo(46.5563f, 39.537f);
6826path.quadTo(46.3146f, 39.8955f, 46.0624f, 40.2438f);
6827path.conicTo(45.4761f, 41.0539f, 44.666f, 40.4676f, 0.707107f);
6828path.conicTo(43.8559f, 39.8813f, 44.4422f, 39.0712f, 0.707107f);
6829path.quadTo(44.6749f, 38.7498f, 44.8955f, 38.4226f);
6830path.lineTo(44.9637f, 38.3211f);
6831path.conicTo(45.5209f, 37.4907f, 46.3513f, 38.0479f, 0.707107f);
6832path.conicTo(47.1817f, 38.605f, 46.6245f, 39.4354f, 0.707107f);
6833path.close();
6834path.moveTo(44.8168f, 41.8314f);
6835path.quadTo(44.4832f, 42.2241f, 44.1342f, 42.6034f);
6836path.conicTo(43.4572f, 43.3394f, 42.7212f, 42.6623f, 0.707107f);
6837path.conicTo(41.9853f, 41.9853f, 42.6623f, 41.2494f, 0.707107f);
6838path.quadTo(42.9845f, 40.8992f, 43.2924f, 40.5366f);
6839path.conicTo(43.9398f, 39.7745f, 44.702f, 40.4218f, 0.707107f);
6840path.conicTo(45.4642f, 41.0692f, 44.8168f, 41.8314f, 0.707107f);
6841path.close();
6842path.moveTo(42.6505f, 44.0908f);
6843path.quadTo(42.2577f, 44.454f, 41.8504f, 44.8006f);
6844path.conicTo(41.0888f, 45.4487f, 40.4408f, 44.6871f, 0.707107f);
6845path.conicTo(39.7927f, 43.9256f, 40.5542f, 43.2775f, 0.707107f);
6846path.quadTo(40.9302f, 42.9575f, 41.2928f, 42.6223f);
6847path.conicTo(42.027f, 41.9434f, 42.7059f, 42.6777f, 0.707107f);
6848path.conicTo(43.3848f, 43.412f, 42.6505f, 44.0908f, 0.707107f);
6849path.close();
6850path.moveTo(40.1383f, 46.1384f);
6851path.quadTo(39.7073f, 46.4471f, 39.2641f, 46.7378f);
6852path.conicTo(38.4281f, 47.2865f, 37.8795f, 46.4504f, 0.707107f);
6853path.conicTo(37.3308f, 45.6143f, 38.1669f, 45.0657f, 0.707107f);
6854path.quadTo(38.576f, 44.7972f, 38.9738f, 44.5124f);
6855path.conicTo(39.7868f, 43.9301f, 40.369f, 44.7432f, 0.707107f);
6856path.conicTo(40.9513f, 45.5562f, 40.1383f, 46.1384f, 0.707107f);
6857path.close();
6858path.moveTo(37.4991f, 47.7985f);
6859path.quadTo(37.0431f, 48.0485f, 36.5775f, 48.2801f);
6860path.conicTo(35.6821f, 48.7254f, 35.2368f, 47.83f, 0.707107f);
6861path.conicTo(34.7915f, 46.9346f, 35.6869f, 46.4893f, 0.707107f);
6862path.quadTo(36.1167f, 46.2755f, 36.5376f, 46.0448f);
6863path.conicTo(37.4145f, 45.5641f, 37.8952f, 46.4409f, 0.707107f);
6864path.conicTo(38.376f, 47.3178f, 37.4991f, 47.7985f, 0.707107f);
6865path.close();
6866path.moveTo(34.6651f, 49.1368f);
6867path.quadTo(34.1756f, 49.3328f, 33.6785f, 49.5089f);
6868path.conicTo(32.7358f, 49.8427f, 32.402f, 48.9f, 0.707107f);
6869path.conicTo(32.0682f, 47.9574f, 33.0109f, 47.6236f, 0.707107f);
6870path.quadTo(33.4697f, 47.4611f, 33.9216f, 47.2801f);
6871path.conicTo(34.85f, 46.9084f, 35.2217f, 47.8368f, 0.707107f);
6872path.conicTo(35.5934f, 48.7651f, 34.6651f, 49.1368f, 0.707107f);
6873path.close();
6874path.moveTo(31.6557f, 50.1337f);
6875path.quadTo(31.1425f, 50.2696f, 30.6243f, 50.3844f);
6876path.conicTo(29.648f, 50.6007f, 29.4317f, 49.6244f, 0.707107f);
6877path.conicTo(29.2153f, 48.6481f, 30.1917f, 48.4317f, 0.707107f);
6878path.quadTo(30.6701f, 48.3257f, 31.1437f, 48.2003f);
6879path.conicTo(32.1104f, 47.9443f, 32.3664f, 48.911f, 0.707107f);
6880path.conicTo(32.6223f, 49.8777f, 31.6557f, 50.1337f, 0.707107f);
6881path.close();
6882path.moveTo(28.5567f, 50.7556f);
6883path.quadTo(28.0395f, 50.827f, 27.5198f, 50.8776f);
6884path.conicTo(26.5245f, 50.9745f, 26.4276f, 49.9792f, 0.707107f);
6885path.conicTo(26.3307f, 48.9839f, 27.326f, 48.887f, 0.707107f);
6886path.quadTo(27.8056f, 48.8403f, 28.2831f, 48.7744f);
6887path.conicTo(29.2737f, 48.6376f, 29.4105f, 49.6282f, 0.707107f);
6888path.conicTo(29.5473f, 50.6188f, 28.5567f, 50.7556f, 0.707107f);
6889path.close();
6890path.moveTo(25.4424f, 50.9962f);
6891path.quadTo(24.9222f, 51.0051f, 24.4022f, 50.9931f);
6892path.conicTo(23.4025f, 50.9701f, 23.4255f, 49.9704f, 0.707107f);
6893path.conicTo(23.4485f, 48.9707f, 24.4482f, 48.9937f, 0.707107f);
6894path.quadTo(24.9283f, 49.0047f, 25.4084f, 48.9965f);
6895path.conicTo(26.4083f, 48.9795f, 26.4253f, 49.9794f, 0.707107f);
6896path.conicTo(26.4423f, 50.9792f, 25.4424f, 50.9962f, 0.707107f);
6897path.close();
6898path.moveTo(22.3065f, 50.8601f);
6899path.quadTo(21.7885f, 50.8062f, 21.2732f, 50.7315f);
6900path.conicTo(20.2835f, 50.5882f, 20.4268f, 49.5985f, 0.707107f);
6901path.conicTo(20.5702f, 48.6088f, 21.5599f, 48.7522f, 0.707107f);
6902path.quadTo(22.0355f, 48.8211f, 22.5136f, 48.8709f);
6903path.conicTo(23.5083f, 48.9745f, 23.4047f, 49.9691f, 0.707107f);
6904path.conicTo(23.3011f, 50.9637f, 22.3065f, 50.8601f, 0.707107f);
6905path.close();
6906path.moveTo(19.2346f, 50.3527f);
6907path.quadTo(18.7003f, 50.2312f, 18.1717f, 50.0873f);
6908path.conicTo(17.2068f, 49.8247f, 17.4694f, 48.8598f, 0.707107f);
6909path.conicTo(17.732f, 47.8949f, 18.6969f, 48.1575f, 0.707107f);
6910path.quadTo(19.185f, 48.2904f, 19.6781f, 48.4025f);
6911path.conicTo(20.6532f, 48.6243f, 20.4314f, 49.5994f, 0.707107f);
6912path.conicTo(20.2097f, 50.5745f, 19.2346f, 50.3527f, 0.707107f);
6913path.close();
6914path.moveTo(16.1149f, 49.4347f);
6915path.quadTo(15.6161f, 49.2533f, 15.1251f, 49.0517f);
6916path.conicTo(14.2f, 48.6719f, 14.5798f, 47.7469f, 0.707107f);
6917path.conicTo(14.9596f, 46.8218f, 15.8847f, 47.2016f, 0.707107f);
6918path.quadTo(16.3379f, 47.3877f, 16.7984f, 47.5551f);
6919path.conicTo(17.7382f, 47.8969f, 17.3964f, 48.8366f, 0.707107f);
6920path.conicTo(17.0547f, 49.7764f, 16.1149f, 49.4347f, 0.707107f);
6921path.close();
6922path.moveTo(13.2313f, 48.184f);
6923path.quadTo(12.776f, 47.9529f, 12.33f, 47.704f);
6924path.conicTo(11.4568f, 47.2167f, 11.9441f, 46.3434f, 0.707107f);
6925path.conicTo(12.4314f, 45.4702f, 13.3046f, 45.9575f, 0.707107f);
6926path.quadTo(13.7162f, 46.1872f, 14.1365f, 46.4006f);
6927path.conicTo(15.0282f, 46.8532f, 14.5756f, 47.7449f, 0.707107f);
6928path.conicTo(14.123f, 48.6366f, 13.2313f, 48.184f, 0.707107f);
6929path.close();
6930path.moveTo(10.6208f, 46.6619f);
6931path.lineTo(10.4641f, 46.5571f);
6932path.quadTo(10.1333f, 46.334f, 9.81253f, 46.1031f);
6933path.conicTo(9.00087f, 45.519f, 9.585f, 44.7073f, 0.707107f);
6934path.conicTo(10.1691f, 43.8957f, 10.9808f, 44.4798f, 0.707107f);
6935path.quadTo(11.2769f, 44.6929f, 11.5763f, 44.8948f);
6936path.lineTo(11.7329f, 44.9996f);
6937path.conicTo(12.564f, 45.5557f, 12.008f, 46.3868f, 0.707107f);
6938path.conicTo(11.4519f, 47.2179f, 10.6208f, 46.6619f, 0.707107f);
6939path.close();
6940path.moveTo(8.22326f, 44.8631f);
6941path.quadTo(7.82986f, 44.5308f, 7.44999f, 44.1833f);
6942path.conicTo(6.71217f, 43.5082f, 7.38718f, 42.7704f, 0.707107f);
6943path.conicTo(8.06219f, 42.0326f, 8.8f, 42.7076f, 0.707107f);
6944path.quadTo(9.15066f, 43.0284f, 9.51375f, 43.3351f);
6945path.conicTo(10.2777f, 43.9804f, 9.63248f, 44.7443f, 0.707107f);
6946path.conicTo(8.98724f, 45.5083f, 8.22326f, 44.8631f, 0.707107f);
6947path.close();
6948path.moveTo(5.95972f, 42.705f);
6949path.quadTo(5.59577f, 42.3136f, 5.24823f, 41.9076f);
6950path.conicTo(4.59793f, 41.148f, 5.3576f, 40.4977f, 0.707107f);
6951path.conicTo(6.11728f, 39.8473f, 6.76758f, 40.607f, 0.707107f);
6952path.quadTo(7.08843f, 40.9818f, 7.42436f, 41.3431f);
6953path.conicTo(8.10532f, 42.0754f, 7.373f, 42.7564f, 0.707107f);
6954path.conicTo(6.64068f, 43.4373f, 5.95972f, 42.705f, 0.707107f);
6955path.close();
6956path.moveTo(3.90635f, 40.2006f);
6957path.quadTo(3.59492f, 39.7684f, 3.30147f, 39.3239f);
6958path.conicTo(2.75055f, 38.4893f, 3.58511f, 37.9384f, 0.707107f);
6959path.conicTo(4.41967f, 37.3875f, 4.97059f, 38.222f, 0.707107f);
6960path.quadTo(5.24148f, 38.6324f, 5.52894f, 39.0313f);
6961path.conicTo(6.11358f, 39.8426f, 5.30228f, 40.4272f, 0.707107f);
6962path.conicTo(4.49099f, 41.0119f, 3.90635f, 40.2006f, 0.707107f);
6963path.close();
6964path.moveTo(2.23643f, 37.5626f);
6965path.quadTo(1.98525f, 37.1075f, 1.75248f, 36.6427f);
6966path.conicTo(1.30469f, 35.7486f, 2.19883f, 35.3008f, 0.707107f);
6967path.conicTo(3.09296f, 34.853f, 3.54076f, 35.7471f, 0.707107f);
6968path.quadTo(3.75563f, 36.1762f, 3.98747f, 36.5963f);
6969path.conicTo(4.47065f, 37.4718f, 3.59513f, 37.955f, 0.707107f);
6970path.conicTo(2.71961f, 38.4382f, 2.23643f, 37.5626f, 0.707107f);
6971path.close();
6972path.moveTo(0.890647f, 34.7334f);
6973path.quadTo(0.69328f, 34.2445f, 0.515902f, 33.7481f);
6974path.conicTo(0.179435f, 32.8064f, 1.12113f, 32.4699f, 0.707107f);
6975path.conicTo(2.06282f, 32.1335f, 2.39929f, 33.0752f, 0.707107f);
6976path.quadTo(2.56303f, 33.5334f, 2.74521f, 33.9847f);
6977path.conicTo(3.11957f, 34.912f, 2.19229f, 35.2863f, 0.707107f);
6978path.conicTo(1.26501f, 35.6607f, 0.890647f, 34.7334f, 0.707107f);
6979path.close();
6980path.moveTo(-0.114587f, 31.7274f);
6981path.quadTo(-0.251922f, 31.2147f, -0.368218f, 30.6968f);
6982path.conicTo(-0.587327f, 29.7211f, 0.388373f, 29.502f, 0.707107f);
6983path.conicTo(1.36407f, 29.2829f, 1.58318f, 30.2586f, 0.707107f);
6984path.quadTo(1.69053f, 30.7366f, 1.8173f, 31.2099f);
6985path.conicTo(2.07605f, 32.1758f, 1.1101f, 32.4346f, 0.707107f);
6986path.conicTo(0.144159f, 32.6933f, -0.114587f, 31.7274f, 0.707107f);
6987path.close();
6988path.moveTo(-0.745485f, 28.6291f);
6989path.quadTo(-0.818367f, 28.112f, -0.870432f, 27.5925f);
6990path.conicTo(-0.970142f, 26.5974f, 0.0248742f, 26.4977f, 0.707107f);
6991path.conicTo(1.01989f, 26.398f, 1.1196f, 27.393f, 0.707107f);
6992path.quadTo(1.16766f, 27.8726f, 1.23494f, 28.3499f);
6993path.conicTo(1.37452f, 29.3401f, 0.384305f, 29.4797f, 0.707107f);
6994path.conicTo(-0.605905f, 29.6193f, -0.745485f, 28.6291f, 0.707107f);
6995path.close();
6996path.moveTo(-0.994901f, 25.515f);
6997path.quadTo(-1.00519f, 24.9955f, -0.994722f, 24.4761f);
6998path.conicTo(-0.97457f, 23.4763f, 0.0252273f, 23.4964f, 0.707107f);
6999path.conicTo(1.02502f, 23.5166f, 1.00487f, 24.5164f, 0.707107f);
7000path.quadTo(0.995207f, 24.9959f, 1.00471f, 25.4754f);
7001path.conicTo(1.02451f, 26.4752f, 0.0247103f, 26.495f, 0.707107f);
7002path.conicTo(-0.975093f, 26.5148f, -0.994901f, 25.515f, 0.707107f);
7003path.close();
7004path.moveTo(-0.867571f, 22.3792f);
7005path.quadTo(-0.81506f, 21.8609f, -0.741825f, 21.3451f);
7006path.conicTo(-0.60125f, 20.355f, 0.38882f, 20.4956f, 0.707107f);
7007path.conicTo(1.37889f, 20.6361f, 1.23831f, 21.6262f, 0.707107f);
7008path.quadTo(1.17071f, 22.1023f, 1.12224f, 22.5807f);
7009path.conicTo(1.02144f, 23.5757f, 0.026537f, 23.4749f, 0.707107f);
7010path.conicTo(-0.96837f, 23.3741f, -0.867571f, 22.3792f, 0.707107f);
7011path.close();
7012path.moveTo(-0.369678f, 19.3097f);
7013path.quadTo(-0.249693f, 18.7748f, -0.107265f, 18.2453f);
7014path.conicTo(0.152529f, 17.2797f, 1.11819f, 17.5395f, 0.707107f);
7015path.conicTo(2.08386f, 17.7993f, 1.82406f, 18.7649f, 0.707107f);
7016path.quadTo(1.69259f, 19.2536f, 1.58184f, 19.7474f);
7017path.conicTo(1.36298f, 20.7232f, 0.387221f, 20.5043f, 0.707107f);
7018path.conicTo(-0.588536f, 20.2855f, -0.369678f, 19.3097f, 0.707107f);
7019path.close();
7020path.moveTo(0.539863f, 16.1851f);
7021path.quadTo(0.719962f, 15.6854f, 0.920307f, 15.1934f);
7022path.conicTo(1.29748f, 14.2673f, 2.22362f, 14.6445f, 0.707107f);
7023path.conicTo(3.14976f, 15.0216f, 2.7726f, 15.9478f, 0.707107f);
7024path.quadTo(2.58765f, 16.4019f, 2.42141f, 16.8632f);
7025path.conicTo(2.08237f, 17.804f, 1.1416f, 17.4649f, 0.707107f);
7026path.conicTo(0.200823f, 17.1259f, 0.539863f, 16.1851f, 0.707107f);
7027path.close();
7028path.moveTo(1.78353f, 13.2955f);
7029path.quadTo(2.01364f, 12.8391f, 2.26151f, 12.392f);
7030path.conicTo(2.74643f, 11.5175f, 3.62099f, 12.0024f, 0.707107f);
7031path.conicTo(4.49555f, 12.4873f, 4.01063f, 13.3618f, 0.707107f);
7032path.quadTo(3.78183f, 13.7745f, 3.56941f, 14.1958f);
7033path.conicTo(3.11923f, 15.0888f, 2.22629f, 14.6386f, 0.707107f);
7034path.conicTo(1.33336f, 14.1884f, 1.78353f, 13.2955f, 0.707107f);
7035path.close();
7036path.moveTo(3.30083f, 10.6771f);
7037path.lineTo(3.44218f, 10.4652f);
7038path.quadTo(3.6466f, 10.1621f, 3.85641f, 9.86895f);
7039path.conicTo(4.43837f, 9.05574f, 5.25159f, 9.6377f, 0.707107f);
7040path.conicTo(6.0648f, 10.2197f, 5.48284f, 11.0329f, 0.707107f);
7041path.quadTo(5.28917f, 11.3035f, 5.10592f, 11.5752f);
7042path.lineTo(4.96457f, 11.787f);
7043path.conicTo(4.4096f, 12.6189f, 3.57773f, 12.0639f, 0.707107f);
7044path.conicTo(2.74586f, 11.509f, 3.30083f, 10.6771f, 0.707107f);
7045path.close();
7046path.moveTo(5.0909f, 8.27793f);
7047path.quadTo(5.42174f, 7.88403f, 5.76791f, 7.50353f);
7048path.conicTo(6.44085f, 6.76383f, 7.18054f, 7.43678f, 0.707107f);
7049path.conicTo(7.92024f, 8.10972f, 7.24729f, 8.84942f, 0.707107f);
7050path.quadTo(6.92775f, 9.20065f, 6.62237f, 9.56424f);
7051path.conicTo(5.97921f, 10.33f, 5.21348f, 9.68682f, 0.707107f);
7052path.conicTo(4.44774f, 9.04367f, 5.0909f, 8.27793f, 0.707107f);
7053path.close();
7054path.moveTo(7.24064f, 6.0104f);
7055path.quadTo(7.63069f, 5.64561f, 8.03537f, 5.29717f);
7056path.conicTo(8.79318f, 4.64469f, 9.44566f, 5.40249f, 0.707107f);
7057path.conicTo(10.0981f, 6.16029f, 9.34034f, 6.81278f, 0.707107f);
7058path.quadTo(8.96678f, 7.13442f, 8.60675f, 7.47113f);
7059path.conicTo(7.87638f, 8.15419f, 7.19332f, 7.42382f, 0.707107f);
7060path.conicTo(6.51027f, 6.69345f, 7.24064f, 6.0104f, 0.707107f);
7061path.close();
7062path.moveTo(9.73726f, 3.95128f);
7063path.quadTo(10.1706f, 3.63704f, 10.6165f, 3.34092f);
7064path.conicTo(11.4496f, 2.78771f, 12.0028f, 3.62075f, 0.707107f);
7065path.conicTo(12.556f, 4.4538f, 11.7229f, 5.007f, 0.707107f);
7066path.quadTo(11.3113f, 5.28035f, 10.9113f, 5.57041f);
7067path.conicTo(10.1018f, 6.15744f, 9.51472f, 5.34787f, 0.707107f);
7068path.conicTo(8.92769f, 4.53831f, 9.73726f, 3.95128f, 0.707107f);
7069path.close();
7070path.moveTo(12.374f, 2.27153f);
7071path.quadTo(12.8282f, 2.01921f, 13.2921f, 1.78522f);
7072path.conicTo(14.185f, 1.33492f, 14.6353f, 2.22779f, 0.707107f);
7073path.conicTo(15.0856f, 3.12067f, 14.1927f, 3.57097f, 0.707107f);
7074path.quadTo(13.7645f, 3.78696f, 13.3452f, 4.01988f);
7075path.conicTo(12.471f, 4.5055f, 11.9854f, 3.63132f, 0.707107f);
7076path.conicTo(11.4998f, 2.75715f, 12.374f, 2.27153f, 0.707107f);
7077path.close();
7078path.moveTo(15.1984f, 0.918296f);
7079path.quadTo(15.6866f, 0.719602f, 16.1824f, 0.540851f);
7080path.conicTo(17.1231f, 0.20171f, 17.4623f, 1.14245f, 0.707107f);
7081path.conicTo(17.8014f, 2.08318f, 16.8607f, 2.42232f, 0.707107f);
7082path.quadTo(16.403f, 2.58733f, 15.9524f, 2.77074f);
7083path.conicTo(15.0261f, 3.14772f, 14.6492f, 2.2215f, 0.707107f);
7084path.conicTo(14.2722f, 1.29528f, 15.1984f, 0.918296f, 0.707107f);
7085path.close();
7086path.moveTo(18.201f, -0.0952874f);
7087path.quadTo(18.7132f, -0.234075f, 19.2308f, -0.351842f);
7088path.conicTo(20.2058f, -0.573734f, 20.4277f, 0.401338f, 0.707107f);
7089path.conicTo(20.6496f, 1.37641f, 19.6745f, 1.5983f, 0.707107f);
7090path.quadTo(19.1968f, 1.70701f, 18.724f, 1.83512f);
7091path.conicTo(17.7588f, 2.09662f, 17.4973f, 1.13142f, 0.707107f);
7092path.conicTo(17.2358f, 0.166216f, 18.201f, -0.0952874f, 0.707107f);
7093path.close();
7094path.moveTo(21.2986f, -0.73518f);
7095path.quadTo(21.8155f, -0.809526f, 22.3349f, -0.863052f);
7096path.conicTo(23.3297f, -0.965552f, 23.4322f, 0.029181f, 0.707107f);
7097path.conicTo(23.5347f, 1.02391f, 22.5399f, 1.12641f, 0.707107f);
7098path.quadTo(22.0604f, 1.17582f, 21.5833f, 1.24445f);
7099path.conicTo(20.5935f, 1.38681f, 20.4511f, 0.397f, 0.707107f);
7100path.conicTo(20.3088f, -0.592814f, 21.2986f, -0.73518f, 0.707107f);
7101path.close();
7102path.moveTo(24.4124f, -0.993361f);
7103path.quadTo(24.9312f, -1.00509f, 25.4501f, -0.996107f);
7104path.conicTo(26.4499f, -0.978799f, 26.4326f, 0.0210512f, 0.707107f);
7105path.conicTo(26.4153f, 1.0209f, 25.4155f, 1.00359f, 0.707107f);
7106path.quadTo(24.9365f, 0.995302f, 24.4576f, 1.00613f);
7107path.conicTo(23.4578f, 1.02873f, 23.4352f, 0.0289853f, 0.707107f);
7108path.conicTo(23.4126f, -0.970759f, 24.4124f, -0.993361f, 0.707107f);
7109path.close();
7110path.moveTo(27.5481f, -0.87484f);
7111path.quadTo(28.0668f, -0.823762f, 28.583f, -0.75194f);
7112path.conicTo(29.5734f, -0.614138f, 29.4356f, 0.376322f, 0.707107f);
7113path.conicTo(29.2978f, 1.36678f, 28.3074f, 1.22898f, 0.707107f);
7114path.quadTo(27.8309f, 1.16268f, 27.3521f, 1.11553f);
7115path.conicTo(26.3569f, 1.01753f, 26.4549f, 0.0223428f, 0.707107f);
7116path.conicTo(26.5529f, -0.972843f, 27.5481f, -0.87484f, 0.707107f);
7117path.close();
7118path.moveTo(30.6151f, -0.386432f);
7119path.quadTo(31.1507f, -0.267954f, 31.6809f, -0.126991f);
7120path.conicTo(32.6473f, 0.129965f, 32.3904f, 1.09639f, 0.707107f);
7121path.conicTo(32.1334f, 2.06281f, 31.167f, 1.80585f, 0.707107f);
7122path.quadTo(30.6776f, 1.67574f, 30.1832f, 1.56637f);
7123path.conicTo(29.2068f, 1.35041f, 29.4227f, 0.374005f, 0.707107f);
7124path.conicTo(29.6387f, -0.602396f, 30.6151f, -0.386432f, 0.707107f);
7125path.close();
7126path.moveTo(33.7445f, 0.514616f);
7127path.quadTo(34.2452f, 0.693421f, 34.7381f, 0.892536f);
7128path.conicTo(35.6653f, 1.26708f, 35.2908f, 2.19429f, 0.707107f);
7129path.conicTo(34.9162f, 3.1215f, 33.989f, 2.74696f, 0.707107f);
7130path.quadTo(33.534f, 2.56316f, 33.0718f, 2.3981f);
7131path.conicTo(32.1301f, 2.06177f, 32.4664f, 1.12003f, 0.707107f);
7132path.conicTo(32.8027f, 0.178285f, 33.7445f, 0.514616f, 0.707107f);
7133path.close();
7134path.moveTo(36.6402f, 1.7512f);
7135path.quadTo(37.0977f, 1.98026f, 37.5458f, 2.22715f);
7136path.conicTo(38.4217f, 2.70968f, 37.9392f, 3.58556f, 0.707107f);
7137path.conicTo(37.4566f, 4.46144f, 36.5808f, 3.97891f, 0.707107f);
7138path.quadTo(36.1671f, 3.75102f, 35.7448f, 3.53956f);
7139path.conicTo(34.8506f, 3.09185f, 35.2983f, 2.19767f, 0.707107f);
7140path.conicTo(35.746f, 1.30349f, 36.6402f, 1.7512f, 0.707107f);
7141path.close();
7142path.moveTo(39.2611f, 3.26012f);
7143path.quadTo(39.4005f, 3.35159f, 39.539f, 3.44501f);
7144path.quadTo(39.8091f, 3.62717f, 40.0746f, 3.81611f);
7145path.conicTo(40.8893f, 4.3959f, 40.3096f, 5.21067f, 0.707107f);
7146path.conicTo(39.7298f, 6.02543f, 38.915f, 5.44564f, 0.707107f);
7147path.quadTo(38.67f, 5.2713f, 38.4206f, 5.10309f);
7148path.quadTo(38.293f, 5.017f, 38.164f, 4.9324f);
7149path.conicTo(37.3279f, 4.38388f, 37.8764f, 3.54775f, 0.707107f);
7150path.conicTo(38.4249f, 2.71161f, 39.2611f, 3.26012f, 0.707107f);
7151path.close();
7152path.moveTo(41.6673f, 5.04503f);
7153path.quadTo(42.0618f, 5.37449f, 42.4428f, 5.71927f);
7154path.conicTo(43.1844f, 6.39015f, 42.5135f, 7.13171f, 0.707107f);
7155path.conicTo(41.8426f, 7.87327f, 41.1011f, 7.20239f, 0.707107f);
7156path.quadTo(40.7493f, 6.88414f, 40.3852f, 6.58004f);
7157path.conicTo(39.6177f, 5.93899f, 40.2588f, 5.17149f, 0.707107f);
7158path.conicTo(40.8998f, 4.40399f, 41.6673f, 5.04503f, 0.707107f);
7159path.close();
7160path.moveTo(43.9388f, 7.1865f);
7161path.quadTo(44.3044f, 7.57519f, 44.6538f, 7.97856f);
7162path.conicTo(45.3084f, 8.73448f, 44.5525f, 9.38914f, 0.707107f);
7163path.conicTo(43.7966f, 10.0438f, 43.1419f, 9.28789f, 0.707107f);
7164path.quadTo(42.8195f, 8.91555f, 42.482f, 8.55677f);
7165path.conicTo(41.7969f, 7.82836f, 42.5253f, 7.14322f, 0.707107f);
7166path.conicTo(43.2537f, 6.45808f, 43.9388f, 7.1865f, 0.707107f);
7167path.close();
7168path.moveTo(46.0036f, 9.6753f);
7169path.quadTo(46.3207f, 10.1098f, 46.6195f, 10.5571f);
7170path.conicTo(47.175f, 11.3886f, 46.3435f, 11.9441f, 0.707107f);
7171path.conicTo(45.5119f, 12.4996f, 44.9564f, 11.6681f, 0.707107f);
7172path.quadTo(44.6806f, 11.2552f, 44.388f, 10.8541f);
7173path.conicTo(43.7986f, 10.0463f, 44.6064f, 9.45688f, 0.707107f);
7174path.conicTo(45.4142f, 8.86747f, 46.0036f, 9.6753f, 0.707107f);
7175path.close();
7176path.moveTo(47.6932f, 12.3107f);
7177path.quadTo(47.9467f, 12.764f, 48.1819f, 13.2271f);
7178path.conicTo(48.6347f, 14.1187f, 47.7431f, 14.5715f, 0.707107f);
7179path.conicTo(46.8514f, 15.0243f, 46.3986f, 14.1327f, 0.707107f);
7180path.quadTo(46.1816f, 13.7053f, 45.9476f, 13.2868f);
7181path.conicTo(45.4595f, 12.414f, 46.3323f, 11.9259f, 0.707107f);
7182path.conicTo(47.2051f, 11.4379f, 47.6932f, 12.3107f, 0.707107f);
7183path.close();
7184path.moveTo(49.0539f, 15.1303f);
7185path.quadTo(49.2539f, 15.6178f, 49.434f, 16.113f);
7186path.conicTo(49.7758f, 17.0527f, 48.836f, 17.3946f, 0.707107f);
7187path.conicTo(47.8963f, 17.7364f, 47.5545f, 16.7966f, 0.707107f);
7188path.quadTo(47.3882f, 16.3395f, 47.2036f, 15.8895f);
7189path.conicTo(46.824f, 14.9643f, 47.7491f, 14.5847f, 0.707107f);
7190path.conicTo(48.6743f, 14.2051f, 49.0539f, 15.1303f, 0.707107f);
7191path.close();
7192path.moveTo(50.0758f, 18.1294f);
7193path.quadTo(50.216f, 18.6412f, 50.3352f, 19.1584f);
7194path.conicTo(50.5599f, 20.1328f, 49.5855f, 20.3575f, 0.707107f);
7195path.conicTo(48.6111f, 20.5821f, 48.3864f, 19.6077f, 0.707107f);
7196path.quadTo(48.2763f, 19.1304f, 48.1469f, 18.6579f);
7197path.conicTo(47.8826f, 17.6935f, 48.8471f, 17.4292f, 0.707107f);
7198path.conicTo(49.8115f, 17.165f, 50.0758f, 18.1294f, 0.707107f);
7199path.close();
7200path.moveTo(50.7247f, 21.2262f);
7201path.quadTo(50.8005f, 21.743f, 50.8555f, 22.2623f);
7202path.conicTo(50.9607f, 23.2568f, 49.9663f, 23.3621f, 0.707107f);
7203path.conicTo(48.9719f, 23.4673f, 48.8666f, 22.4729f, 0.707107f);
7204path.quadTo(48.8158f, 21.9935f, 48.7458f, 21.5165f);
7205path.conicTo(48.6007f, 20.5271f, 49.5901f, 20.382f, 0.707107f);
7206path.conicTo(50.5795f, 20.2368f, 50.7247f, 21.2262f, 0.707107f);
7207path.close();
7208path.moveTo(50.9916f, 24.3398f);
7209path.quadTo(51.0048f, 24.858f, 50.9973f, 25.3762f);
7210path.conicTo(50.9828f, 26.3761f, 49.9829f, 26.3616f, 0.707107f);
7211path.conicTo(48.983f, 26.3472f, 48.9975f, 25.3473f, 0.707107f);
7212path.quadTo(49.0044f, 24.8687f, 48.9923f, 24.3906f);
7213path.conicTo(48.9669f, 23.3909f, 49.9665f, 23.3655f, 0.707107f);
7214path.conicTo(50.9662f, 23.3401f, 50.9916f, 24.3398f, 0.707107f);
7215path.close();
7216path.moveTo(50.8819f, 27.4753f);
7217path.quadTo(50.8323f, 27.9943f, 50.7618f, 28.511f);
7218path.conicTo(50.6268f, 29.5018f, 49.636f, 29.3668f, 0.707107f);
7219path.conicTo(48.6451f, 29.2317f, 48.7802f, 28.2409f, 0.707107f);
7220path.quadTo(48.8452f, 27.7641f, 48.891f, 27.2849f);
7221path.conicTo(48.9862f, 26.2894f, 49.9816f, 26.3846f, 0.707107f);
7222path.conicTo(50.9771f, 26.4798f, 50.8819f, 27.4753f, 0.707107f);
7223path.close();
7224path.moveTo(50.4023f, 30.5429f);
7225path.quadTo(50.2856f, 31.0775f, 50.1465f, 31.607f);
7226path.conicTo(49.8924f, 32.5742f, 48.9252f, 32.3201f, 0.707107f);
7227path.conicTo(47.9581f, 32.066f, 48.2122f, 31.0988f, 0.707107f);
7228path.quadTo(48.3405f, 30.6102f, 48.4483f, 30.1165f);
7229path.conicTo(48.6614f, 29.1395f, 49.6385f, 29.3527f, 0.707107f);
7230path.conicTo(50.6155f, 29.5659f, 50.4023f, 30.5429f, 0.707107f);
7231path.close();
7232path.moveTo(49.5104f, 33.674f);
7233path.quadTo(49.3329f, 34.1756f, 49.1351f, 34.6695f);
7234path.conicTo(48.7632f, 35.5977f, 47.8349f, 35.2258f, 0.707107f);
7235path.conicTo(46.9066f, 34.854f, 47.2785f, 33.9257f, 0.707107f);
7236path.quadTo(47.4612f, 33.4697f, 47.625f, 33.0067f);
7237path.conicTo(47.9587f, 32.064f, 48.9014f, 32.3977f, 0.707107f);
7238path.conicTo(49.8441f, 32.7313f, 49.5104f, 33.674f, 0.707107f);
7239path.close();
7240path.moveTo(48.281f, 36.5756f);
7241path.quadTo(48.053f, 37.0342f, 47.8071f, 37.4835f);
7242path.conicTo(47.3269f, 38.3607f, 46.4497f, 37.8805f, 0.707107f);
7243path.conicTo(45.5725f, 37.4004f, 46.0527f, 36.5232f, 0.707107f);
7244path.quadTo(46.2797f, 36.1085f, 46.4901f, 35.6852f);
7245path.conicTo(46.9353f, 34.7898f, 47.8307f, 35.235f, 0.707107f);
7246path.conicTo(48.7262f, 35.6802f, 48.281f, 36.5756f, 0.707107f);
7247path.close();
7248path.moveTo(46.7777f, 39.2033f);
7249path.quadTo(46.6677f, 39.3719f, 46.555f, 39.539f);
7250path.quadTo(46.3865f, 39.7888f, 46.2121f, 40.0349f);
7251path.conicTo(45.6338f, 40.8507f, 44.818f, 40.2724f, 0.707107f);
7252path.conicTo(44.0021f, 39.6942f, 44.5804f, 38.8783f, 0.707107f);
7253path.quadTo(44.7413f, 38.6513f, 44.8969f, 38.4206f);
7254path.quadTo(45.0008f, 38.2665f, 45.1025f, 38.1107f);
7255path.conicTo(45.6488f, 37.2731f, 46.4864f, 37.8194f, 0.707107f);
7256path.conicTo(47.324f, 38.3657f, 46.7777f, 39.2033f, 0.707107f);
7257path.close();
7258path.moveTo(44.9527f, 41.6701f);
7259path.quadTo(44.6177f, 42.0709f, 44.267f, 42.458f);
7260path.conicTo(43.5955f, 43.1991f, 42.8545f, 42.5276f, 0.707107f);
7261path.conicTo(42.1135f, 41.8561f, 42.7849f, 41.1151f, 0.707107f);
7262path.quadTo(43.1087f, 40.7578f, 43.4178f, 40.3878f);
7263path.conicTo(44.059f, 39.6203f, 44.8264f, 40.2615f, 0.707107f);
7264path.conicTo(45.5938f, 40.9027f, 44.9527f, 41.6701f, 0.707107f);
7265path.close();
7266path.moveTo(42.7884f, 43.9624f);
7267path.quadTo(42.4083f, 44.319f, 42.014f, 44.6602f);
7268path.conicTo(41.2578f, 45.3146f, 40.6034f, 44.5585f, 0.707107f);
7269path.conicTo(39.949f, 43.8023f, 40.7052f, 43.1479f, 0.707107f);
7270path.quadTo(41.0691f, 42.833f, 41.4201f, 42.5037f);
7271path.conicTo(42.1494f, 41.8196f, 42.8336f, 42.5489f, 0.707107f);
7272path.conicTo(43.5178f, 43.2782f, 42.7884f, 43.9624f, 0.707107f);
7273path.close();
7274path.moveTo(40.3892f, 45.9564f);
7275path.quadTo(39.9683f, 46.2655f, 39.5354f, 46.5574f);
7276path.conicTo(38.7062f, 47.1165f, 38.1472f, 46.2873f, 0.707107f);
7277path.conicTo(37.5881f, 45.4582f, 38.4173f, 44.8992f, 0.707107f);
7278path.quadTo(38.8169f, 44.6297f, 39.2054f, 44.3444f);
7279path.conicTo(40.0114f, 43.7525f, 40.6033f, 44.5585f, 0.707107f);
7280path.conicTo(41.1952f, 45.3645f, 40.3892f, 45.9564f, 0.707107f);
7281path.close();
7282path.moveTo(37.7543f, 47.6568f);
7283path.quadTo(37.2977f, 47.9138f, 36.8312f, 48.1522f);
7284path.conicTo(35.9407f, 48.6072f, 35.4857f, 47.7167f, 0.707107f);
7285path.conicTo(35.0306f, 46.8263f, 35.9211f, 46.3712f, 0.707107f);
7286path.quadTo(36.3518f, 46.1511f, 36.7732f, 45.9139f);
7287path.conicTo(37.6446f, 45.4234f, 38.1351f, 46.2948f, 0.707107f);
7288path.conicTo(38.6257f, 47.1662f, 37.7543f, 47.6568f, 0.707107f);
7289path.close();
7290path.moveTo(34.9311f, 49.0286f);
7291path.quadTo(34.4488f, 49.2279f, 33.9589f, 49.4077f);
7292path.conicTo(33.0202f, 49.7523f, 32.6756f, 48.8136f, 0.707107f);
7293path.conicTo(32.331f, 47.8748f, 33.2698f, 47.5302f, 0.707107f);
7294path.quadTo(33.722f, 47.3642f, 34.1672f, 47.1802f);
7295path.conicTo(35.0914f, 46.7983f, 35.4733f, 47.7224f, 0.707107f);
7296path.conicTo(35.8553f, 48.6466f, 34.9311f, 49.0286f, 0.707107f);
7297path.close();
7298path.moveTo(31.9824f, 50.0449f);
7299path.quadTo(31.4774f, 50.1857f, 30.9668f, 50.3061f);
7300path.conicTo(29.9935f, 50.5355f, 29.764f, 49.5622f, 0.707107f);
7301path.conicTo(29.5346f, 48.5889f, 30.5079f, 48.3594f, 0.707107f);
7302path.quadTo(30.9789f, 48.2484f, 31.4453f, 48.1184f);
7303path.conicTo(32.4086f, 47.8498f, 32.6771f, 48.8131f, 0.707107f);
7304path.conicTo(32.9457f, 49.7763f, 31.9824f, 50.0449f, 0.707107f);
7305path.close();
7306path.moveTo(28.899f, 50.706f);
7307path.quadTo(28.3834f, 50.7842f, 27.8652f, 50.8416f);
7308path.conicTo(26.8713f, 50.9518f, 26.7611f, 49.9579f, 0.707107f);
7309path.conicTo(26.6509f, 48.964f, 27.6448f, 48.8538f, 0.707107f);
7310path.quadTo(28.1231f, 48.8008f, 28.599f, 48.7286f);
7311path.conicTo(29.5877f, 48.5786f, 29.7377f, 49.5673f, 0.707107f);
7312path.conicTo(29.8877f, 50.556f, 28.899f, 50.706f, 0.707107f);
7313path.close();
7314path.moveTo(25.8106f, 50.9874f);
7315path.quadTo(25.6321f, 50.9929f, 25.4537f, 50.996f);
7316path.conicTo(24.4539f, 51.0135f, 24.4365f, 50.0136f, 0.707115f);
7317path.lineTo(24.4251f, 49.3638f);
7318path.conicTo(24.4077f, 48.364f, 25.4075f, 48.3465f, 0.707107f);
7319path.conicTo(26.4073f, 48.3291f, 26.4248f, 49.3289f, 0.707107f);
7320path.lineTo(26.4361f, 49.9787f);
7321path.lineTo(25.4363f, 49.9962f);
7322path.lineTo(25.4189f, 48.9963f);
7323path.quadTo(25.5836f, 48.9935f, 25.7482f, 48.9883f);
7324path.conicTo(26.7477f, 48.9571f, 26.7789f, 49.9567f, 0.707107f);
7325path.conicTo(26.8101f, 50.9562f, 25.8106f, 50.9874f, 0.707107f);
7326path.close();
7327path.moveTo(24.3902f, 47.3641f);
7328path.lineTo(24.3728f, 46.3643f);
7329path.conicTo(24.3553f, 45.3645f, 25.3551f, 45.347f, 0.707107f);
7330path.conicTo(26.355f, 45.3295f, 26.3724f, 46.3294f, 0.707107f);
7331path.lineTo(26.3899f, 47.3292f);
7332path.conicTo(26.4074f, 48.3291f, 25.4075f, 48.3465f, 0.707107f);
7333path.conicTo(24.4077f, 48.364f, 24.3902f, 47.3641f, 0.707107f);
7334path.close();
7335path.moveTo(24.3378f, 44.3646f);
7336path.lineTo(24.3204f, 43.3648f);
7337path.conicTo(24.3029f, 42.3649f, 25.3028f, 42.3475f, 0.707107f);
7338path.conicTo(26.3026f, 42.33f, 26.3201f, 43.3298f, 0.707107f);
7339path.lineTo(26.3375f, 44.3297f);
7340path.conicTo(26.355f, 45.3295f, 25.3551f, 45.347f, 0.707107f);
7341path.conicTo(24.3553f, 45.3645f, 24.3378f, 44.3646f, 0.707107f);
7342path.close();
7343path.moveTo(24.2855f, 41.3651f);
7344path.lineTo(24.268f, 40.3652f);
7345path.conicTo(24.2506f, 39.3654f, 25.2504f, 39.3479f, 0.707107f);
7346path.conicTo(26.2503f, 39.3305f, 26.2677f, 40.3303f, 0.707107f);
7347path.lineTo(26.2852f, 41.3302f);
7348path.conicTo(26.3026f, 42.33f, 25.3028f, 42.3475f, 0.707107f);
7349path.conicTo(24.3029f, 42.3649f, 24.2855f, 41.3651f, 0.707107f);
7350path.close();
7351path.moveTo(24.2331f, 38.3655f);
7352path.lineTo(24.2157f, 37.3657f);
7353path.conicTo(24.1982f, 36.3658f, 25.1981f, 36.3484f, 0.707107f);
7354path.conicTo(26.1979f, 36.3309f, 26.2154f, 37.3308f, 0.707107f);
7355path.lineTo(26.2328f, 38.3306f);
7356path.conicTo(26.2503f, 39.3305f, 25.2504f, 39.3479f, 0.707107f);
7357path.conicTo(24.2506f, 39.3654f, 24.2331f, 38.3655f, 0.707107f);
7358path.close();
7359path.moveTo(24.1808f, 35.366f);
7360path.lineTo(24.1633f, 34.3661f);
7361path.conicTo(24.1459f, 33.3663f, 25.1457f, 33.3488f, 0.707107f);
7362path.conicTo(26.1456f, 33.3314f, 26.163f, 34.3312f, 0.707107f);
7363path.lineTo(26.1805f, 35.3311f);
7364path.conicTo(26.1979f, 36.3309f, 25.1981f, 36.3484f, 0.707107f);
7365path.conicTo(24.1982f, 36.3658f, 24.1808f, 35.366f, 0.707107f);
7366path.close();
7367path.moveTo(24.1284f, 32.3664f);
7368path.lineTo(24.111f, 31.3666f);
7369path.conicTo(24.0935f, 30.3667f, 25.0934f, 30.3493f, 0.707107f);
7370path.conicTo(26.0932f, 30.3318f, 26.1107f, 31.3317f, 0.707107f);
7371path.lineTo(26.1281f, 32.3315f);
7372path.conicTo(26.1456f, 33.3314f, 25.1457f, 33.3488f, 0.707107f);
7373path.conicTo(24.1459f, 33.3663f, 24.1284f, 32.3664f, 0.707107f);
7374path.close();
7375path.moveTo(24.0761f, 29.3669f);
7376path.lineTo(24.0586f, 28.367f);
7377path.conicTo(24.0412f, 27.3672f, 25.041f, 27.3497f, 0.707107f);
7378path.conicTo(26.0409f, 27.3323f, 26.0583f, 28.3321f, 0.707107f);
7379path.lineTo(26.0758f, 29.332f);
7380path.conicTo(26.0932f, 30.3318f, 25.0934f, 30.3493f, 0.707107f);
7381path.conicTo(24.0935f, 30.3667f, 24.0761f, 29.3669f, 0.707107f);
7382path.close();
7383path.moveTo(24.0237f, 26.3673f);
7384path.lineTo(24.0063f, 25.3675f);
7385path.conicTo(23.9888f, 24.3676f, 24.9887f, 24.3502f, 0.707107f);
7386path.conicTo(25.9885f, 24.3327f, 26.006f, 25.3326f, 0.707107f);
7387path.lineTo(26.0234f, 26.3324f);
7388path.conicTo(26.0409f, 27.3323f, 25.041f, 27.3497f, 0.707107f);
7389path.conicTo(24.0412f, 27.3672f, 24.0237f, 26.3673f, 0.707107f);
7390path.close();
7391path1 = path;
7392path.reset();
7393path.setFillType(SkPathFillType::kWinding);
7394path.moveTo(25.0098f, 23.1973f);
7395path.lineTo(25.5689f, 22.3682f);
7396path.conicTo(26.1281f, 21.5392f, 26.9572f, 22.0984f, 0.707107f);
7397path.conicTo(27.7862f, 22.6576f, 27.227f, 23.4866f, 0.707107f);
7398path.lineTo(26.6678f, 24.3156f);
7399path.conicTo(26.1086f, 25.1447f, 25.2796f, 24.5855f, 0.707107f);
7400path.conicTo(24.4506f, 24.0263f, 25.0098f, 23.1973f, 0.707107f);
7401path.close();
7402path.moveTo(26.6873f, 20.7101f);
7403path.lineTo(27.2465f, 19.8811f);
7404path.conicTo(27.8057f, 19.0521f, 28.6348f, 19.6113f, 0.707107f);
7405path.conicTo(29.4638f, 20.1704f, 28.9046f, 20.9995f, 0.707107f);
7406path.lineTo(28.3454f, 21.8285f);
7407path.conicTo(27.7862f, 22.6576f, 26.9572f, 22.0984f, 0.707107f);
7408path.conicTo(26.1281f, 21.5392f, 26.6873f, 20.7101f, 0.707107f);
7409path.close();
7410path.moveTo(28.3649f, 18.223f);
7411path.lineTo(28.9241f, 17.394f);
7412path.conicTo(29.4833f, 16.565f, 30.3123f, 17.1241f, 0.707107f);
7413path.conicTo(31.1414f, 17.6833f, 30.5822f, 18.5124f, 0.707107f);
7414path.lineTo(30.023f, 19.3414f);
7415path.conicTo(29.4638f, 20.1704f, 28.6348f, 19.6113f, 0.707107f);
7416path.conicTo(27.8057f, 19.0521f, 28.3649f, 18.223f, 0.707107f);
7417path.close();
7418path.moveTo(30.0425f, 15.7359f);
7419path.lineTo(30.6017f, 14.9069f);
7420path.conicTo(31.1609f, 14.0778f, 31.9899f, 14.637f, 0.707107f);
7421path.conicTo(32.8189f, 15.1962f, 32.2598f, 16.0253f, 0.707107f);
7422path.lineTo(31.7006f, 16.8543f);
7423path.conicTo(31.1414f, 17.6833f, 30.3123f, 17.1241f, 0.707107f);
7424path.conicTo(29.4833f, 16.565f, 30.0425f, 15.7359f, 0.707107f);
7425path.close();
7426path.moveTo(31.7201f, 13.2488f);
7427path.lineTo(32.2793f, 12.4198f);
7428path.conicTo(32.8385f, 11.5907f, 33.6675f, 12.1499f, 0.707107f);
7429path.conicTo(34.4965f, 12.7091f, 33.9373f, 13.5381f, 0.707107f);
7430path.lineTo(33.3781f, 14.3672f);
7431path.conicTo(32.8189f, 15.1962f, 31.9899f, 14.637f, 0.707107f);
7432path.conicTo(31.1609f, 14.0778f, 31.7201f, 13.2488f, 0.707107f);
7433path.close();
7434path.moveTo(33.3976f, 10.7617f);
7435path.lineTo(33.9568f, 9.93265f);
7436path.conicTo(34.516f, 9.10361f, 35.3451f, 9.6628f, 0.707107f);
7437path.conicTo(36.1741f, 10.222f, 35.6149f, 11.051f, 0.707107f);
7438path.lineTo(35.0557f, 11.8801f);
7439path.conicTo(34.4965f, 12.7091f, 33.6675f, 12.1499f, 0.707107f);
7440path.conicTo(32.8385f, 11.5907f, 33.3976f, 10.7617f, 0.707107f);
7441path.close();
7442path.moveTo(35.0752f, 8.27457f);
7443path.lineTo(35.6344f, 7.44554f);
7444path.conicTo(36.1936f, 6.6165f, 37.0226f, 7.17569f, 0.707107f);
7445path.conicTo(37.8517f, 7.73488f, 37.2925f, 8.56392f, 0.707107f);
7446path.lineTo(36.7333f, 9.39296f);
7447path.conicTo(36.1741f, 10.222f, 35.3451f, 9.6628f, 0.707107f);
7448path.conicTo(34.516f, 9.10361f, 35.0752f, 8.27457f, 0.707107f);
7449path.close();
7450path.moveTo(36.7528f, 5.78746f);
7451path.lineTo(37.312f, 4.95842f);
7452path.conicTo(37.8712f, 4.12939f, 38.7002f, 4.68858f, 0.707107f);
7453path.conicTo(39.5293f, 5.24777f, 38.9701f, 6.07681f, 0.707107f);
7454path.lineTo(38.4109f, 6.90585f);
7455path.conicTo(37.8517f, 7.73488f, 37.0226f, 7.17569f, 0.707107f);
7456path.conicTo(36.1936f, 6.6165f, 36.7528f, 5.78746f, 0.707107f);
7457path.close();
7458path.moveTo(39.9447f, 3.72429f);
7459path.quadTo(40.3524f, 4.01069f, 40.7489f, 4.31248f);
7460path.conicTo(41.5445f, 4.9182f, 40.9388f, 5.71387f, 0.707107f);
7461path.conicTo(40.3331f, 6.50955f, 39.5374f, 5.90383f, 0.707107f);
7462path.quadTo(39.1714f, 5.62521f, 38.7951f, 5.36088f);
7463path.conicTo(37.9768f, 4.78608f, 38.5516f, 3.96779f, 0.707107f);
7464path.conicTo(39.1264f, 3.14949f, 39.9447f, 3.72429f, 0.707107f);
7465path.close();
7466path.moveTo(42.3194f, 5.60826f);
7467path.quadTo(42.707f, 5.95446f, 43.0804f, 6.31583f);
7468path.conicTo(43.7991f, 7.01122f, 43.1037f, 7.72985f, 0.707107f);
7469path.conicTo(42.4083f, 8.44848f, 41.6896f, 7.75308f, 0.707107f);
7470path.quadTo(41.3448f, 7.41944f, 40.9871f, 7.09992f);
7471path.conicTo(40.2413f, 6.43379f, 40.9074f, 5.68796f, 0.707107f);
7472path.conicTo(41.5735f, 4.94212f, 42.3194f, 5.60826f, 0.707107f);
7473path.close();
7474path.moveTo(44.5406f, 7.84871f);
7475path.quadTo(44.8959f, 8.25352f, 45.2341f, 8.67266f);
7476path.conicTo(45.862f, 9.4509f, 45.0838f, 10.0789f, 0.707107f);
7477path.conicTo(44.3056f, 10.7068f, 43.6776f, 9.9286f, 0.707107f);
7478path.quadTo(43.3654f, 9.54174f, 43.0374f, 9.16805f);
7479path.conicTo(42.3778f, 8.41649f, 43.1293f, 7.75682f, 0.707107f);
7480path.conicTo(43.8809f, 7.09715f, 44.5406f, 7.84871f, 0.707107f);
7481path.close();
7482path.moveTo(46.528f, 10.4211f);
7483path.quadTo(46.815f, 10.8449f, 47.0851f, 11.2796f);
7484path.conicTo(47.6128f, 12.129f, 46.7633f, 12.6567f, 0.707107f);
7485path.conicTo(45.9139f, 13.1844f, 45.3862f, 12.335f, 0.707107f);
7486path.quadTo(45.1369f, 11.9337f, 44.872f, 11.5426f);
7487path.conicTo(44.3113f, 10.7146f, 45.1393f, 10.1538f, 0.707107f);
7488path.conicTo(45.9673f, 9.5931f, 46.528f, 10.4211f, 0.707107f);
7489path.close();
7490path.moveTo(48.1056f, 13.0782f);
7491path.quadTo(48.3449f, 13.542f, 48.5654f, 14.015f);
7492path.conicTo(48.9879f, 14.9213f, 48.0816f, 15.3438f, 0.707107f);
7493path.conicTo(47.1752f, 15.7663f, 46.7527f, 14.86f, 0.707107f);
7494path.quadTo(46.5492f, 14.4234f, 46.3283f, 13.9953f);
7495path.conicTo(45.8698f, 13.1066f, 46.7584f, 12.6481f, 0.707107f);
7496path.conicTo(47.6471f, 12.1895f, 48.1056f, 13.0782f, 0.707107f);
7497path.close();
7498path.moveTo(49.3755f, 15.9538f);
7499path.quadTo(49.5594f, 16.4493f, 49.7229f, 16.9516f);
7500path.conicTo(50.0325f, 17.9025f, 49.0816f, 18.2121f, 0.707107f);
7501path.conicTo(48.1307f, 18.5216f, 47.8212f, 17.5707f, 0.707107f);
7502path.quadTo(47.6702f, 17.1069f, 47.5005f, 16.6497f);
7503path.conicTo(47.1526f, 15.7122f, 48.0901f, 15.3642f, 0.707107f);
7504path.conicTo(49.0276f, 15.0163f, 49.3755f, 15.9538f, 0.707107f);
7505path.close();
7506path.moveTo(50.2964f, 18.9923f);
7507path.quadTo(50.4191f, 19.5089f, 50.5206f, 20.0302f);
7508path.conicTo(50.7117f, 21.0117f, 49.7302f, 21.2029f, 0.707107f);
7509path.conicTo(48.7486f, 21.394f, 48.5575f, 20.4125f, 0.707107f);
7510path.quadTo(48.4638f, 19.9313f, 48.3505f, 19.4544f);
7511path.conicTo(48.1194f, 18.4815f, 49.0924f, 18.2504f, 0.707107f);
7512path.conicTo(50.0653f, 18.0193f, 50.2964f, 18.9923f, 0.707107f);
7513path.close();
7514path.moveTo(50.8373f, 22.0956f);
7515path.quadTo(50.8955f, 22.6138f, 50.933f, 23.1341f);
7516path.conicTo(51.0047f, 24.1315f, 50.0073f, 24.2033f, 0.707107f);
7517path.conicTo(49.0099f, 24.275f, 48.9381f, 23.2776f, 0.707107f);
7518path.quadTo(48.9036f, 22.7975f, 48.8498f, 22.3191f);
7519path.conicTo(48.7381f, 21.3253f, 49.7318f, 21.2136f, 0.707107f);
7520path.conicTo(50.7255f, 21.1019f, 50.8373f, 22.0956f, 0.707107f);
7521path.close();
7522path.moveTo(50.9992f, 25.2099f);
7523path.quadTo(50.9949f, 25.7358f, 50.9694f, 26.2608f);
7524path.conicTo(50.9209f, 27.2596f, 49.9221f, 27.2111f, 0.707107f);
7525path.conicTo(48.9233f, 27.1626f, 48.9718f, 26.1638f, 0.707107f);
7526path.quadTo(48.9953f, 25.679f, 48.9992f, 25.1938f);
7527path.conicTo(49.0073f, 24.1938f, 50.0073f, 24.2019f, 0.707107f);
7528path.conicTo(51.0072f, 24.21f, 50.9992f, 25.2099f, 0.707107f);
7529path.close();
7530path.moveTo(50.7839f, 28.3454f);
7531path.quadTo(50.7172f, 28.8596f, 50.63f, 29.3708f);
7532path.conicTo(50.4619f, 30.3565f, 49.4761f, 30.1884f, 0.707107f);
7533path.conicTo(48.4903f, 30.0203f, 48.6584f, 29.0346f, 0.707107f);
7534path.quadTo(48.7389f, 28.5627f, 48.8005f, 28.088f);
7535path.conicTo(48.9292f, 27.0963f, 49.9209f, 27.225f, 0.707107f);
7536path.conicTo(50.9126f, 27.3537f, 50.7839f, 28.3454f, 0.707107f);
7537path.close();
7538path.moveTo(50.1906f, 31.437f);
7539path.quadTo(50.0558f, 31.9646f, 49.899f, 32.4861f);
7540path.conicTo(49.611f, 33.4438f, 48.6534f, 33.1558f, 0.707107f);
7541path.conicTo(47.6957f, 32.8679f, 47.9837f, 31.9103f, 0.707107f);
7542path.quadTo(48.1284f, 31.4289f, 48.2528f, 30.9418f);
7543path.conicTo(48.5004f, 29.9729f, 49.4693f, 30.2205f, 0.707107f);
7544path.conicTo(50.4382f, 30.4681f, 50.1906f, 31.437f, 0.707107f);
7545path.close();
7546path.moveTo(49.1978f, 34.5114f);
7547path.quadTo(49.0051f, 35.0016f, 48.7927f, 35.4837f);
7548path.conicTo(48.3895f, 36.3988f, 47.4744f, 35.9956f, 0.707107f);
7549path.conicTo(46.5593f, 35.5923f, 46.9625f, 34.6772f, 0.707107f);
7550path.quadTo(47.1586f, 34.2323f, 47.3364f, 33.7797f);
7551path.conicTo(47.7023f, 32.849f, 48.6329f, 33.2149f, 0.707107f);
7552path.conicTo(49.5636f, 33.5807f, 49.1978f, 34.5114f, 0.707107f);
7553path.close();
7554path.moveTo(47.8852f, 37.3397f);
7555path.quadTo(47.6449f, 37.7853f, 47.3876f, 38.2211f);
7556path.conicTo(46.879f, 39.0821f, 46.018f, 38.5736f, 0.707107f);
7557path.conicTo(45.1569f, 38.0651f, 45.6655f, 37.204f, 0.707107f);
7558path.quadTo(45.903f, 36.8018f, 46.1248f, 36.3906f);
7559path.conicTo(46.5993f, 35.5103f, 47.4796f, 35.9849f, 0.707107f);
7560path.conicTo(48.3598f, 36.4595f, 47.8852f, 37.3397f, 0.707107f);
7561path.close();
7562path.moveTo(46.3154f, 39.8881f);
7563path.quadTo(46.0303f, 40.2962f, 45.7299f, 40.693f);
7564path.conicTo(45.1264f, 41.4903f, 44.3291f, 40.8867f, 0.707107f);
7565path.conicTo(43.5318f, 40.2831f, 44.1353f, 39.4858f, 0.707107f);
7566path.quadTo(44.4126f, 39.1195f, 44.6757f, 38.7428f);
7567path.conicTo(45.2483f, 37.923f, 46.0682f, 38.4956f, 0.707107f);
7568path.conicTo(46.888f, 39.0682f, 46.3154f, 39.8881f, 0.707107f);
7569path.close();
7570path.moveTo(44.4398f, 42.2654f);
7571path.quadTo(44.095f, 42.6536f, 43.7349f, 43.0278f);
7572path.conicTo(43.0415f, 43.7484f, 42.321f, 43.055f, 0.707107f);
7573path.conicTo(41.6004f, 42.3616f, 42.2938f, 41.641f, 0.707107f);
7574path.quadTo(42.6261f, 41.2957f, 42.9444f, 40.9374f);
7575path.conicTo(43.6084f, 40.1897f, 44.3561f, 40.8537f, 0.707107f);
7576path.conicTo(45.1038f, 41.5177f, 44.4398f, 42.2654f, 0.707107f);
7577path.close();
7578path.moveTo(42.2075f, 44.4911f);
7579path.quadTo(41.804f, 44.8473f, 41.3862f, 45.1865f);
7580path.conicTo(40.6098f, 45.8167f, 39.9795f, 45.0403f, 0.707107f);
7581path.conicTo(39.3493f, 44.2639f, 40.1257f, 43.6336f, 0.707107f);
7582path.quadTo(40.5114f, 43.3205f, 40.8838f, 42.9918f);
7583path.conicTo(41.6335f, 42.3299f, 42.2953f, 43.0796f, 0.707107f);
7584path.conicTo(42.9572f, 43.8292f, 42.2075f, 44.4911f, 0.707107f);
7585path.close();
7586path.moveTo(39.6379f, 46.488f);
7587path.quadTo(39.2151f, 46.776f, 38.7814f, 47.0471f);
7588path.conicTo(37.9334f, 47.5771f, 37.4034f, 46.7292f, 0.707107f);
7589path.conicTo(36.8733f, 45.8812f, 37.7213f, 45.3511f, 0.707107f);
7590path.quadTo(38.1217f, 45.1009f, 38.5119f, 44.835f);
7591path.conicTo(39.3383f, 44.2721f, 39.9013f, 45.0985f, 0.707107f);
7592path.conicTo(40.4643f, 45.925f, 39.6379f, 46.488f, 0.707107f);
7593path.close();
7594path.moveTo(36.9864f, 48.0722f);
7595path.quadTo(36.5234f, 48.3127f, 36.0513f, 48.5344f);
7596path.conicTo(35.1461f, 48.9595f, 34.7211f, 48.0543f, 0.707107f);
7597path.conicTo(34.296f, 47.1491f, 35.2012f, 46.7241f, 0.707107f);
7598path.quadTo(35.6371f, 46.5194f, 36.0644f, 46.2974f);
7599path.conicTo(36.9518f, 45.8364f, 37.4128f, 46.7238f, 0.707107f);
7600path.conicTo(37.8738f, 47.6112f, 36.9864f, 48.0722f, 0.707107f);
7601path.close();
7602path.moveTo(34.1153f, 49.3498f);
7603path.quadTo(33.6206f, 49.535f, 33.1187f, 49.6999f);
7604path.conicTo(32.1687f, 50.0122f, 31.8565f, 49.0622f, 0.707107f);
7605path.conicTo(31.5442f, 48.1122f, 32.4942f, 47.7999f, 0.707107f);
7606path.quadTo(32.9575f, 47.6477f, 33.4141f, 47.4767f);
7607path.conicTo(34.3507f, 47.1261f, 34.7012f, 48.0627f, 0.707107f);
7608path.conicTo(35.0518f, 48.9992f, 34.1153f, 49.3498f, 0.707107f);
7609path.close();
7610path.moveTo(31.08f, 50.2791f);
7611path.quadTo(30.5637f, 50.4033f, 30.0427f, 50.5063f);
7612path.conicTo(29.0617f, 50.7002f, 28.8678f, 49.7192f, 0.707107f);
7613path.conicTo(28.6738f, 48.7382f, 29.6548f, 48.5443f, 0.707107f);
7614path.quadTo(30.1357f, 48.4492f, 30.6122f, 48.3346f);
7615path.conicTo(31.5845f, 48.1007f, 31.8184f, 49.073f, 0.707107f);
7616path.conicTo(32.0522f, 50.0453f, 31.08f, 50.2791f, 0.707107f);
7617path.close();
7618path.moveTo(27.9769f, 50.829f);
7619path.quadTo(27.4588f, 50.8887f, 26.9386f, 50.9276f);
7620path.conicTo(25.9414f, 51.0022f, 25.8668f, 50.005f, 0.707107f);
7621path.conicTo(25.7923f, 49.0078f, 26.7895f, 48.9332f, 0.707107f);
7622path.quadTo(27.2696f, 48.8973f, 27.7479f, 48.8422f);
7623path.conicTo(28.7413f, 48.7277f, 28.8558f, 49.7211f, 0.707107f);
7624path.conicTo(28.9703f, 50.7145f, 27.9769f, 50.829f, 0.707107f);
7625path.close();
7626path.moveTo(24.8625f, 50.9996f);
7627path.quadTo(24.3373f, 50.9969f, 23.8128f, 50.9729f);
7628path.conicTo(22.8138f, 50.9272f, 22.8595f, 49.9283f, 0.707107f);
7629path.conicTo(22.9051f, 48.9293f, 23.9041f, 48.975f, 0.707107f);
7630path.quadTo(24.3884f, 48.9971f, 24.8731f, 48.9997f);
7631path.conicTo(25.8731f, 49.005f, 25.8678f, 50.005f, 0.707107f);
7632path.conicTo(25.8624f, 51.0049f, 24.8625f, 50.9996f, 0.707107f);
7633path.close();
7634path.moveTo(21.7268f, 50.7931f);
7635path.quadTo(21.2121f, 50.7278f, 20.7005f, 50.642f);
7636path.conicTo(19.7143f, 50.4767f, 19.8796f, 49.4905f, 0.707107f);
7637path.conicTo(20.045f, 48.5042f, 21.0312f, 48.6696f, 0.707107f);
7638path.quadTo(21.5036f, 48.7488f, 21.9786f, 48.8091f);
7639path.conicTo(22.9707f, 48.9349f, 22.8448f, 49.927f, 0.707107f);
7640path.conicTo(22.7189f, 50.919f, 21.7268f, 50.7931f, 0.707107f);
7641path.close();
7642path.moveTo(18.6372f, 50.2094f);
7643path.quadTo(18.1089f, 50.0761f, 17.5865f, 49.9207f);
7644path.conicTo(16.628f, 49.6356f, 16.9132f, 48.6771f, 0.707107f);
7645path.conicTo(17.1983f, 47.7186f, 18.1568f, 48.0037f, 0.707107f);
7646path.quadTo(18.639f, 48.1472f, 19.1267f, 48.2702f);
7647path.conicTo(20.0963f, 48.515f, 19.8516f, 49.4846f, 0.707107f);
7648path.conicTo(19.6068f, 50.4542f, 18.6372f, 50.2094f, 0.707107f);
7649path.close();
7650path.moveTo(15.5577f, 49.2248f);
7651path.quadTo(15.0665f, 49.0334f, 14.5834f, 48.8222f);
7652path.conicTo(13.6672f, 48.4215f, 14.0678f, 47.5053f, 0.707107f);
7653path.conicTo(14.4684f, 46.589f, 15.3847f, 46.9897f, 0.707107f);
7654path.quadTo(15.8306f, 47.1846f, 16.284f, 47.3614f);
7655path.conicTo(17.2158f, 47.7246f, 16.8526f, 48.6563f, 0.707107f);
7656path.conicTo(16.4894f, 49.588f, 15.5577f, 49.2248f, 0.707107f);
7657path.close();
7658path.moveTo(12.7231f, 47.9189f);
7659path.quadTo(12.2765f, 47.6797f, 11.8395f, 47.4233f);
7660path.conicTo(10.9771f, 46.9171f, 11.4833f, 46.0547f, 0.707107f);
7661path.conicTo(11.9894f, 45.1922f, 12.8519f, 45.6984f, 0.707107f);
7662path.quadTo(13.2552f, 45.9351f, 13.6675f, 46.156f);
7663path.conicTo(14.549f, 46.6282f, 14.0768f, 47.5096f, 0.707107f);
7664path.conicTo(13.6046f, 48.3911f, 12.7231f, 47.9189f, 0.707107f);
7665path.close();
7666path.moveTo(10.1686f, 46.3548f);
7667path.quadTo(9.76024f, 46.0712f, 9.363f, 45.7722f);
7668path.conicTo(8.56406f, 45.1708f, 9.16549f, 44.3718f, 0.707107f);
7669path.conicTo(9.76691f, 43.5729f, 10.5658f, 44.1743f, 0.707107f);
7670path.quadTo(10.9325f, 44.4504f, 11.3095f, 44.7122f);
7671path.conicTo(12.1308f, 45.2826f, 11.5604f, 46.1039f, 0.707107f);
7672path.conicTo(10.9899f, 46.9253f, 10.1686f, 46.3548f, 0.707107f);
7673path.close();
7674path.moveTo(7.78853f, 44.4876f);
7675path.quadTo(7.39972f, 44.1442f, 7.02492f, 43.7855f);
7676path.conicTo(6.3024f, 43.0942f, 6.99374f, 42.3717f, 0.707107f);
7677path.conicTo(7.68509f, 41.6492f, 8.40761f, 42.3405f, 0.707107f);
7678path.quadTo(8.7536f, 42.6715f, 9.11249f, 42.9885f);
7679path.conicTo(9.86201f, 43.6505f, 9.20003f, 44.4f, 0.707107f);
7680path.conicTo(8.53805f, 45.1496f, 7.78853f, 44.4876f, 0.707107f);
7681path.close();
7682path.moveTo(5.55855f, 42.2635f);
7683path.quadTo(5.20148f, 41.8614f, 4.86131f, 41.4449f);
7684path.conicTo(4.22883f, 40.6703f, 5.0034f, 40.0378f, 0.707107f);
7685path.conicTo(5.77797f, 39.4053f, 6.41046f, 40.1799f, 0.707107f);
7686path.quadTo(6.72443f, 40.5644f, 7.05403f, 40.9356f);
7687path.conicTo(7.71802f, 41.6833f, 6.97028f, 42.3473f, 0.707107f);
7688path.conicTo(6.22254f, 43.0113f, 5.55855f, 42.2635f, 0.707107f);
7689path.close();
7690path.moveTo(3.55261f, 39.6973f);
7691path.quadTo(3.26341f, 39.2752f, 2.99107f, 38.8422f);
7692path.conicTo(2.45867f, 37.9957f, 3.30517f, 37.4633f, 0.707107f);
7693path.conicTo(4.15167f, 36.9309f, 4.68406f, 37.7774f, 0.707107f);
7694path.quadTo(4.93548f, 38.1772f, 5.20241f, 38.5667f);
7695path.conicTo(5.76769f, 39.3916f, 4.94279f, 39.9569f, 0.707107f);
7696path.conicTo(4.11789f, 40.5222f, 3.55261f, 39.6973f, 0.707107f);
7697path.close();
7698path.moveTo(1.96145f, 37.0509f);
7699path.quadTo(1.71975f, 36.5889f, 1.49677f, 36.1175f);
7700path.conicTo(1.06917f, 35.2135f, 1.97315f, 34.7859f, 0.707107f);
7701path.conicTo(2.87712f, 34.3583f, 3.30471f, 35.2623f, 0.707107f);
7702path.quadTo(3.51053f, 35.6974f, 3.73364f, 36.1239f);
7703path.conicTo(4.19714f, 37.01f, 3.31105f, 37.4735f, 0.707107f);
7704path.conicTo(2.42495f, 37.937f, 1.96145f, 37.0509f, 0.707107f);
7705path.close();
7706path.moveTo(0.676191f, 34.1844f);
7707path.quadTo(0.489621f, 33.6902f, 0.323275f, 33.189f);
7708path.conicTo(0.00831527f, 32.2399f, 0.95742f, 31.9249f, 0.707107f);
7709path.conicTo(1.90653f, 31.6099f, 2.22149f, 32.559f, 0.707107f);
7710path.quadTo(2.37504f, 33.0218f, 2.54726f, 33.4779f);
7711path.conicTo(2.9005f, 34.4134f, 1.96497f, 34.7666f, 0.707107f);
7712path.conicTo(1.02943f, 35.1199f, 0.676191f, 34.1844f, 0.707107f);
7713path.close();
7714path.moveTo(-0.261658f, 31.1521f);
7715path.quadTo(-0.387304f, 30.6362f, -0.491779f, 30.1156f);
7716path.conicTo(-0.68853f, 29.1351f, 0.291923f, 28.9384f, 0.707107f);
7717path.conicTo(1.27238f, 28.7416f, 1.46913f, 29.7221f, 0.707107f);
7718path.quadTo(1.56557f, 30.2026f, 1.68155f, 30.6789f);
7719path.conicTo(1.91817f, 31.6505f, 0.946565f, 31.8871f, 0.707107f);
7720path.conicTo(-0.0250367f, 32.1237f, -0.261658f, 31.1521f, 0.707107f);
7721path.close();
7722path.moveTo(-0.820549f, 28.0495f);
7723path.quadTo(-0.881733f, 27.5314f, -0.922089f, 27.0113f);
7724path.conicTo(-0.999449f, 26.0143f, -0.00244591f, 25.9369f, 0.707107f);
7725path.conicTo(0.994557f, 25.8596f, 1.07192f, 26.8566f, 0.707107f);
7726path.quadTo(1.10917f, 27.3367f, 1.16565f, 27.8149f);
7727path.conicTo(1.28293f, 28.808f, 0.289834f, 28.9253f, 0.707107f);
7728path.conicTo(-0.703265f, 29.0426f, -0.820549f, 28.0495f, 0.707107f);
7729path.close();
7730path.moveTo(-0.999918f, 24.9349f);
7731path.quadTo(-0.998605f, 24.4104f, -0.976138f, 23.8863f);
7732path.conicTo(-0.933305f, 22.8873f, 0.0657772f, 22.9301f, 0.707107f);
7733path.conicTo(1.06486f, 22.9729f, 1.02203f, 23.972f, 0.707107f);
7734path.quadTo(1.00129f, 24.4557f, 1.00008f, 24.9399f);
7735path.conicTo(0.997572f, 25.9399f, -0.0024244f, 25.9374f, 0.707107f);
7736path.conicTo(-1.00242f, 25.9349f, -0.999918f, 24.9349f, 0.707107f);
7737path.close();
7738path.moveTo(-0.802212f, 21.7991f);
7739path.quadTo(-0.738311f, 21.284f, -0.653903f, 20.7719f);
7740path.conicTo(-0.491283f, 19.7852f, 0.495406f, 19.9478f, 0.707107f);
7741path.conicTo(1.48209f, 20.1104f, 1.31948f, 21.0971f, 0.707107f);
7742path.quadTo(1.24156f, 21.5698f, 1.18257f, 22.0453f);
7743path.conicTo(1.05946f, 23.0377f, 0.0670681f, 22.9146f, 0.707107f);
7744path.conicTo(-0.925325f, 22.7915f, -0.802212f, 21.7991f, 0.707107f);
7745path.close();
7746path.moveTo(-0.228066f, 18.7115f);
7747path.quadTo(-0.096172f, 18.1824f, 0.0577899f, 17.6593f);
7748path.conicTo(0.340124f, 16.7f, 1.29944f, 16.9823f, 0.707107f);
7749path.conicTo(2.25876f, 17.2646f, 1.97642f, 18.2239f, 0.707107f);
7750path.quadTo(1.8343f, 18.7068f, 1.71255f, 19.1953f);
7751path.conicTo(1.47069f, 20.1656f, 0.50038f, 19.9237f, 0.707107f);
7752path.conicTo(-0.46993f, 19.6819f, -0.228066f, 18.7115f, 0.707107f);
7753path.close();
7754path.moveTo(0.74831f, 15.6269f);
7755path.quadTo(0.938539f, 15.1347f, 1.14857f, 14.6506f);
7756path.conicTo(1.54662f, 13.7333f, 2.46398f, 14.1313f, 0.707107f);
7757path.conicTo(3.38135f, 14.5294f, 2.9833f, 15.4467f, 0.707107f);
7758path.quadTo(2.78942f, 15.8936f, 2.61382f, 16.3479f);
7759path.conicTo(2.25331f, 17.2806f, 1.32056f, 16.9201f, 0.707107f);
7760path.conicTo(0.387801f, 16.5596f, 0.74831f, 15.6269f, 0.707107f);
7761path.close();
7762path.moveTo(2.04744f, 12.7861f);
7763path.quadTo(2.28569f, 12.3384f, 2.5412f, 11.9003f);
7764path.conicTo(3.04504f, 11.0365f, 3.90884f, 11.5403f, 0.707107f);
7765path.conicTo(4.77264f, 12.0442f, 4.26881f, 12.908f, 0.707107f);
7766path.quadTo(4.03293f, 13.3123f, 3.81302f, 13.7256f);
7767path.conicTo(3.34325f, 14.6084f, 2.46046f, 14.1386f, 0.707107f);
7768path.conicTo(1.57767f, 13.6689f, 2.04744f, 12.7861f, 0.707107f);
7769path.close();
7770path.moveTo(3.60589f, 10.2253f);
7771path.quadTo(3.88812f, 9.81661f, 4.18576f, 9.419f);
7772path.conicTo(4.78503f, 8.61845f, 5.58558f, 9.21772f, 0.707107f);
7773path.conicTo(6.38613f, 9.81699f, 5.78686f, 10.6175f, 0.707107f);
7774path.quadTo(5.51211f, 10.9846f, 5.25159f, 11.3618f);
7775path.conicTo(4.68333f, 12.1847f, 3.86048f, 11.6164f, 0.707107f);
7776path.conicTo(3.03763f, 11.0481f, 3.60589f, 10.2253f, 0.707107f);
7777path.close();
7778path.moveTo(5.46482f, 7.84259f);
7779path.quadTo(5.80682f, 7.4532f, 6.16407f, 7.07773f);
7780path.conicTo(6.85339f, 6.35327f, 7.57785f, 7.04259f, 0.707107f);
7781path.conicTo(8.30231f, 7.73191f, 7.61299f, 8.45636f, 0.707107f);
7782path.quadTo(7.28322f, 8.80295f, 6.96752f, 9.16239f);
7783path.conicTo(6.30762f, 9.91375f, 5.55627f, 9.25385f, 0.707107f);
7784path.conicTo(4.80492f, 8.59395f, 5.46482f, 7.84259f, 0.707107f);
7785path.close();
7786path.moveTo(7.68062f, 5.60827f);
7787path.quadTo(8.08142f, 5.25031f, 8.49666f, 4.90921f);
7788path.conicTo(9.26938f, 4.27447f, 9.90412f, 5.04719f, 0.707107f);
7789path.conicTo(10.5389f, 5.81992f, 9.76614f, 6.45466f, 0.707107f);
7790path.quadTo(9.38285f, 6.76951f, 9.01289f, 7.09994f);
7791path.conicTo(8.26705f, 7.76607f, 7.60092f, 7.02024f, 0.707107f);
7792path.conicTo(6.93479f, 6.2744f, 7.68062f, 5.60827f, 0.707107f);
7793path.close();
7794path.moveTo(10.2392f, 3.59627f);
7795path.quadTo(10.6626f, 3.30433f, 11.0971f, 3.02935f);
7796path.conicTo(11.9421f, 2.49463f, 12.4768f, 3.33965f, 0.707107f);
7797path.conicTo(13.0116f, 4.18467f, 12.1666f, 4.7194f, 0.707107f);
7798path.quadTo(11.7654f, 4.97322f, 11.3747f, 5.24271f);
7799path.conicTo(10.5515f, 5.81043f, 9.98373f, 4.98721f, 0.707107f);
7800path.conicTo(9.41601f, 4.16399f, 10.2392f, 3.59627f, 0.707107f);
7801path.close();
7802path.moveTo(12.8847f, 1.99524f);
7803path.quadTo(13.3459f, 1.75234f, 13.8165f, 1.52812f);
7804path.conicTo(14.7193f, 1.09799f, 15.1494f, 2.00075f, 0.707107f);
7805path.conicTo(15.5795f, 2.90352f, 14.6768f, 3.33365f, 0.707107f);
7806path.quadTo(14.2424f, 3.54063f, 13.8166f, 3.76484f);
7807path.conicTo(12.9318f, 4.23081f, 12.4658f, 3.34601f, 0.707107f);
7808path.conicTo(11.9999f, 2.46122f, 12.8847f, 1.99524f, 0.707107f);
7809path.close();
7810path.moveTo(15.7467f, 0.702339f);
7811path.quadTo(16.2402f, 0.514409f, 16.7409f, 0.346672f);
7812path.conicTo(17.6891f, 0.029011f, 18.0067f, 0.977215f, 0.707107f);
7813path.conicTo(18.3244f, 1.92542f, 17.3762f, 2.24308f, 0.707107f);
7814path.quadTo(16.914f, 2.39792f, 16.4585f, 2.57139f);
7815path.conicTo(15.524f, 2.92729f, 15.1681f, 1.99276f, 0.707107f);
7816path.conicTo(14.8122f, 1.05824f, 15.7467f, 0.702339f, 0.707107f);
7817path.close();
7818path.moveTo(18.7758f, -0.24399f);
7819path.quadTo(19.2913f, -0.371107f, 19.8116f, -0.477061f);
7820path.conicTo(20.7915f, -0.676608f, 20.9911f, 0.303281f, 0.707107f);
7821path.conicTo(21.1906f, 1.28317f, 20.2107f, 1.48272f, 0.707107f);
7822path.quadTo(19.7304f, 1.58052f, 19.2546f, 1.69785f);
7823path.conicTo(18.2836f, 1.93725f, 18.0443f, 0.966329f, 0.707107f);
7824path.conicTo(17.8049f, -0.00459272f, 18.7758f, -0.24399f, 0.707107f);
7825path.close();
7826path.moveTo(21.878f, -0.811882f);
7827path.quadTo(22.396f, -0.874528f, 22.916f, -0.916348f);
7828path.conicTo(23.9128f, -0.996504f, 23.993f, 0.000278629f, 0.707107f);
7829path.conicTo(24.0731f, 0.997061f, 23.0764f, 1.07722f, 0.707107f);
7830path.quadTo(22.5963f, 1.11582f, 22.1182f, 1.17365f);
7831path.conicTo(21.1254f, 1.29372f, 21.0053f, 0.300958f, 0.707107f);
7832path.conicTo(20.8853f, -0.691807f, 21.878f, -0.811882f, 0.707107f);
7833path.close();
7834path.moveTo(24.9926f, -0.999999f);
7835path.quadTo(25.5166f, -1.00015f, 26.0401f, -0.979188f);
7836path.conicTo(27.0393f, -0.939179f, 26.9992f, 0.0600199f, 0.707107f);
7837path.conicTo(26.9592f, 1.05922f, 25.96f, 1.01921f, 0.707107f);
7838path.quadTo(25.4768f, 0.999863f, 24.9932f, 1);
7839path.conicTo(23.9932f, 1.00029f, 23.9929f, 0.000287339f, 0.707107f);
7840path.conicTo(23.9926f, -0.999713f, 24.9926f, -0.999999f, 0.707107f);
7841path.close();
7842path.moveTo(28.1286f, -0.811081f);
7843path.quadTo(28.6441f, -0.748593f, 29.1567f, -0.665572f);
7844path.conicTo(30.1439f, -0.505698f, 29.984f, 0.48144f, 0.707107f);
7845path.conicTo(29.8241f, 1.46858f, 28.837f, 1.3087f, 0.707107f);
7846path.quadTo(28.3638f, 1.23207f, 27.8879f, 1.17439f);
7847path.conicTo(26.8952f, 1.05406f, 27.0155f, 0.0613233f, 0.707107f);
7848path.conicTo(27.1359f, -0.931411f, 28.1286f, -0.811081f, 0.707107f);
7849path.close();
7850path.moveTo(31.214f, -0.246499f);
7851path.quadTo(31.7439f, -0.116076f, 32.2679f, 0.0364622f);
7852path.conicTo(33.228f, 0.315996f, 32.9485f, 1.27613f, 0.707107f);
7853path.conicTo(32.6689f, 2.23627f, 31.7088f, 1.95673f, 0.707107f);
7854path.quadTo(31.2252f, 1.81593f, 30.736f, 1.69554f);
7855path.conicTo(29.765f, 1.45654f, 30.004f, 0.48552f, 0.707107f);
7856path.conicTo(30.243f, -0.485499f, 31.214f, -0.246499f, 0.707107f);
7857path.close();
7858path.moveTo(34.3038f, 0.721629f);
7859path.quadTo(34.797f, 0.910612f, 35.282f, 1.11946f);
7860path.conicTo(36.2005f, 1.51493f, 35.805f, 2.43341f, 0.707107f);
7861path.conicTo(35.4096f, 3.35189f, 34.4911f, 2.95642f, 0.707107f);
7862path.quadTo(34.0434f, 2.76365f, 33.5881f, 2.5892f);
7863path.conicTo(32.6543f, 2.23137f, 33.0122f, 1.29758f, 0.707107f);
7864path.conicTo(33.37f, 0.363796f, 34.3038f, 0.721629f, 0.707107f);
7865path.close();
7866path.moveTo(37.1508f, 2.01396f);
7867path.quadTo(37.5996f, 2.2512f, 38.0388f, 2.50578f);
7868path.conicTo(38.904f, 3.00727f, 38.4025f, 3.87244f, 0.707107f);
7869path.conicTo(37.901f, 4.7376f, 37.0358f, 4.23612f, 0.707107f);
7870path.quadTo(36.6304f, 4.00111f, 36.2161f, 3.78211f);
7871path.conicTo(35.332f, 3.31476f, 35.7994f, 2.43069f, 0.707107f);
7872path.conicTo(36.2667f, 1.54661f, 37.1508f, 2.01396f, 0.707107f);
7873path.close();
7874path.moveTo(39.718f, 3.56681f);
7875path.quadTo(40.1269f, 3.84765f, 40.5249f, 4.14392f);
7876path.conicTo(41.3271f, 4.74104f, 40.73f, 5.54319f, 0.707107f);
7877path.conicTo(40.1329f, 6.34535f, 39.3307f, 5.74823f, 0.707107f);
7878path.quadTo(38.9634f, 5.47478f, 38.5858f, 5.21552f);
7879path.conicTo(37.7615f, 4.64945f, 38.3275f, 3.82509f, 0.707107f);
7880path.conicTo(38.8936f, 3.00074f, 39.718f, 3.56681f, 0.707107f);
7881path.close();
7882path.moveTo(42.1033f, 5.41741f);
7883path.quadTo(42.4933f, 5.75802f, 42.8694f, 6.11388f);
7884path.conicTo(43.5958f, 6.80115f, 42.9085f, 7.52755f, 0.707107f);
7885path.conicTo(42.2212f, 8.25394f, 41.4948f, 7.56667f, 0.707107f);
7886path.quadTo(41.1476f, 7.23817f, 40.7876f, 6.92375f);
7887path.conicTo(40.0345f, 6.26593f, 40.6923f, 5.51275f, 0.707107f);
7888path.conicTo(41.3501f, 4.75958f, 42.1033f, 5.41741f, 0.707107f);
7889path.close();
7890path.moveTo(44.3419f, 7.62498f);
7891path.quadTo(44.7007f, 8.02444f, 45.0428f, 8.43835f);
7892path.conicTo(45.6797f, 9.20922f, 44.9089f, 9.84622f, 0.707107f);
7893path.conicTo(44.138f, 10.4832f, 43.501f, 9.71234f, 0.707107f);
7894path.quadTo(43.1852f, 9.3302f, 42.854f, 8.96151f);
7895path.conicTo(42.1858f, 8.21759f, 42.9297f, 7.54932f, 0.707107f);
7896path.conicTo(43.6736f, 6.88106f, 44.3419f, 7.62498f, 0.707107f);
7897path.close();
7898path.moveTo(46.3599f, 10.1759f);
7899path.quadTo(46.6546f, 10.6005f, 46.9322f, 11.0366f);
7900path.conicTo(47.4693f, 11.8801f, 46.6257f, 12.4172f, 0.707107f);
7901path.conicTo(45.7822f, 12.9542f, 45.2451f, 12.1107f, 0.707107f);
7902path.quadTo(44.9889f, 11.7082f, 44.7168f, 11.3162f);
7903path.conicTo(44.1467f, 10.4947f, 44.9682f, 9.92452f, 0.707107f);
7904path.conicTo(45.7897f, 9.35435f, 46.3599f, 10.1759f, 0.707107f);
7905path.close();
7906path.moveTo(47.9708f, 12.8204f);
7907path.quadTo(48.2149f, 13.2808f, 48.4403f, 13.7506f);
7908path.conicTo(48.873f, 14.6521f, 47.9715f, 15.0848f, 0.707107f);
7909path.conicTo(47.0699f, 15.5174f, 46.6372f, 14.6159f, 0.707107f);
7910path.quadTo(46.4291f, 14.1822f, 46.2038f, 13.7573f);
7911path.conicTo(45.7354f, 12.8738f, 46.6188f, 12.4054f, 0.707107f);
7912path.conicTo(47.5023f, 11.9369f, 47.9708f, 12.8204f, 0.707107f);
7913path.close();
7914path.moveTo(49.2713f, 15.6778f);
7915path.quadTo(49.4606f, 16.1706f, 49.6297f, 16.6708f);
7916path.conicTo(49.9501f, 17.6181f, 49.0028f, 17.9384f, 0.707107f);
7917path.conicTo(48.0555f, 18.2588f, 47.7351f, 17.3115f, 0.707107f);
7918path.quadTo(47.5791f, 16.8499f, 47.4043f, 16.3949f);
7919path.conicTo(47.0458f, 15.4614f, 47.9793f, 15.1029f, 0.707107f);
7920path.conicTo(48.9128f, 14.7443f, 49.2713f, 15.6778f, 0.707107f);
7921path.close();
7922path.moveTo(50.2261f, 18.7037f);
7923path.quadTo(50.3547f, 19.2188f, 50.4621f, 19.7388f);
7924path.conicTo(50.6645f, 20.7182f, 49.6852f, 20.9205f, 0.707107f);
7925path.conicTo(48.7059f, 21.1229f, 48.5035f, 20.1436f, 0.707107f);
7926path.quadTo(48.4043f, 19.6636f, 48.2856f, 19.1881f);
7927path.conicTo(48.0435f, 18.2178f, 49.0137f, 17.9757f, 0.707107f);
7928path.conicTo(49.984f, 17.7335f, 50.2261f, 18.7037f, 0.707107f);
7929path.close();
7930path.moveTo(50.803f, 21.8055f);
7931path.quadTo(50.8671f, 22.3234f, 50.9104f, 22.8434f);
7932path.conicTo(50.9934f, 23.8399f, 49.9968f, 23.9229f, 0.707107f);
7933path.conicTo(49.0002f, 24.0058f, 48.9173f, 23.0093f, 0.707107f);
7934path.quadTo(48.8773f, 22.5293f, 48.8182f, 22.0513f);
7935path.conicTo(48.6953f, 21.0588f, 49.6877f, 20.936f, 0.707107f);
7936path.conicTo(50.6801f, 20.8131f, 50.803f, 21.8055f, 0.707107f);
7937path.close();
7938path.moveTo(50.9999f, 24.9202f);
7939path.quadTo(51.0015f, 25.4434f, 50.982f, 25.9664f);
7940path.conicTo(50.9449f, 26.9657f, 49.9456f, 26.9286f, 0.707107f);
7941path.conicTo(48.9463f, 26.8914f, 48.9834f, 25.8921f, 0.707107f);
7942path.quadTo(49.0014f, 25.4094f, 48.9999f, 24.9263f);
7943path.conicTo(48.9968f, 23.9263f, 49.9968f, 23.9232f, 0.707107f);
7944path.conicTo(50.9968f, 23.9202f, 50.9999f, 24.9202f, 0.707107f);
7945path.close();
7946path.moveTo(50.8198f, 28.0562f);
7947path.quadTo(50.7587f, 28.5721f, 50.677f, 29.0852f);
7948path.conicTo(50.5199f, 30.0728f, 49.5323f, 29.9157f, 0.707107f);
7949path.conicTo(48.5448f, 29.7586f, 48.7019f, 28.771f, 0.707107f);
7950path.quadTo(48.7772f, 28.2974f, 48.8336f, 27.8211f);
7951path.conicTo(48.9512f, 26.8281f, 49.9442f, 26.9456f, 0.707107f);
7952path.conicTo(50.9373f, 27.0632f, 50.8198f, 28.0562f, 0.707107f);
7953path.close();
7954path.moveTo(50.2647f, 31.1395f);
7955path.quadTo(50.1358f, 31.6701f, 49.9847f, 32.1949f);
7956path.conicTo(49.7079f, 33.1558f, 48.747f, 32.8791f, 0.707107f);
7957path.conicTo(47.786f, 32.6024f, 48.0628f, 31.6414f, 0.707107f);
7958path.quadTo(48.2022f, 31.1571f, 48.3213f, 30.6672f);
7959path.conicTo(48.5574f, 29.6955f, 49.5291f, 29.9317f, 0.707107f);
7960path.conicTo(50.5009f, 30.1678f, 50.2647f, 31.1395f, 0.707107f);
7961path.close();
7962path.moveTo(49.3049f, 34.2343f);
7963path.quadTo(49.1171f, 34.7285f, 48.9095f, 35.2145f);
7964path.conicTo(48.5166f, 36.1341f, 47.597f, 35.7412f, 0.707107f);
7965path.conicTo(46.6774f, 35.3483f, 47.0703f, 34.4288f, 0.707107f);
7966path.quadTo(47.262f, 33.9801f, 47.4353f, 33.524f);
7967path.conicTo(47.7904f, 32.5892f, 48.7252f, 32.9444f, 0.707107f);
7968path.conicTo(49.66f, 33.2995f, 49.3049f, 34.2343f, 0.707107f);
7969path.close();
7970path.moveTo(48.0194f, 37.0875f);
7971path.quadTo(47.7831f, 37.5374f, 47.5295f, 37.9777f);
7972path.conicTo(47.0304f, 38.8443f, 46.1638f, 38.3451f, 0.707107f);
7973path.conicTo(45.2973f, 37.846f, 45.7965f, 36.9795f, 0.707107f);
7974path.quadTo(46.0306f, 36.5729f, 46.2487f, 36.1577f);
7975path.conicTo(46.7136f, 35.2723f, 47.5989f, 35.7372f, 0.707107f);
7976path.conicTo(48.4843f, 36.2021f, 48.0194f, 37.0875f, 0.707107f);
7977path.close();
7978path.moveTo(46.4721f, 39.6612f);
7979path.quadTo(46.1926f, 40.0705f, 45.8977f, 40.4688f);
7980path.conicTo(45.3028f, 41.2726f, 44.499f, 40.6776f, 0.707107f);
7981path.conicTo(43.6953f, 40.0827f, 44.2902f, 39.2789f, 0.707107f);
7982path.quadTo(44.5624f, 38.9112f, 44.8204f, 38.5334f);
7983path.conicTo(45.3843f, 37.7075f, 46.2101f, 38.2714f, 0.707107f);
7984path.conicTo(47.036f, 38.8353f, 46.4721f, 39.6612f, 0.707107f);
7985path.close();
7986path.moveTo(44.6298f, 42.0491f);
7987path.quadTo(44.2906f, 42.4396f, 43.9361f, 42.8164f);
7988path.conicTo(43.2509f, 43.5447f, 42.5226f, 42.8595f, 0.707107f);
7989path.conicTo(41.7942f, 42.1742f, 42.4795f, 41.4459f, 0.707107f);
7990path.quadTo(42.8067f, 41.0981f, 43.1198f, 40.7376f);
7991path.conicTo(43.7756f, 39.9826f, 44.5306f, 40.6383f, 0.707107f);
7992path.conicTo(45.2856f, 41.2941f, 44.6298f, 42.0491f, 0.707107f);
7993path.close();
7994path.moveTo(42.4305f, 44.2919f);
7995path.quadTo(42.0324f, 44.6516f, 41.6198f, 44.9946f);
7996path.conicTo(40.8507f, 45.6338f, 40.2115f, 44.8648f, 0.707107f);
7997path.conicTo(39.5723f, 44.0958f, 40.3413f, 43.4566f, 0.707107f);
7998path.quadTo(40.7222f, 43.1399f, 41.0897f, 42.8079f);
7999path.conicTo(41.8317f, 42.1375f, 42.5021f, 42.8795f, 0.707107f);
8000path.conicTo(43.1725f, 43.6215f, 42.4305f, 44.2919f, 0.707107f);
8001path.close();
8002path.moveTo(39.8873f, 46.3159f);
8003path.quadTo(39.4613f, 46.6134f, 39.0238f, 46.8936f);
8004path.conicTo(38.1818f, 47.433f, 37.6424f, 46.5909f, 0.707107f);
8005path.conicTo(37.103f, 45.7489f, 37.9451f, 45.2095f, 0.707107f);
8006path.quadTo(38.3489f, 44.9508f, 38.7421f, 44.6763f);
8007path.conicTo(39.5619f, 44.1037f, 40.1345f, 44.9235f, 0.707107f);
8008path.conicTo(40.7071f, 45.7434f, 39.8873f, 46.3159f, 0.707107f);
8009path.close();
8010path.moveTo(37.2437f, 47.9367f);
8011path.quadTo(36.7842f, 48.182f, 36.3153f, 48.4086f);
8012path.conicTo(35.415f, 48.8439f, 34.9797f, 47.9435f, 0.707107f);
8013path.conicTo(34.5445f, 47.0432f, 35.4449f, 46.608f, 0.707107f);
8014path.quadTo(35.8778f, 46.3987f, 36.3019f, 46.1723f);
8015path.conicTo(37.1841f, 45.7014f, 37.655f, 46.5836f, 0.707107f);
8016path.conicTo(38.1259f, 47.4658f, 37.2437f, 47.9367f, 0.707107f);
8017path.close();
8018path.moveTo(34.3909f, 49.2448f);
8019path.quadTo(33.8988f, 49.4354f, 33.3992f, 49.606f);
8020path.conicTo(32.4528f, 49.929f, 32.1298f, 48.9826f, 0.707107f);
8021path.conicTo(31.8068f, 48.0362f, 32.7532f, 47.7132f, 0.707107f);
8022path.quadTo(33.2142f, 47.5558f, 33.6685f, 47.3798f);
8023path.conicTo(34.601f, 47.0186f, 34.9622f, 47.9511f, 0.707107f);
8024path.conicTo(35.3234f, 48.8836f, 34.3909f, 49.2448f, 0.707107f);
8025path.close();
8026path.moveTo(31.3682f, 50.208f);
8027path.quadTo(30.8535f, 50.3381f, 30.3338f, 50.447f);
8028path.conicTo(29.3551f, 50.6521f, 29.15f, 49.6734f, 0.707107f);
8029path.conicTo(28.9448f, 48.6947f, 29.9236f, 48.4895f, 0.707107f);
8030path.quadTo(30.4033f, 48.389f, 30.8784f, 48.269f);
8031path.conicTo(31.8479f, 48.024f, 32.0929f, 48.9936f, 0.707107f);
8032path.conicTo(32.3378f, 49.9631f, 31.3682f, 50.208f, 0.707107f);
8033path.close();
8034path.moveTo(28.2669f, 50.7939f);
8035path.quadTo(27.7491f, 50.8595f, 27.2292f, 50.9043f);
8036path.conicTo(26.2329f, 50.99f, 26.1472f, 49.9937f, 0.707107f);
8037path.conicTo(26.0615f, 48.9973f, 27.0578f, 48.9116f, 0.707107f);
8038path.quadTo(27.5378f, 48.8703f, 28.0156f, 48.8098f);
8039path.conicTo(29.0077f, 48.6841f, 29.1334f, 49.6762f, 0.707107f);
8040path.conicTo(29.259f, 50.6683f, 28.2669f, 50.7939f, 0.707107f);
8041path.close();
8042path.moveTo(25.1523f, 50.9996f);
8043path.quadTo(24.6297f, 51.0026f, 24.1072f, 50.9847f);
8044path.conicTo(23.1078f, 50.9503f, 23.1422f, 49.9509f, 0.707107f);
8045path.conicTo(23.1765f, 48.9515f, 24.1759f, 48.9858f, 0.707107f);
8046path.quadTo(24.658f, 49.0024f, 25.1406f, 48.9996f);
8047path.conicTo(26.1406f, 48.9937f, 26.1464f, 49.9937f, 0.707107f);
8048path.conicTo(26.1523f, 50.9937f, 25.1523f, 50.9996f, 0.707107f);
8049path.close();
8050path.moveTo(22.0162f, 50.8282f);
8051path.quadTo(21.4999f, 50.7686f, 20.9863f, 50.6883f);
8052path.conicTo(19.9983f, 50.5339f, 20.1527f, 49.5459f, 0.707107f);
8053path.conicTo(20.307f, 48.5579f, 21.295f, 48.7123f, 0.707107f);
8054path.quadTo(21.7691f, 48.7864f, 22.2457f, 48.8414f);
8055path.conicTo(23.2391f, 48.9562f, 23.1243f, 49.9496f, 0.707107f);
8056path.conicTo(23.0096f, 50.943f, 22.0162f, 50.8282f, 0.707107f);
8057path.close();
8058path.moveTo(18.9351f, 50.2827f);
8059path.quadTo(18.4037f, 50.1553f, 17.8782f, 50.0056f);
8060path.conicTo(16.9164f, 49.7317f, 17.1904f, 48.7699f, 0.707107f);
8061path.conicTo(17.4643f, 47.8082f, 18.426f, 48.0821f, 0.707107f);
8062path.quadTo(18.9112f, 48.2203f, 19.4016f, 48.3379f);
8063path.conicTo(20.374f, 48.5712f, 20.1408f, 49.5436f, 0.707107f);
8064path.conicTo(19.9075f, 50.516f, 18.9351f, 50.2827f, 0.707107f);
8065path.close();
8066path.moveTo(15.8352f, 49.3312f);
8067path.quadTo(15.3403f, 49.1448f, 14.8531f, 48.9383f);
8068path.conicTo(13.9324f, 48.548f, 14.3227f, 47.6273f, 0.707107f);
8069path.conicTo(14.713f, 46.7066f, 15.6337f, 47.0969f, 0.707107f);
8070path.quadTo(16.0832f, 47.2874f, 16.5402f, 47.4596f);
8071path.conicTo(17.476f, 47.812f, 17.1235f, 48.7479f, 0.707107f);
8072path.conicTo(16.771f, 49.6837f, 15.8352f, 49.3312f, 0.707107f);
8073path.close();
8074path.moveTo(12.9759f, 48.0526f);
8075path.quadTo(12.5249f, 47.8173f, 12.0835f, 47.5647f);
8076path.conicTo(11.2156f, 47.0679f, 11.7124f, 46.2f, 0.707107f);
8077path.conicTo(12.2092f, 45.3321f, 13.0771f, 45.8289f, 0.707107f);
8078path.quadTo(13.4846f, 46.0622f, 13.9009f, 46.2793f);
8079path.conicTo(14.7875f, 46.7418f, 14.325f, 47.6284f, 0.707107f);
8080path.conicTo(13.8626f, 48.5151f, 12.9759f, 48.0526f, 0.707107f);
8081path.close();
8082path.moveTo(10.3957f, 46.5108f);
8083path.quadTo(9.9861f, 46.2327f, 9.58733f, 45.9392f);
8084path.conicTo(8.78198f, 45.3464f, 9.37478f, 44.541f, 0.707107f);
8085path.conicTo(9.96757f, 43.7357f, 10.7729f, 44.3285f, 0.707107f);
8086path.quadTo(11.141f, 44.5994f, 11.5191f, 44.8561f);
8087path.conicTo(12.3464f, 45.4178f, 11.7847f, 46.2451f, 0.707107f);
8088path.conicTo(11.223f, 47.0725f, 10.3957f, 46.5108f, 0.707107f);
8089path.close();
8090path.moveTo(8.00525f, 44.6769f);
8091path.quadTo(7.6141f, 44.339f, 7.23672f, 43.9859f);
8092path.conicTo(6.50649f, 43.3027f, 7.18969f, 42.5725f, 0.707107f);
8093path.conicTo(7.87289f, 41.8423f, 8.60312f, 42.5255f, 0.707107f);
8094path.quadTo(8.95149f, 42.8514f, 9.31254f, 43.1632f);
8095path.conicTo(10.0693f, 43.8169f, 9.4157f, 44.5737f, 0.707107f);
8096path.conicTo(8.76206f, 45.3305f, 8.00525f, 44.6769f, 0.707107f);
8097path.close();
8098path.moveTo(5.75818f, 42.4858f);
8099path.quadTo(5.39763f, 42.089f, 5.05371f, 41.6777f);
8100path.conicTo(4.41226f, 40.9105f, 5.17942f, 40.2691f, 0.707107f);
8101path.conicTo(5.94658f, 39.6276f, 6.58804f, 40.3948f, 0.707107f);
8102path.quadTo(6.90548f, 40.7744f, 7.23832f, 41.1407f);
8103path.conicTo(7.91085f, 41.8808f, 7.17078f, 42.5533f, 0.707107f);
8104path.conicTo(6.43071f, 43.2258f, 5.75818f, 42.4858f, 0.707107f);
8105path.close();
8106path.moveTo(3.72821f, 39.9503f);
8107path.quadTo(3.42794f, 39.523f, 3.1451f, 39.0842f);
8108path.conicTo(2.6034f, 38.2436f, 3.44397f, 37.7019f, 0.707107f);
8109path.conicTo(4.28454f, 37.1602f, 4.82624f, 38.0008f, 0.707107f);
8110path.quadTo(5.08734f, 38.4059f, 5.3645f, 38.8003f);
8111path.conicTo(5.93951f, 39.6184f, 5.12137f, 40.1934f, 0.707107f);
8112path.conicTo(4.30322f, 40.7684f, 3.72821f, 39.9503f, 0.707107f);
8113path.close();
8114path.moveTo(2.09762f, 37.3078f);
8115path.quadTo(1.85114f, 36.8491f, 1.62324f, 36.381f);
8116path.conicTo(1.18551f, 35.4819f, 2.08461f, 35.0442f, 0.707107f);
8117path.conicTo(2.98372f, 34.6064f, 3.42145f, 35.5055f, 0.707107f);
8118path.quadTo(3.63184f, 35.9377f, 3.85934f, 36.361f);
8119path.conicTo(4.33272f, 37.2419f, 3.45185f, 37.7153f, 0.707107f);
8120path.conicTo(2.57099f, 38.1886f, 2.09762f, 37.3078f, 0.707107f);
8121path.close();
8122path.moveTo(0.781912f, 34.4596f);
8123path.quadTo(0.589924f, 33.9681f, 0.418029f, 33.4692f);
8124path.conicTo(0.0922952f, 32.5237f, 1.03776f, 32.198f, 0.707107f);
8125path.conicTo(1.98322f, 31.8722f, 2.30895f, 32.8177f, 0.707107f);
8126path.quadTo(2.46761f, 33.2782f, 2.64484f, 33.7319f);
8127path.conicTo(3.00867f, 34.6634f, 2.07721f, 35.0272f, 0.707107f);
8128path.conicTo(1.14575f, 35.3911f, 0.781912f, 34.4596f, 0.707107f);
8129path.close();
8130path.moveTo(-0.189761f, 31.4402f);
8131path.quadTo(-0.321263f, 30.9258f, -0.431662f, 30.4065f);
8132path.conicTo(-0.639608f, 29.4284f, 0.338532f, 29.2205f, 0.707107f);
8133path.conicTo(1.31667f, 29.0125f, 1.52462f, 29.9906f, 0.707107f);
8134path.quadTo(1.62653f, 30.47f, 1.74791f, 30.9448f);
8135path.conicTo(1.99561f, 31.9136f, 1.02677f, 32.1613f, 0.707107f);
8136path.conicTo(0.0579369f, 32.409f, -0.189761f, 31.4402f, 0.707107f);
8137path.close();
8138path.moveTo(-0.784658f, 28.3394f);
8139path.quadTo(-0.851693f, 27.8218f, -0.897902f, 27.3019f);
8140path.conicTo(-0.986437f, 26.3058f, 0.00963629f, 26.2173f, 0.707107f);
8141path.conicTo(1.00571f, 26.1288f, 1.09424f, 27.1248f, 0.707107f);
8142path.quadTo(1.1369f, 27.6047f, 1.19878f, 28.0825f);
8143path.conicTo(1.32721f, 29.0742f, 0.335496f, 29.2027f, 0.707107f);
8144path.conicTo(-0.656222f, 29.3311f, -0.784658f, 28.3394f, 0.707107f);
8145path.close();
8146path.moveTo(-0.999031f, 25.2248f);
8147path.quadTo(-1.00354f, 24.7027f, -0.987098f, 24.1809f);
8148path.conicTo(-0.955596f, 23.1814f, 0.0439078f, 23.2129f, 0.707107f);
8149path.conicTo(1.04341f, 23.2444f, 1.01191f, 24.2439f, 0.707107f);
8150path.quadTo(0.996728f, 24.7256f, 1.00089f, 25.2075f);
8151path.conicTo(1.00954f, 26.2075f, 0.00957754f, 26.2161f, 0.707107f);
8152path.conicTo(-0.990385f, 26.2248f, -0.999031f, 25.2248f, 0.707107f);
8153path.close();
8154path.moveTo(-0.836492f, 22.0887f);
8155path.quadTo(-0.778263f, 21.5719f, -0.699419f, 21.0579f);
8156path.conicTo(-0.5478f, 20.0695f, 0.440639f, 20.2211f, 0.707107f);
8157path.conicTo(1.42908f, 20.3727f, 1.27746f, 21.3612f, 0.707107f);
8158path.quadTo(1.20468f, 21.8356f, 1.15093f, 22.3126f);
8159path.conicTo(1.03896f, 23.3063f, 0.0452449f, 23.1944f, 0.707107f);
8160path.conicTo(-0.948466f, 23.0824f, -0.836492f, 22.0887f, 0.707107f);
8161path.close();
8162path.moveTo(-0.300548f, 19.0098f);
8163path.quadTo(-0.174573f, 18.4777f, -0.0263361f, 17.9514f);
8164path.conicTo(0.244762f, 16.9889f, 1.20731f, 17.26f, 0.707107f);
8165path.conicTo(2.16987f, 17.5311f, 1.89877f, 18.4936f, 0.707107f);
8166path.quadTo(1.76193f, 18.9794f, 1.64565f, 19.4706f);
8167path.conicTo(1.41526f, 20.4437f, 0.442159f, 20.2133f, 0.707107f);
8168path.conicTo(-0.530939f, 19.9829f, -0.300548f, 19.0098f, 0.707107f);
8169path.close();
8170path.moveTo(0.642658f, 15.9049f);
8171path.quadTo(0.827861f, 15.409f, 1.0331f, 14.9209f);
8172path.conicTo(1.42076f, 13.9991f, 2.34256f, 14.3868f, 0.707107f);
8173path.conicTo(3.26437f, 14.7744f, 2.87671f, 15.6962f, 0.707107f);
8174path.quadTo(2.68726f, 16.1467f, 2.5163f, 16.6046f);
8175path.conicTo(2.16648f, 17.5414f, 1.22967f, 17.1916f, 0.707107f);
8176path.conicTo(0.292846f, 16.8418f, 0.642658f, 15.9049f, 0.707107f);
8177path.close();
8178path.moveTo(1.91434f, 13.0395f);
8179path.quadTo(2.14856f, 12.5875f, 2.40031f, 12.1449f);
8180path.conicTo(2.89473f, 11.2757f, 3.76395f, 11.7701f, 0.707107f);
8181path.conicTo(4.63317f, 12.2645f, 4.13875f, 13.1337f, 0.707107f);
8182path.quadTo(3.90637f, 13.5423f, 3.69016f, 13.9596f);
8183path.conicTo(3.23014f, 14.8475f, 2.34223f, 14.3875f, 0.707107f);
8184path.conicTo(1.45432f, 13.9275f, 1.91434f, 13.0395f, 0.707107f);
8185path.close();
8186path.moveTo(3.45073f, 10.4525f);
8187path.quadTo(3.72744f, 10.0426f, 4.01954f, 9.64356f);
8188path.conicTo(4.61017f, 8.83661f, 5.41711f, 9.42725f, 0.707107f);
8189path.conicTo(6.22405f, 10.0179f, 5.63342f, 10.8248f, 0.707107f);
8190path.quadTo(5.36379f, 11.1932f, 5.10836f, 11.5716f);
8191path.conicTo(4.54884f, 12.4004f, 3.72003f, 11.8409f, 0.707107f);
8192path.conicTo(2.89121f, 11.2813f, 3.45073f, 10.4525f, 0.707107f);
8193path.close();
8194path.moveTo(5.2763f, 8.05964f);
8195path.quadTo(5.61273f, 7.66793f, 5.96445f, 7.2899f);
8196path.conicTo(6.6456f, 6.55776f, 7.37774f, 7.23892f, 0.707107f);
8197path.conicTo(8.10988f, 7.92008f, 7.42872f, 8.65221f, 0.707107f);
8198path.quadTo(7.10407f, 9.00116f, 6.79351f, 9.36274f);
8199path.conicTo(6.14196f, 10.1213f, 5.38336f, 9.46979f, 0.707107f);
8200path.conicTo(4.62475f, 8.81824f, 5.2763f, 8.05964f, 0.707107f);
8201path.close();
8202path.moveTo(7.45913f, 5.80839f);
8203path.quadTo(7.85457f, 5.44696f, 8.26455f, 5.10214f);
8204path.conicTo(9.02985f, 4.45847f, 9.67352f, 5.22377f, 0.707107f);
8205path.conicTo(10.3172f, 5.98907f, 9.5519f, 6.63274f, 0.707107f);
8206path.quadTo(9.17345f, 6.95105f, 8.80843f, 7.28467f);
8207path.conicTo(8.07029f, 7.95931f, 7.39564f, 7.22117f, 0.707107f);
8208path.conicTo(6.72099f, 6.48303f, 7.45913f, 5.80839f, 0.707107f);
8209path.close();
8210path.moveTo(9.98688f, 3.77251f);
8211path.quadTo(10.4153f, 3.46948f, 10.8557f, 3.18397f);
8212path.conicTo(11.6948f, 2.63996f, 12.2388f, 3.47904f, 0.707107f);
8213path.conicTo(12.7828f, 4.31812f, 11.9437f, 4.86213f, 0.707107f);
8214path.quadTo(11.5373f, 5.12566f, 11.1417f, 5.40539f);
8215path.conicTo(10.3253f, 5.98282f, 9.74787f, 5.16638f, 0.707107f);
8216path.conicTo(9.17044f, 4.34994f, 9.98688f, 3.77251f, 0.707107f);
8217path.close();
8218path.moveTo(12.6283f, 2.13208f);
8219path.quadTo(13.0861f, 1.88442f, 13.5534f, 1.65529f);
8220path.conicTo(14.4513f, 1.21504f, 14.8915f, 2.11291f, 0.707107f);
8221path.conicTo(15.3318f, 3.01078f, 14.4339f, 3.45104f, 0.707107f);
8222path.quadTo(14.0025f, 3.66255f, 13.58f, 3.89115f);
8223path.conicTo(12.7005f, 4.36698f, 12.2246f, 3.48744f, 0.707107f);
8224path.conicTo(11.7488f, 2.60791f, 12.6283f, 2.13208f, 0.707107f);
8225path.close();
8226path.moveTo(15.4718f, 0.808815f);
8227path.quadTo(15.9627f, 0.615476f, 16.461f, 0.442208f);
8228path.conicTo(17.4055f, 0.113784f, 17.7339f, 1.05831f, 0.707107f);
8229path.conicTo(18.0624f, 2.00284f, 17.1178f, 2.33127f, 0.707107f);
8230path.quadTo(16.6578f, 2.49121f, 16.2047f, 2.66968f);
8231path.conicTo(15.2743f, 3.03614f, 14.9078f, 2.10571f, 0.707107f);
8232path.conicTo(14.5414f, 1.17528f, 15.4718f, 0.808815f, 0.707107f);
8233path.close();
8234path.moveTo(18.4879f, -0.171272f);
8235path.quadTo(19.0019f, -0.304236f, 19.5208f, -0.416111f);
8236path.conicTo(20.4984f, -0.62685f, 20.7091f, 0.350692f, 0.707107f);
8237path.conicTo(20.9198f, 1.32823f, 19.9423f, 1.53897f, 0.707107f);
8238path.quadTo(19.4633f, 1.64224f, 18.9889f, 1.76498f);
8239path.conicTo(18.0207f, 2.01544f, 17.7703f, 1.04732f, 0.707107f);
8240path.conicTo(17.5198f, 0.0791926f, 18.4879f, -0.171272f, 0.707107f);
8241path.close();
8242path.moveTo(21.5882f, -0.77517f);
8243path.quadTo(22.1056f, -0.843665f, 22.6254f, -0.891339f);
8244path.conicTo(23.6212f, -0.982672f, 23.7126f, 0.0131486f, 0.707107f);
8245path.conicTo(23.8039f, 1.00897f, 22.8081f, 1.1003f, 0.707107f);
8246path.quadTo(22.3283f, 1.14431f, 21.8506f, 1.20754f);
8247path.conicTo(20.8592f, 1.33876f, 20.728f, 0.347405f, 0.707107f);
8248path.conicTo(20.5968f, -0.643948f, 21.5882f, -0.77517f, 0.707107f);
8249path.close();
8250path.moveTo(24.7026f, -0.998301f);
8251path.quadTo(25.2241f, -1.00426f, 25.7453f, -0.989316f);
8252path.conicTo(26.7449f, -0.960651f, 26.7162f, 0.0389383f, 0.707107f);
8253path.conicTo(26.6876f, 1.03853f, 25.688f, 1.00986f, 0.707107f);
8254path.quadTo(25.2068f, 0.996064f, 24.7255f, 1.00157f);
8255path.conicTo(23.7256f, 1.013f, 23.7141f, 0.0130688f, 0.707107f);
8256path.conicTo(23.7027f, -0.986866f, 24.7026f, -0.998301f, 0.707107f);
8257path.close();
8258path.moveTo(27.8388f, -0.844563f);
8259path.quadTo(28.3559f, -0.787759f, 28.8704f, -0.710314f);
8260path.conicTo(29.8592f, -0.561454f, 29.7104f, 0.427404f, 0.707107f);
8261path.conicTo(29.5615f, 1.41626f, 28.5726f, 1.2674f, 0.707107f);
8262path.quadTo(28.0978f, 1.19591f, 27.6204f, 1.14348f);
8263path.conicTo(26.6264f, 1.0343f, 26.7356f, 0.0402742f, 0.707107f);
8264path.conicTo(26.8447f, -0.953747f, 27.8388f, -0.844563f, 0.707107f);
8265path.close();
8266path.moveTo(30.9153f, -0.318153f);
8267path.quadTo(31.4481f, -0.193671f, 31.9752f, -0.046875f);
8268path.conicTo(32.9386f, 0.221405f, 32.6703f, 1.18475f, 0.707107f);
8269path.conicTo(32.402f, 2.14809f, 31.4387f, 1.87981f, 0.707107f);
8270path.quadTo(30.9521f, 1.74431f, 30.4603f, 1.6294f);
8271path.conicTo(29.4865f, 1.40189f, 29.714f, 0.428111f, 0.707107f);
8272path.conicTo(29.9416f, -0.545664f, 30.9153f, -0.318153f, 0.707107f);
8273path.close();
8274path.moveTo(34.0252f, 0.616677f);
8275path.quadTo(34.5221f, 0.800609f, 35.0111f, 1.00465f);
8276path.conicTo(35.934f, 1.3897f, 35.549f, 2.31259f, 0.707107f);
8277path.conicTo(35.1639f, 3.23549f, 34.241f, 2.85044f, 0.707107f);
8278path.quadTo(33.7896f, 2.66211f, 33.3309f, 2.49232f);
8279path.conicTo(32.3931f, 2.1452f, 32.7402f, 1.20738f, 0.707107f);
8280path.conicTo(33.0873f, 0.269559f, 34.0252f, 0.616677f, 0.707107f);
8281path.close();
8282path.moveTo(36.8967f, 1.88141f);
8283path.quadTo(37.3499f, 2.11462f, 37.7936f, 2.3654f);
8284path.conicTo(38.6641f, 2.85746f, 38.1721f, 3.72802f, 0.707107f);
8285path.conicTo(37.68f, 4.59858f, 36.8094f, 4.10652f, 0.707107f);
8286path.quadTo(36.3999f, 3.87504f, 35.9815f, 3.65976f);
8287path.conicTo(35.0924f, 3.2022f, 35.5499f, 2.31302f, 0.707107f);
8288path.conicTo(36.0075f, 1.42384f, 36.8967f, 1.88141f, 0.707107f);
8289path.close();
8290path.moveTo(39.4914f, 3.413f);
8291path.lineTo(39.5381f, 3.44439f);
8292path.quadTo(39.9244f, 3.70494f, 40.3002f, 3.97845f);
8293path.conicTo(41.1087f, 4.56692f, 40.5202f, 5.37544f, 0.707107f);
8294path.conicTo(39.9317f, 6.18396f, 39.1232f, 5.59549f, 0.707107f);
8295path.quadTo(38.7763f, 5.34298f, 38.4215f, 5.10371f);
8296path.lineTo(38.3749f, 5.07232f);
8297path.conicTo(37.5452f, 4.51406f, 38.1035f, 3.68439f, 0.707107f);
8298path.conicTo(38.6618f, 2.85473f, 39.4914f, 3.413f, 0.707107f);
8299path.close();
8300path.moveTo(41.8859f, 5.22965f);
8301path.quadTo(42.2782f, 5.56471f, 42.6568f, 5.91499f);
8302path.conicTo(43.3908f, 6.5941f, 42.7117f, 7.32814f, 0.707107f);
8303path.conicTo(42.0326f, 8.06218f, 41.2986f, 7.38308f, 0.707107f);
8304path.quadTo(40.949f, 7.05968f, 40.587f, 6.75043f);
8305path.conicTo(39.8266f, 6.10097f, 40.476f, 5.34058f, 0.707107f);
8306path.conicTo(41.1255f, 4.58018f, 41.8859f, 5.22965f, 0.707107f);
8307path.close();
8308path.moveTo(44.1413f, 7.40421f);
8309path.quadTo(44.5035f, 7.79829f, 44.8493f, 8.20695f);
8310path.conicTo(45.4952f, 8.97038f, 44.7317f, 9.61627f, 0.707107f);
8311path.conicTo(43.9683f, 10.2622f, 43.3224f, 9.49874f, 0.707107f);
8312path.quadTo(43.0033f, 9.1215f, 42.6689f, 8.75773f);
8313path.conicTo(41.9921f, 8.02152f, 42.7283f, 7.34476f, 0.707107f);
8314path.conicTo(43.4645f, 6.668f, 44.1413f, 7.40421f, 0.707107f);
8315path.close();
8316path.moveTo(46.183f, 9.9242f);
8317path.quadTo(46.4888f, 10.3539f, 46.777f, 10.7957f);
8318path.conicTo(47.3233f, 11.6332f, 46.4857f, 12.1796f, 0.707107f);
8319path.conicTo(45.6482f, 12.7259f, 45.1018f, 11.8883f, 0.707107f);
8320path.quadTo(44.8358f, 11.4805f, 44.5535f, 11.0839f);
8321path.conicTo(43.9737f, 10.2691f, 44.7884f, 9.6893f, 0.707107f);
8322path.conicTo(45.6032f, 9.10947f, 46.183f, 9.9242f, 0.707107f);
8323path.close();
8324path.moveTo(47.8333f, 12.5645f);
8325path.quadTo(48.0821f, 13.0214f, 48.3125f, 13.4879f);
8326path.conicTo(48.7552f, 14.3845f, 47.8586f, 14.8273f, 0.707107f);
8327path.conicTo(46.962f, 15.2701f, 46.5192f, 14.3734f, 0.707107f);
8328path.quadTo(46.3065f, 13.9428f, 46.0769f, 13.5211f);
8329path.conicTo(45.5986f, 12.6429f, 46.4768f, 12.1646f, 0.707107f);
8330path.conicTo(47.355f, 11.6863f, 47.8333f, 12.5645f, 0.707107f);
8331path.close();
8332path.moveTo(49.1641f, 15.4033f);
8333path.quadTo(49.3588f, 15.8935f, 49.5334f, 16.3912f);
8334path.conicTo(49.8645f, 17.3348f, 48.9209f, 17.6659f, 0.707107f);
8335path.conicTo(47.9773f, 17.997f, 47.6462f, 17.0534f, 0.707107f);
8336path.quadTo(47.485f, 16.5939f, 47.3053f, 16.1415f);
8337path.conicTo(46.9362f, 15.2121f, 47.8656f, 14.843f, 0.707107f);
8338path.conicTo(48.795f, 14.4739f, 49.1641f, 15.4033f, 0.707107f);
8339path.close();
8340path.moveTo(50.1526f, 18.4161f);
8341path.quadTo(50.287f, 18.9296f, 50.4003f, 19.4482f);
8342path.conicTo(50.6139f, 20.4252f, 49.6369f, 20.6387f, 0.707107f);
8343path.conicTo(48.66f, 20.8522f, 48.4465f, 19.8753f, 0.707107f);
8344path.quadTo(48.3419f, 19.3966f, 48.2178f, 18.9225f);
8345path.conicTo(47.9645f, 17.9551f, 48.9319f, 17.7019f, 0.707107f);
8346path.conicTo(49.8993f, 17.4487f, 50.1526f, 18.4161f, 0.707107f);
8347path.close();
8348path.moveTo(50.7655f, 21.5157f);
8349path.quadTo(50.8354f, 22.033f, 50.8846f, 22.5528f);
8350path.conicTo(50.9787f, 23.5483f, 49.9831f, 23.6425f, 0.707107f);
8351path.conicTo(48.9876f, 23.7366f, 48.8935f, 22.741f, 0.707107f);
8352path.quadTo(48.8481f, 22.2613f, 48.7835f, 21.7837f);
8353path.conicTo(48.6495f, 20.7928f, 49.6405f, 20.6587f, 0.707107f);
8354path.conicTo(50.6315f, 20.5247f, 50.7655f, 21.5157f, 0.707107f);
8355path.close();
8356path.moveTo(50.9974f, 24.6301f);
8357path.quadTo(51.0048f, 25.1509f, 50.9913f, 25.6715f);
8358path.conicTo(50.9655f, 26.6712f, 49.9658f, 26.6454f, 0.707107f);
8359path.conicTo(48.9662f, 26.6196f, 48.992f, 25.6199f, 0.707107f);
8360path.quadTo(49.0044f, 25.1393f, 48.9976f, 24.6585f);
8361path.conicTo(48.9834f, 23.6586f, 49.9833f, 23.6444f, 0.707107f);
8362path.conicTo(50.9832f, 23.6302f, 50.9974f, 24.6301f, 0.707107f);
8363path.close();
8364path.moveTo(50.8524f, 27.7662f);
8365path.quadTo(50.7971f, 28.2837f, 50.721f, 28.7986f);
8366path.conicTo(50.5749f, 29.7879f, 49.5856f, 29.6418f, 0.707107f);
8367path.conicTo(48.5963f, 29.4957f, 48.7425f, 28.5064f, 0.707107f);
8368path.quadTo(48.8127f, 28.0311f, 48.8638f, 27.5534f);
8369path.conicTo(48.9702f, 26.5591f, 49.9645f, 26.6655f, 0.707107f);
8370path.conicTo(50.9588f, 26.7718f, 50.8524f, 27.7662f, 0.707107f);
8371path.close();
8372path.moveTo(50.3355f, 30.8404f);
8373path.quadTo(50.2125f, 31.3739f, 50.0672f, 31.9018f);
8374path.conicTo(49.8018f, 32.8659f, 48.8376f, 32.6005f, 0.707107f);
8375path.conicTo(47.8735f, 32.335f, 48.139f, 31.3709f, 0.707107f);
8376path.quadTo(48.2731f, 30.8836f, 48.3867f, 30.3912f);
8377path.conicTo(48.6113f, 29.4167f, 49.5857f, 29.6413f, 0.707107f);
8378path.conicTo(50.5602f, 29.866f, 50.3355f, 30.8404f, 0.707107f);
8379path.close();
8380path.moveTo(49.4091f, 33.9552f);
8381path.quadTo(49.2264f, 34.4531f, 49.0236f, 34.9431f);
8382path.conicTo(48.6412f, 35.8671f, 47.7172f, 35.4846f, 0.707107f);
8383path.conicTo(46.7932f, 35.1022f, 47.1757f, 34.1782f, 0.707107f);
8384path.quadTo(47.3629f, 33.7259f, 47.5315f, 33.2663f);
8385path.conicTo(47.8759f, 32.3275f, 48.8147f, 32.672f, 0.707107f);
8386path.conicTo(49.7535f, 33.0164f, 49.4091f, 33.9552f, 0.707107f);
8387path.close();
8388path.moveTo(48.1514f, 36.8328f);
8389path.quadTo(47.9191f, 37.2871f, 47.6694f, 37.7318f);
8390path.conicTo(47.1797f, 38.6038f, 46.3078f, 38.1141f, 0.707107f);
8391path.conicTo(45.4359f, 37.6244f, 45.9256f, 36.7525f, 0.707107f);
8392path.quadTo(46.1562f, 36.3418f, 46.3705f, 35.9226f);
8393path.conicTo(46.8256f, 35.0321f, 47.716f, 35.4872f, 0.707107f);
8394path.conicTo(48.6065f, 35.9423f, 48.1514f, 36.8328f, 0.707107f);
8395path.close();
8396path.moveTo(46.6245f, 39.4354f);
8397path.lineTo(46.5563f, 39.537f);
8398path.quadTo(46.3146f, 39.8955f, 46.0624f, 40.2438f);
8399path.conicTo(45.4761f, 41.0539f, 44.666f, 40.4676f, 0.707107f);
8400path.conicTo(43.8559f, 39.8813f, 44.4422f, 39.0712f, 0.707107f);
8401path.quadTo(44.6749f, 38.7498f, 44.8955f, 38.4226f);
8402path.lineTo(44.9637f, 38.3211f);
8403path.conicTo(45.5209f, 37.4907f, 46.3513f, 38.0479f, 0.707107f);
8404path.conicTo(47.1817f, 38.605f, 46.6245f, 39.4354f, 0.707107f);
8405path.close();
8406path.moveTo(44.8168f, 41.8314f);
8407path.quadTo(44.4832f, 42.2241f, 44.1342f, 42.6034f);
8408path.conicTo(43.4572f, 43.3394f, 42.7212f, 42.6623f, 0.707107f);
8409path.conicTo(41.9853f, 41.9853f, 42.6623f, 41.2494f, 0.707107f);
8410path.quadTo(42.9845f, 40.8992f, 43.2924f, 40.5366f);
8411path.conicTo(43.9398f, 39.7745f, 44.702f, 40.4218f, 0.707107f);
8412path.conicTo(45.4642f, 41.0692f, 44.8168f, 41.8314f, 0.707107f);
8413path.close();
8414path.moveTo(42.6505f, 44.0908f);
8415path.quadTo(42.2577f, 44.454f, 41.8504f, 44.8006f);
8416path.conicTo(41.0888f, 45.4487f, 40.4408f, 44.6871f, 0.707107f);
8417path.conicTo(39.7927f, 43.9256f, 40.5542f, 43.2775f, 0.707107f);
8418path.quadTo(40.9302f, 42.9575f, 41.2928f, 42.6223f);
8419path.conicTo(42.027f, 41.9434f, 42.7059f, 42.6777f, 0.707107f);
8420path.conicTo(43.3848f, 43.412f, 42.6505f, 44.0908f, 0.707107f);
8421path.close();
8422path.moveTo(40.1383f, 46.1384f);
8423path.quadTo(39.7073f, 46.4471f, 39.2641f, 46.7378f);
8424path.conicTo(38.4281f, 47.2865f, 37.8795f, 46.4504f, 0.707107f);
8425path.conicTo(37.3308f, 45.6143f, 38.1669f, 45.0657f, 0.707107f);
8426path.quadTo(38.576f, 44.7972f, 38.9738f, 44.5124f);
8427path.conicTo(39.7868f, 43.9301f, 40.369f, 44.7432f, 0.707107f);
8428path.conicTo(40.9513f, 45.5562f, 40.1383f, 46.1384f, 0.707107f);
8429path.close();
8430path.moveTo(37.4991f, 47.7985f);
8431path.quadTo(37.0431f, 48.0485f, 36.5775f, 48.2801f);
8432path.conicTo(35.6821f, 48.7254f, 35.2368f, 47.83f, 0.707107f);
8433path.conicTo(34.7915f, 46.9346f, 35.6869f, 46.4893f, 0.707107f);
8434path.quadTo(36.1167f, 46.2755f, 36.5376f, 46.0448f);
8435path.conicTo(37.4145f, 45.5641f, 37.8952f, 46.4409f, 0.707107f);
8436path.conicTo(38.376f, 47.3178f, 37.4991f, 47.7985f, 0.707107f);
8437path.close();
8438path.moveTo(34.6651f, 49.1368f);
8439path.quadTo(34.1756f, 49.3328f, 33.6785f, 49.5089f);
8440path.conicTo(32.7358f, 49.8427f, 32.402f, 48.9f, 0.707107f);
8441path.conicTo(32.0682f, 47.9574f, 33.0109f, 47.6236f, 0.707107f);
8442path.quadTo(33.4697f, 47.4611f, 33.9216f, 47.2801f);
8443path.conicTo(34.85f, 46.9084f, 35.2217f, 47.8368f, 0.707107f);
8444path.conicTo(35.5934f, 48.7651f, 34.6651f, 49.1368f, 0.707107f);
8445path.close();
8446path.moveTo(31.6557f, 50.1337f);
8447path.quadTo(31.1425f, 50.2696f, 30.6243f, 50.3844f);
8448path.conicTo(29.648f, 50.6007f, 29.4317f, 49.6244f, 0.707107f);
8449path.conicTo(29.2153f, 48.6481f, 30.1917f, 48.4317f, 0.707107f);
8450path.quadTo(30.6701f, 48.3257f, 31.1437f, 48.2003f);
8451path.conicTo(32.1104f, 47.9443f, 32.3664f, 48.911f, 0.707107f);
8452path.conicTo(32.6223f, 49.8777f, 31.6557f, 50.1337f, 0.707107f);
8453path.close();
8454path.moveTo(28.5567f, 50.7556f);
8455path.quadTo(28.0395f, 50.827f, 27.5198f, 50.8776f);
8456path.conicTo(26.5245f, 50.9745f, 26.4276f, 49.9792f, 0.707107f);
8457path.conicTo(26.3307f, 48.9839f, 27.326f, 48.887f, 0.707107f);
8458path.quadTo(27.8056f, 48.8403f, 28.2831f, 48.7744f);
8459path.conicTo(29.2737f, 48.6376f, 29.4105f, 49.6282f, 0.707107f);
8460path.conicTo(29.5473f, 50.6188f, 28.5567f, 50.7556f, 0.707107f);
8461path.close();
8462path.moveTo(25.4424f, 50.9962f);
8463path.quadTo(24.9222f, 51.0051f, 24.4022f, 50.9931f);
8464path.conicTo(23.4025f, 50.9701f, 23.4255f, 49.9704f, 0.707107f);
8465path.conicTo(23.4485f, 48.9707f, 24.4482f, 48.9937f, 0.707107f);
8466path.quadTo(24.9283f, 49.0047f, 25.4084f, 48.9965f);
8467path.conicTo(26.4083f, 48.9795f, 26.4253f, 49.9794f, 0.707107f);
8468path.conicTo(26.4423f, 50.9792f, 25.4424f, 50.9962f, 0.707107f);
8469path.close();
8470path.moveTo(22.3065f, 50.8601f);
8471path.quadTo(21.7885f, 50.8062f, 21.2732f, 50.7315f);
8472path.conicTo(20.2835f, 50.5882f, 20.4268f, 49.5985f, 0.707107f);
8473path.conicTo(20.5702f, 48.6088f, 21.5599f, 48.7522f, 0.707107f);
8474path.quadTo(22.0355f, 48.8211f, 22.5136f, 48.8709f);
8475path.conicTo(23.5083f, 48.9745f, 23.4047f, 49.9691f, 0.707107f);
8476path.conicTo(23.3011f, 50.9637f, 22.3065f, 50.8601f, 0.707107f);
8477path.close();
8478path.moveTo(19.2346f, 50.3527f);
8479path.quadTo(18.7003f, 50.2312f, 18.1717f, 50.0873f);
8480path.conicTo(17.2068f, 49.8247f, 17.4694f, 48.8598f, 0.707107f);
8481path.conicTo(17.732f, 47.8949f, 18.6969f, 48.1575f, 0.707107f);
8482path.quadTo(19.185f, 48.2904f, 19.6781f, 48.4025f);
8483path.conicTo(20.6532f, 48.6243f, 20.4314f, 49.5994f, 0.707107f);
8484path.conicTo(20.2097f, 50.5745f, 19.2346f, 50.3527f, 0.707107f);
8485path.close();
8486path.moveTo(16.1149f, 49.4347f);
8487path.quadTo(15.6161f, 49.2533f, 15.1251f, 49.0517f);
8488path.conicTo(14.2f, 48.6719f, 14.5798f, 47.7469f, 0.707107f);
8489path.conicTo(14.9596f, 46.8218f, 15.8847f, 47.2016f, 0.707107f);
8490path.quadTo(16.3379f, 47.3877f, 16.7984f, 47.5551f);
8491path.conicTo(17.7382f, 47.8969f, 17.3964f, 48.8366f, 0.707107f);
8492path.conicTo(17.0547f, 49.7764f, 16.1149f, 49.4347f, 0.707107f);
8493path.close();
8494path.moveTo(13.2313f, 48.184f);
8495path.quadTo(12.776f, 47.9529f, 12.33f, 47.704f);
8496path.conicTo(11.4568f, 47.2167f, 11.9441f, 46.3434f, 0.707107f);
8497path.conicTo(12.4314f, 45.4702f, 13.3046f, 45.9575f, 0.707107f);
8498path.quadTo(13.7162f, 46.1872f, 14.1365f, 46.4006f);
8499path.conicTo(15.0282f, 46.8532f, 14.5756f, 47.7449f, 0.707107f);
8500path.conicTo(14.123f, 48.6366f, 13.2313f, 48.184f, 0.707107f);
8501path.close();
8502path.moveTo(10.6208f, 46.6619f);
8503path.lineTo(10.4641f, 46.5571f);
8504path.quadTo(10.1333f, 46.334f, 9.81253f, 46.1031f);
8505path.conicTo(9.00087f, 45.519f, 9.585f, 44.7073f, 0.707107f);
8506path.conicTo(10.1691f, 43.8957f, 10.9808f, 44.4798f, 0.707107f);
8507path.quadTo(11.2769f, 44.6929f, 11.5763f, 44.8948f);
8508path.lineTo(11.7329f, 44.9996f);
8509path.conicTo(12.564f, 45.5557f, 12.008f, 46.3868f, 0.707107f);
8510path.conicTo(11.4519f, 47.2179f, 10.6208f, 46.6619f, 0.707107f);
8511path.close();
8512path.moveTo(8.22326f, 44.8631f);
8513path.quadTo(7.82986f, 44.5308f, 7.44999f, 44.1833f);
8514path.conicTo(6.71217f, 43.5082f, 7.38718f, 42.7704f, 0.707107f);
8515path.conicTo(8.06219f, 42.0326f, 8.8f, 42.7076f, 0.707107f);
8516path.quadTo(9.15066f, 43.0284f, 9.51375f, 43.3351f);
8517path.conicTo(10.2777f, 43.9804f, 9.63248f, 44.7443f, 0.707107f);
8518path.conicTo(8.98724f, 45.5083f, 8.22326f, 44.8631f, 0.707107f);
8519path.close();
8520path.moveTo(5.95972f, 42.705f);
8521path.quadTo(5.59577f, 42.3136f, 5.24823f, 41.9076f);
8522path.conicTo(4.59793f, 41.148f, 5.3576f, 40.4977f, 0.707107f);
8523path.conicTo(6.11728f, 39.8473f, 6.76758f, 40.607f, 0.707107f);
8524path.quadTo(7.08843f, 40.9818f, 7.42436f, 41.3431f);
8525path.conicTo(8.10532f, 42.0754f, 7.373f, 42.7564f, 0.707107f);
8526path.conicTo(6.64068f, 43.4373f, 5.95972f, 42.705f, 0.707107f);
8527path.close();
8528path.moveTo(3.90635f, 40.2006f);
8529path.quadTo(3.59492f, 39.7684f, 3.30147f, 39.3239f);
8530path.conicTo(2.75055f, 38.4893f, 3.58511f, 37.9384f, 0.707107f);
8531path.conicTo(4.41967f, 37.3875f, 4.97059f, 38.222f, 0.707107f);
8532path.quadTo(5.24148f, 38.6324f, 5.52894f, 39.0313f);
8533path.conicTo(6.11358f, 39.8426f, 5.30228f, 40.4272f, 0.707107f);
8534path.conicTo(4.49099f, 41.0119f, 3.90635f, 40.2006f, 0.707107f);
8535path.close();
8536path.moveTo(2.23643f, 37.5626f);
8537path.quadTo(1.98525f, 37.1075f, 1.75248f, 36.6427f);
8538path.conicTo(1.30469f, 35.7486f, 2.19883f, 35.3008f, 0.707107f);
8539path.conicTo(3.09296f, 34.853f, 3.54076f, 35.7471f, 0.707107f);
8540path.quadTo(3.75563f, 36.1762f, 3.98747f, 36.5963f);
8541path.conicTo(4.47065f, 37.4718f, 3.59513f, 37.955f, 0.707107f);
8542path.conicTo(2.71961f, 38.4382f, 2.23643f, 37.5626f, 0.707107f);
8543path.close();
8544path.moveTo(0.890647f, 34.7334f);
8545path.quadTo(0.69328f, 34.2445f, 0.515902f, 33.7481f);
8546path.conicTo(0.179435f, 32.8064f, 1.12113f, 32.4699f, 0.707107f);
8547path.conicTo(2.06282f, 32.1335f, 2.39929f, 33.0752f, 0.707107f);
8548path.quadTo(2.56303f, 33.5334f, 2.74521f, 33.9847f);
8549path.conicTo(3.11957f, 34.912f, 2.19229f, 35.2863f, 0.707107f);
8550path.conicTo(1.26501f, 35.6607f, 0.890647f, 34.7334f, 0.707107f);
8551path.close();
8552path.moveTo(-0.114587f, 31.7274f);
8553path.quadTo(-0.251922f, 31.2147f, -0.368218f, 30.6968f);
8554path.conicTo(-0.587327f, 29.7211f, 0.388373f, 29.502f, 0.707107f);
8555path.conicTo(1.36407f, 29.2829f, 1.58318f, 30.2586f, 0.707107f);
8556path.quadTo(1.69053f, 30.7366f, 1.8173f, 31.2099f);
8557path.conicTo(2.07605f, 32.1758f, 1.1101f, 32.4346f, 0.707107f);
8558path.conicTo(0.144159f, 32.6933f, -0.114587f, 31.7274f, 0.707107f);
8559path.close();
8560path.moveTo(-0.745485f, 28.6291f);
8561path.quadTo(-0.818367f, 28.112f, -0.870432f, 27.5925f);
8562path.conicTo(-0.970142f, 26.5974f, 0.0248742f, 26.4977f, 0.707107f);
8563path.conicTo(1.01989f, 26.398f, 1.1196f, 27.393f, 0.707107f);
8564path.quadTo(1.16766f, 27.8726f, 1.23494f, 28.3499f);
8565path.conicTo(1.37452f, 29.3401f, 0.384305f, 29.4797f, 0.707107f);
8566path.conicTo(-0.605905f, 29.6193f, -0.745485f, 28.6291f, 0.707107f);
8567path.close();
8568path.moveTo(-0.994901f, 25.515f);
8569path.quadTo(-1.00519f, 24.9955f, -0.994722f, 24.4761f);
8570path.conicTo(-0.97457f, 23.4763f, 0.0252273f, 23.4964f, 0.707107f);
8571path.conicTo(1.02502f, 23.5166f, 1.00487f, 24.5164f, 0.707107f);
8572path.quadTo(0.995207f, 24.9959f, 1.00471f, 25.4754f);
8573path.conicTo(1.02451f, 26.4752f, 0.0247103f, 26.495f, 0.707107f);
8574path.conicTo(-0.975093f, 26.5148f, -0.994901f, 25.515f, 0.707107f);
8575path.close();
8576path.moveTo(-0.867571f, 22.3792f);
8577path.quadTo(-0.81506f, 21.8609f, -0.741825f, 21.3451f);
8578path.conicTo(-0.60125f, 20.355f, 0.38882f, 20.4956f, 0.707107f);
8579path.conicTo(1.37889f, 20.6361f, 1.23831f, 21.6262f, 0.707107f);
8580path.quadTo(1.17071f, 22.1023f, 1.12224f, 22.5807f);
8581path.conicTo(1.02144f, 23.5757f, 0.026537f, 23.4749f, 0.707107f);
8582path.conicTo(-0.96837f, 23.3741f, -0.867571f, 22.3792f, 0.707107f);
8583path.close();
8584path.moveTo(-0.369678f, 19.3097f);
8585path.quadTo(-0.249693f, 18.7748f, -0.107265f, 18.2453f);
8586path.conicTo(0.152529f, 17.2797f, 1.11819f, 17.5395f, 0.707107f);
8587path.conicTo(2.08386f, 17.7993f, 1.82406f, 18.7649f, 0.707107f);
8588path.quadTo(1.69259f, 19.2536f, 1.58184f, 19.7474f);
8589path.conicTo(1.36298f, 20.7232f, 0.387221f, 20.5043f, 0.707107f);
8590path.conicTo(-0.588536f, 20.2855f, -0.369678f, 19.3097f, 0.707107f);
8591path.close();
8592path.moveTo(0.539863f, 16.1851f);
8593path.quadTo(0.719962f, 15.6854f, 0.920307f, 15.1934f);
8594path.conicTo(1.29748f, 14.2673f, 2.22362f, 14.6445f, 0.707107f);
8595path.conicTo(3.14976f, 15.0216f, 2.7726f, 15.9478f, 0.707107f);
8596path.quadTo(2.58765f, 16.4019f, 2.42141f, 16.8632f);
8597path.conicTo(2.08237f, 17.804f, 1.1416f, 17.4649f, 0.707107f);
8598path.conicTo(0.200823f, 17.1259f, 0.539863f, 16.1851f, 0.707107f);
8599path.close();
8600path.moveTo(1.78353f, 13.2955f);
8601path.quadTo(2.01364f, 12.8391f, 2.26151f, 12.392f);
8602path.conicTo(2.74643f, 11.5175f, 3.62099f, 12.0024f, 0.707107f);
8603path.conicTo(4.49555f, 12.4873f, 4.01063f, 13.3618f, 0.707107f);
8604path.quadTo(3.78183f, 13.7745f, 3.56941f, 14.1958f);
8605path.conicTo(3.11923f, 15.0888f, 2.22629f, 14.6386f, 0.707107f);
8606path.conicTo(1.33336f, 14.1884f, 1.78353f, 13.2955f, 0.707107f);
8607path.close();
8608path.moveTo(3.30083f, 10.6771f);
8609path.lineTo(3.44218f, 10.4652f);
8610path.quadTo(3.6466f, 10.1621f, 3.85641f, 9.86895f);
8611path.conicTo(4.43837f, 9.05574f, 5.25159f, 9.6377f, 0.707107f);
8612path.conicTo(6.0648f, 10.2197f, 5.48284f, 11.0329f, 0.707107f);
8613path.quadTo(5.28917f, 11.3035f, 5.10592f, 11.5752f);
8614path.lineTo(4.96457f, 11.787f);
8615path.conicTo(4.4096f, 12.6189f, 3.57773f, 12.0639f, 0.707107f);
8616path.conicTo(2.74586f, 11.509f, 3.30083f, 10.6771f, 0.707107f);
8617path.close();
8618path.moveTo(5.0909f, 8.27793f);
8619path.quadTo(5.42174f, 7.88403f, 5.76791f, 7.50353f);
8620path.conicTo(6.44085f, 6.76383f, 7.18054f, 7.43678f, 0.707107f);
8621path.conicTo(7.92024f, 8.10972f, 7.24729f, 8.84942f, 0.707107f);
8622path.quadTo(6.92775f, 9.20065f, 6.62237f, 9.56424f);
8623path.conicTo(5.97921f, 10.33f, 5.21348f, 9.68682f, 0.707107f);
8624path.conicTo(4.44774f, 9.04367f, 5.0909f, 8.27793f, 0.707107f);
8625path.close();
8626path.moveTo(7.24064f, 6.0104f);
8627path.quadTo(7.63069f, 5.64561f, 8.03537f, 5.29717f);
8628path.conicTo(8.79318f, 4.64469f, 9.44566f, 5.40249f, 0.707107f);
8629path.conicTo(10.0981f, 6.16029f, 9.34034f, 6.81278f, 0.707107f);
8630path.quadTo(8.96678f, 7.13442f, 8.60675f, 7.47113f);
8631path.conicTo(7.87638f, 8.15419f, 7.19332f, 7.42382f, 0.707107f);
8632path.conicTo(6.51027f, 6.69345f, 7.24064f, 6.0104f, 0.707107f);
8633path.close();
8634path.moveTo(9.73726f, 3.95128f);
8635path.quadTo(10.1706f, 3.63704f, 10.6165f, 3.34092f);
8636path.conicTo(11.4496f, 2.78771f, 12.0028f, 3.62075f, 0.707107f);
8637path.conicTo(12.556f, 4.4538f, 11.7229f, 5.007f, 0.707107f);
8638path.quadTo(11.3113f, 5.28035f, 10.9113f, 5.57041f);
8639path.conicTo(10.1018f, 6.15744f, 9.51472f, 5.34787f, 0.707107f);
8640path.conicTo(8.92769f, 4.53831f, 9.73726f, 3.95128f, 0.707107f);
8641path.close();
8642path.moveTo(12.374f, 2.27153f);
8643path.quadTo(12.8282f, 2.01921f, 13.2921f, 1.78522f);
8644path.conicTo(14.185f, 1.33492f, 14.6353f, 2.22779f, 0.707107f);
8645path.conicTo(15.0856f, 3.12067f, 14.1927f, 3.57097f, 0.707107f);
8646path.quadTo(13.7645f, 3.78696f, 13.3452f, 4.01988f);
8647path.conicTo(12.471f, 4.5055f, 11.9854f, 3.63132f, 0.707107f);
8648path.conicTo(11.4998f, 2.75715f, 12.374f, 2.27153f, 0.707107f);
8649path.close();
8650path.moveTo(15.1984f, 0.918296f);
8651path.quadTo(15.6866f, 0.719602f, 16.1824f, 0.540851f);
8652path.conicTo(17.1231f, 0.20171f, 17.4623f, 1.14245f, 0.707107f);
8653path.conicTo(17.8014f, 2.08318f, 16.8607f, 2.42232f, 0.707107f);
8654path.quadTo(16.403f, 2.58733f, 15.9524f, 2.77074f);
8655path.conicTo(15.0261f, 3.14772f, 14.6492f, 2.2215f, 0.707107f);
8656path.conicTo(14.2722f, 1.29528f, 15.1984f, 0.918296f, 0.707107f);
8657path.close();
8658path.moveTo(18.201f, -0.0952874f);
8659path.quadTo(18.7132f, -0.234075f, 19.2308f, -0.351842f);
8660path.conicTo(20.2058f, -0.573734f, 20.4277f, 0.401338f, 0.707107f);
8661path.conicTo(20.6496f, 1.37641f, 19.6745f, 1.5983f, 0.707107f);
8662path.quadTo(19.1968f, 1.70701f, 18.724f, 1.83512f);
8663path.conicTo(17.7588f, 2.09662f, 17.4973f, 1.13142f, 0.707107f);
8664path.conicTo(17.2358f, 0.166216f, 18.201f, -0.0952874f, 0.707107f);
8665path.close();
8666path.moveTo(21.2986f, -0.73518f);
8667path.quadTo(21.8155f, -0.809526f, 22.3349f, -0.863052f);
8668path.conicTo(23.3297f, -0.965552f, 23.4322f, 0.029181f, 0.707107f);
8669path.conicTo(23.5347f, 1.02391f, 22.5399f, 1.12641f, 0.707107f);
8670path.quadTo(22.0604f, 1.17582f, 21.5833f, 1.24445f);
8671path.conicTo(20.5935f, 1.38681f, 20.4511f, 0.397f, 0.707107f);
8672path.conicTo(20.3088f, -0.592814f, 21.2986f, -0.73518f, 0.707107f);
8673path.close();
8674path.moveTo(24.4124f, -0.993361f);
8675path.quadTo(24.9312f, -1.00509f, 25.4501f, -0.996107f);
8676path.conicTo(26.4499f, -0.978799f, 26.4326f, 0.0210512f, 0.707107f);
8677path.conicTo(26.4153f, 1.0209f, 25.4155f, 1.00359f, 0.707107f);
8678path.quadTo(24.9365f, 0.995302f, 24.4576f, 1.00613f);
8679path.conicTo(23.4578f, 1.02873f, 23.4352f, 0.0289853f, 0.707107f);
8680path.conicTo(23.4126f, -0.970759f, 24.4124f, -0.993361f, 0.707107f);
8681path.close();
8682path.moveTo(27.5481f, -0.87484f);
8683path.quadTo(28.0668f, -0.823762f, 28.583f, -0.75194f);
8684path.conicTo(29.5734f, -0.614138f, 29.4356f, 0.376322f, 0.707107f);
8685path.conicTo(29.2978f, 1.36678f, 28.3074f, 1.22898f, 0.707107f);
8686path.quadTo(27.8309f, 1.16268f, 27.3521f, 1.11553f);
8687path.conicTo(26.3569f, 1.01753f, 26.4549f, 0.0223428f, 0.707107f);
8688path.conicTo(26.5529f, -0.972843f, 27.5481f, -0.87484f, 0.707107f);
8689path.close();
8690path.moveTo(30.6151f, -0.386432f);
8691path.quadTo(31.1507f, -0.267954f, 31.6809f, -0.126991f);
8692path.conicTo(32.6473f, 0.129965f, 32.3904f, 1.09639f, 0.707107f);
8693path.conicTo(32.1334f, 2.06281f, 31.167f, 1.80585f, 0.707107f);
8694path.quadTo(30.6776f, 1.67574f, 30.1832f, 1.56637f);
8695path.conicTo(29.2068f, 1.35041f, 29.4227f, 0.374005f, 0.707107f);
8696path.conicTo(29.6387f, -0.602396f, 30.6151f, -0.386432f, 0.707107f);
8697path.close();
8698path.moveTo(33.7445f, 0.514616f);
8699path.quadTo(34.2452f, 0.693421f, 34.7381f, 0.892536f);
8700path.conicTo(35.6653f, 1.26708f, 35.2908f, 2.19429f, 0.707107f);
8701path.conicTo(34.9162f, 3.1215f, 33.989f, 2.74696f, 0.707107f);
8702path.quadTo(33.534f, 2.56316f, 33.0718f, 2.3981f);
8703path.conicTo(32.1301f, 2.06177f, 32.4664f, 1.12003f, 0.707107f);
8704path.conicTo(32.8027f, 0.178285f, 33.7445f, 0.514616f, 0.707107f);
8705path.close();
8706path.moveTo(36.6402f, 1.7512f);
8707path.quadTo(37.0977f, 1.98026f, 37.5458f, 2.22715f);
8708path.conicTo(38.4217f, 2.70968f, 37.9392f, 3.58556f, 0.707107f);
8709path.conicTo(37.4566f, 4.46144f, 36.5808f, 3.97891f, 0.707107f);
8710path.quadTo(36.1671f, 3.75102f, 35.7448f, 3.53956f);
8711path.conicTo(34.8506f, 3.09185f, 35.2983f, 2.19767f, 0.707107f);
8712path.conicTo(35.746f, 1.30349f, 36.6402f, 1.7512f, 0.707107f);
8713path.close();
8714path.moveTo(39.2611f, 3.26012f);
8715path.quadTo(39.4005f, 3.35159f, 39.539f, 3.44501f);
8716path.quadTo(39.8091f, 3.62717f, 40.0746f, 3.81611f);
8717path.conicTo(40.8893f, 4.3959f, 40.3096f, 5.21067f, 0.707107f);
8718path.conicTo(39.7298f, 6.02543f, 38.915f, 5.44564f, 0.707107f);
8719path.quadTo(38.67f, 5.2713f, 38.4206f, 5.10309f);
8720path.quadTo(38.293f, 5.017f, 38.164f, 4.9324f);
8721path.conicTo(37.3279f, 4.38388f, 37.8764f, 3.54775f, 0.707107f);
8722path.conicTo(38.4249f, 2.71161f, 39.2611f, 3.26012f, 0.707107f);
8723path.close();
8724path.moveTo(41.6673f, 5.04503f);
8725path.quadTo(42.0618f, 5.37449f, 42.4428f, 5.71927f);
8726path.conicTo(43.1844f, 6.39015f, 42.5135f, 7.13171f, 0.707107f);
8727path.conicTo(41.8426f, 7.87327f, 41.1011f, 7.20239f, 0.707107f);
8728path.quadTo(40.7493f, 6.88414f, 40.3852f, 6.58004f);
8729path.conicTo(39.6177f, 5.93899f, 40.2588f, 5.17149f, 0.707107f);
8730path.conicTo(40.8998f, 4.40399f, 41.6673f, 5.04503f, 0.707107f);
8731path.close();
8732path.moveTo(43.9388f, 7.1865f);
8733path.quadTo(44.3044f, 7.57519f, 44.6538f, 7.97856f);
8734path.conicTo(45.3084f, 8.73448f, 44.5525f, 9.38914f, 0.707107f);
8735path.conicTo(43.7966f, 10.0438f, 43.1419f, 9.28789f, 0.707107f);
8736path.quadTo(42.8195f, 8.91555f, 42.482f, 8.55677f);
8737path.conicTo(41.7969f, 7.82836f, 42.5253f, 7.14322f, 0.707107f);
8738path.conicTo(43.2537f, 6.45808f, 43.9388f, 7.1865f, 0.707107f);
8739path.close();
8740path.moveTo(46.0036f, 9.6753f);
8741path.quadTo(46.3207f, 10.1098f, 46.6195f, 10.5571f);
8742path.conicTo(47.175f, 11.3886f, 46.3435f, 11.9441f, 0.707107f);
8743path.conicTo(45.5119f, 12.4996f, 44.9564f, 11.6681f, 0.707107f);
8744path.quadTo(44.6806f, 11.2552f, 44.388f, 10.8541f);
8745path.conicTo(43.7986f, 10.0463f, 44.6064f, 9.45688f, 0.707107f);
8746path.conicTo(45.4142f, 8.86747f, 46.0036f, 9.6753f, 0.707107f);
8747path.close();
8748path.moveTo(47.6932f, 12.3107f);
8749path.quadTo(47.9467f, 12.764f, 48.1819f, 13.2271f);
8750path.conicTo(48.6347f, 14.1187f, 47.7431f, 14.5715f, 0.707107f);
8751path.conicTo(46.8514f, 15.0243f, 46.3986f, 14.1327f, 0.707107f);
8752path.quadTo(46.1816f, 13.7053f, 45.9476f, 13.2868f);
8753path.conicTo(45.4595f, 12.414f, 46.3323f, 11.9259f, 0.707107f);
8754path.conicTo(47.2051f, 11.4379f, 47.6932f, 12.3107f, 0.707107f);
8755path.close();
8756path.moveTo(49.0539f, 15.1303f);
8757path.quadTo(49.2539f, 15.6178f, 49.434f, 16.113f);
8758path.conicTo(49.7758f, 17.0527f, 48.836f, 17.3946f, 0.707107f);
8759path.conicTo(47.8963f, 17.7364f, 47.5545f, 16.7966f, 0.707107f);
8760path.quadTo(47.3882f, 16.3395f, 47.2036f, 15.8895f);
8761path.conicTo(46.824f, 14.9643f, 47.7491f, 14.5847f, 0.707107f);
8762path.conicTo(48.6743f, 14.2051f, 49.0539f, 15.1303f, 0.707107f);
8763path.close();
8764path.moveTo(50.0758f, 18.1294f);
8765path.quadTo(50.216f, 18.6412f, 50.3352f, 19.1584f);
8766path.conicTo(50.5599f, 20.1328f, 49.5855f, 20.3575f, 0.707107f);
8767path.conicTo(48.6111f, 20.5821f, 48.3864f, 19.6077f, 0.707107f);
8768path.quadTo(48.2763f, 19.1304f, 48.1469f, 18.6579f);
8769path.conicTo(47.8826f, 17.6935f, 48.8471f, 17.4292f, 0.707107f);
8770path.conicTo(49.8115f, 17.165f, 50.0758f, 18.1294f, 0.707107f);
8771path.close();
8772path.moveTo(50.7247f, 21.2262f);
8773path.quadTo(50.8005f, 21.743f, 50.8555f, 22.2623f);
8774path.conicTo(50.9607f, 23.2568f, 49.9663f, 23.3621f, 0.707107f);
8775path.conicTo(48.9719f, 23.4673f, 48.8666f, 22.4729f, 0.707107f);
8776path.quadTo(48.8158f, 21.9935f, 48.7458f, 21.5165f);
8777path.conicTo(48.6007f, 20.5271f, 49.5901f, 20.382f, 0.707107f);
8778path.conicTo(50.5795f, 20.2368f, 50.7247f, 21.2262f, 0.707107f);
8779path.close();
8780path.moveTo(50.9916f, 24.3398f);
8781path.quadTo(51.0048f, 24.858f, 50.9973f, 25.3762f);
8782path.conicTo(50.9828f, 26.3761f, 49.9829f, 26.3616f, 0.707107f);
8783path.conicTo(48.983f, 26.3472f, 48.9975f, 25.3473f, 0.707107f);
8784path.quadTo(49.0044f, 24.8687f, 48.9923f, 24.3906f);
8785path.conicTo(48.9669f, 23.3909f, 49.9665f, 23.3655f, 0.707107f);
8786path.conicTo(50.9662f, 23.3401f, 50.9916f, 24.3398f, 0.707107f);
8787path.close();
8788path.moveTo(50.8819f, 27.4753f);
8789path.quadTo(50.8323f, 27.9943f, 50.7618f, 28.511f);
8790path.conicTo(50.6268f, 29.5018f, 49.636f, 29.3668f, 0.707107f);
8791path.conicTo(48.6451f, 29.2317f, 48.7802f, 28.2409f, 0.707107f);
8792path.quadTo(48.8452f, 27.7641f, 48.891f, 27.2849f);
8793path.conicTo(48.9862f, 26.2894f, 49.9816f, 26.3846f, 0.707107f);
8794path.conicTo(50.9771f, 26.4798f, 50.8819f, 27.4753f, 0.707107f);
8795path.close();
8796path.moveTo(50.4023f, 30.5429f);
8797path.quadTo(50.2856f, 31.0775f, 50.1465f, 31.607f);
8798path.conicTo(49.8924f, 32.5742f, 48.9252f, 32.3201f, 0.707107f);
8799path.conicTo(47.9581f, 32.066f, 48.2122f, 31.0988f, 0.707107f);
8800path.quadTo(48.3405f, 30.6102f, 48.4483f, 30.1165f);
8801path.conicTo(48.6614f, 29.1395f, 49.6385f, 29.3527f, 0.707107f);
8802path.conicTo(50.6155f, 29.5659f, 50.4023f, 30.5429f, 0.707107f);
8803path.close();
8804path.moveTo(49.5104f, 33.674f);
8805path.quadTo(49.3329f, 34.1756f, 49.1351f, 34.6695f);
8806path.conicTo(48.7632f, 35.5977f, 47.8349f, 35.2258f, 0.707107f);
8807path.conicTo(46.9066f, 34.854f, 47.2785f, 33.9257f, 0.707107f);
8808path.quadTo(47.4612f, 33.4697f, 47.625f, 33.0067f);
8809path.conicTo(47.9587f, 32.064f, 48.9014f, 32.3977f, 0.707107f);
8810path.conicTo(49.8441f, 32.7313f, 49.5104f, 33.674f, 0.707107f);
8811path.close();
8812path.moveTo(48.281f, 36.5756f);
8813path.quadTo(48.053f, 37.0342f, 47.8071f, 37.4835f);
8814path.conicTo(47.3269f, 38.3607f, 46.4497f, 37.8805f, 0.707107f);
8815path.conicTo(45.5725f, 37.4004f, 46.0527f, 36.5232f, 0.707107f);
8816path.quadTo(46.2797f, 36.1085f, 46.4901f, 35.6852f);
8817path.conicTo(46.9353f, 34.7898f, 47.8307f, 35.235f, 0.707107f);
8818path.conicTo(48.7262f, 35.6802f, 48.281f, 36.5756f, 0.707107f);
8819path.close();
8820path.moveTo(46.7777f, 39.2033f);
8821path.quadTo(46.6677f, 39.3719f, 46.555f, 39.539f);
8822path.quadTo(46.3865f, 39.7888f, 46.2121f, 40.0349f);
8823path.conicTo(45.6338f, 40.8507f, 44.818f, 40.2724f, 0.707107f);
8824path.conicTo(44.0021f, 39.6942f, 44.5804f, 38.8783f, 0.707107f);
8825path.quadTo(44.7413f, 38.6513f, 44.8969f, 38.4206f);
8826path.quadTo(45.0008f, 38.2665f, 45.1025f, 38.1107f);
8827path.conicTo(45.6488f, 37.2731f, 46.4864f, 37.8194f, 0.707107f);
8828path.conicTo(47.324f, 38.3657f, 46.7777f, 39.2033f, 0.707107f);
8829path.close();
8830path.moveTo(44.9527f, 41.6701f);
8831path.quadTo(44.6177f, 42.0709f, 44.267f, 42.458f);
8832path.conicTo(43.5955f, 43.1991f, 42.8545f, 42.5276f, 0.707107f);
8833path.conicTo(42.1135f, 41.8561f, 42.7849f, 41.1151f, 0.707107f);
8834path.quadTo(43.1087f, 40.7578f, 43.4178f, 40.3878f);
8835path.conicTo(44.059f, 39.6203f, 44.8264f, 40.2615f, 0.707107f);
8836path.conicTo(45.5938f, 40.9027f, 44.9527f, 41.6701f, 0.707107f);
8837path.close();
8838path.moveTo(42.7884f, 43.9624f);
8839path.quadTo(42.4083f, 44.319f, 42.014f, 44.6602f);
8840path.conicTo(41.2578f, 45.3146f, 40.6034f, 44.5585f, 0.707107f);
8841path.conicTo(39.949f, 43.8023f, 40.7052f, 43.1479f, 0.707107f);
8842path.quadTo(41.0691f, 42.833f, 41.4201f, 42.5037f);
8843path.conicTo(42.1494f, 41.8196f, 42.8336f, 42.5489f, 0.707107f);
8844path.conicTo(43.5178f, 43.2782f, 42.7884f, 43.9624f, 0.707107f);
8845path.close();
8846path.moveTo(40.3892f, 45.9564f);
8847path.quadTo(39.9683f, 46.2655f, 39.5354f, 46.5574f);
8848path.conicTo(38.7062f, 47.1165f, 38.1472f, 46.2873f, 0.707107f);
8849path.conicTo(37.5881f, 45.4582f, 38.4173f, 44.8992f, 0.707107f);
8850path.quadTo(38.8169f, 44.6297f, 39.2054f, 44.3444f);
8851path.conicTo(40.0114f, 43.7525f, 40.6033f, 44.5585f, 0.707107f);
8852path.conicTo(41.1952f, 45.3645f, 40.3892f, 45.9564f, 0.707107f);
8853path.close();
8854path.moveTo(37.7543f, 47.6568f);
8855path.quadTo(37.2977f, 47.9138f, 36.8312f, 48.1522f);
8856path.conicTo(35.9407f, 48.6072f, 35.4857f, 47.7167f, 0.707107f);
8857path.conicTo(35.0306f, 46.8263f, 35.9211f, 46.3712f, 0.707107f);
8858path.quadTo(36.3518f, 46.1511f, 36.7732f, 45.9139f);
8859path.conicTo(37.6446f, 45.4234f, 38.1351f, 46.2948f, 0.707107f);
8860path.conicTo(38.6257f, 47.1662f, 37.7543f, 47.6568f, 0.707107f);
8861path.close();
8862path.moveTo(34.9311f, 49.0286f);
8863path.quadTo(34.4488f, 49.2279f, 33.9589f, 49.4077f);
8864path.conicTo(33.0202f, 49.7523f, 32.6756f, 48.8136f, 0.707107f);
8865path.conicTo(32.331f, 47.8748f, 33.2698f, 47.5302f, 0.707107f);
8866path.quadTo(33.722f, 47.3642f, 34.1672f, 47.1802f);
8867path.conicTo(35.0914f, 46.7983f, 35.4733f, 47.7224f, 0.707107f);
8868path.conicTo(35.8553f, 48.6466f, 34.9311f, 49.0286f, 0.707107f);
8869path.close();
8870path.moveTo(31.9824f, 50.0449f);
8871path.quadTo(31.4774f, 50.1857f, 30.9668f, 50.3061f);
8872path.conicTo(29.9935f, 50.5355f, 29.764f, 49.5622f, 0.707107f);
8873path.conicTo(29.5346f, 48.5889f, 30.5079f, 48.3594f, 0.707107f);
8874path.quadTo(30.9789f, 48.2484f, 31.4453f, 48.1184f);
8875path.conicTo(32.4086f, 47.8498f, 32.6771f, 48.8131f, 0.707107f);
8876path.conicTo(32.9457f, 49.7763f, 31.9824f, 50.0449f, 0.707107f);
8877path.close();
8878path.moveTo(28.899f, 50.706f);
8879path.quadTo(28.3834f, 50.7842f, 27.8652f, 50.8416f);
8880path.conicTo(26.8713f, 50.9518f, 26.7611f, 49.9579f, 0.707107f);
8881path.conicTo(26.6509f, 48.964f, 27.6448f, 48.8538f, 0.707107f);
8882path.quadTo(28.1231f, 48.8008f, 28.599f, 48.7286f);
8883path.conicTo(29.5877f, 48.5786f, 29.7377f, 49.5673f, 0.707107f);
8884path.conicTo(29.8877f, 50.556f, 28.899f, 50.706f, 0.707107f);
8885path.close();
8886path.moveTo(25.8106f, 50.9874f);
8887path.quadTo(25.6321f, 50.9929f, 25.4537f, 50.996f);
8888path.conicTo(24.4539f, 51.0135f, 24.4365f, 50.0136f, 0.707115f);
8889path.lineTo(24.4251f, 49.3638f);
8890path.conicTo(24.4077f, 48.364f, 25.4075f, 48.3465f, 0.707107f);
8891path.conicTo(26.4073f, 48.3291f, 26.4248f, 49.3289f, 0.707107f);
8892path.lineTo(26.4361f, 49.9787f);
8893path.lineTo(25.4363f, 49.9962f);
8894path.lineTo(25.4189f, 48.9963f);
8895path.quadTo(25.5836f, 48.9935f, 25.7482f, 48.9883f);
8896path.conicTo(26.7477f, 48.9571f, 26.7789f, 49.9567f, 0.707107f);
8897path.conicTo(26.8101f, 50.9562f, 25.8106f, 50.9874f, 0.707107f);
8898path.close();
8899path.moveTo(24.3902f, 47.3641f);
8900path.lineTo(24.3728f, 46.3643f);
8901path.conicTo(24.3553f, 45.3645f, 25.3551f, 45.347f, 0.707107f);
8902path.conicTo(26.355f, 45.3295f, 26.3724f, 46.3294f, 0.707107f);
8903path.lineTo(26.3899f, 47.3292f);
8904path.conicTo(26.4074f, 48.3291f, 25.4075f, 48.3465f, 0.707107f);
8905path.conicTo(24.4077f, 48.364f, 24.3902f, 47.3641f, 0.707107f);
8906path.close();
8907path.moveTo(24.3378f, 44.3646f);
8908path.lineTo(24.3204f, 43.3648f);
8909path.conicTo(24.3029f, 42.3649f, 25.3028f, 42.3475f, 0.707107f);
8910path.conicTo(26.3026f, 42.33f, 26.3201f, 43.3298f, 0.707107f);
8911path.lineTo(26.3375f, 44.3297f);
8912path.conicTo(26.355f, 45.3295f, 25.3551f, 45.347f, 0.707107f);
8913path.conicTo(24.3553f, 45.3645f, 24.3378f, 44.3646f, 0.707107f);
8914path.close();
8915path.moveTo(24.2855f, 41.3651f);
8916path.lineTo(24.268f, 40.3652f);
8917path.conicTo(24.2506f, 39.3654f, 25.2504f, 39.3479f, 0.707107f);
8918path.conicTo(26.2503f, 39.3305f, 26.2677f, 40.3303f, 0.707107f);
8919path.lineTo(26.2852f, 41.3302f);
8920path.conicTo(26.3026f, 42.33f, 25.3028f, 42.3475f, 0.707107f);
8921path.conicTo(24.3029f, 42.3649f, 24.2855f, 41.3651f, 0.707107f);
8922path.close();
8923path.moveTo(24.2331f, 38.3655f);
8924path.lineTo(24.2157f, 37.3657f);
8925path.conicTo(24.1982f, 36.3658f, 25.1981f, 36.3484f, 0.707107f);
8926path.conicTo(26.1979f, 36.3309f, 26.2154f, 37.3308f, 0.707107f);
8927path.lineTo(26.2328f, 38.3306f);
8928path.conicTo(26.2503f, 39.3305f, 25.2504f, 39.3479f, 0.707107f);
8929path.conicTo(24.2506f, 39.3654f, 24.2331f, 38.3655f, 0.707107f);
8930path.close();
8931path.moveTo(24.1808f, 35.366f);
8932path.lineTo(24.1633f, 34.3661f);
8933path.conicTo(24.1459f, 33.3663f, 25.1457f, 33.3488f, 0.707107f);
8934path.conicTo(26.1456f, 33.3314f, 26.163f, 34.3312f, 0.707107f);
8935path.lineTo(26.1805f, 35.3311f);
8936path.conicTo(26.1979f, 36.3309f, 25.1981f, 36.3484f, 0.707107f);
8937path.conicTo(24.1982f, 36.3658f, 24.1808f, 35.366f, 0.707107f);
8938path.close();
8939path.moveTo(24.1284f, 32.3664f);
8940path.lineTo(24.111f, 31.3666f);
8941path.conicTo(24.0935f, 30.3667f, 25.0934f, 30.3493f, 0.707107f);
8942path.conicTo(26.0932f, 30.3318f, 26.1107f, 31.3317f, 0.707107f);
8943path.lineTo(26.1281f, 32.3315f);
8944path.conicTo(26.1456f, 33.3314f, 25.1457f, 33.3488f, 0.707107f);
8945path.conicTo(24.1459f, 33.3663f, 24.1284f, 32.3664f, 0.707107f);
8946path.close();
8947path.moveTo(24.0761f, 29.3669f);
8948path.lineTo(24.0586f, 28.367f);
8949path.conicTo(24.0412f, 27.3672f, 25.041f, 27.3497f, 0.707107f);
8950path.conicTo(26.0409f, 27.3323f, 26.0583f, 28.3321f, 0.707107f);
8951path.lineTo(26.0758f, 29.332f);
8952path.conicTo(26.0932f, 30.3318f, 25.0934f, 30.3493f, 0.707107f);
8953path.conicTo(24.0935f, 30.3667f, 24.0761f, 29.3669f, 0.707107f);
8954path.close();
8955path.moveTo(24.0237f, 26.3673f);
8956path.lineTo(24.0063f, 25.3675f);
8957path.conicTo(23.9888f, 24.3676f, 24.9887f, 24.3502f, 0.707107f);
8958path.conicTo(25.9885f, 24.3327f, 26.006f, 25.3326f, 0.707107f);
8959path.lineTo(26.0234f, 26.3324f);
8960path.conicTo(26.0409f, 27.3323f, 25.041f, 27.3497f, 0.707107f);
8961path.conicTo(24.0412f, 27.3672f, 24.0237f, 26.3673f, 0.707107f);
8962path.close();
8963 testPathOpFail(reporter, path, path1, kXOR_SkPathOp, filename);
8964}
testPathOpFail
bool testPathOpFail(skiatest::Reporter *reporter, const SkPath &a, const SkPath &b, const SkPathOp shapeOp, const char *testName)
Definition PathOpsExtendedTest.cpp:636

◆ halbug()

static void halbug ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5743 of file PathOpsOpTest.cpp.

5743 {
5744 SkPath path, path2;
5745 path.setFillType(SkPathFillType::kEvenOdd);
5746 path.addRect(SkRect{278.653992f, 155.747406f, 580.15918f, 593.602051f});
5747 path2.setFillType(SkPathFillType::kWinding);
5748 path2.addRect(SkRect{278.657715f, 155.747314f, 580.238281f, 594.114014f});
5749 testPathOp(reporter, path, path2, kIntersect_SkPathOp, filename);
5750}

◆ issue1417()

static void issue1417 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1863 of file PathOpsOpTest.cpp.

1863 {
1864 SkPath path1;
1865 path1.moveTo(122.58908843994140625f, 82.2836456298828125f);
1866 path1.quadTo(129.8215789794921875f, 80, 138, 80);
1867 path1.quadTo(147.15692138671875f, 80, 155.1280364990234375f, 82.86279296875f);
1868 path1.lineTo(161.1764678955078125f, 100);
1869 path1.lineTo(161.1764678955078125f, 100);
1870 path1.lineTo(115.29412078857421875f, 100);
1871 path1.lineTo(115.29412078857421875f, 100);
1872 path1.lineTo(122.58908843994140625f, 82.2836456298828125f);
1873 path1.lineTo(122.58908843994140625f, 82.2836456298828125f);
1874 path1.close();
1875 path1.moveTo(98.68194580078125f, 140.343841552734375f);
1876 path1.lineTo(115.29412078857421875f, 100);
1877 path1.lineTo(115.29412078857421875f, 100);
1878 path1.lineTo(97.9337615966796875f, 100);
1879 path1.lineTo(97.9337615966796875f, 100);
1880 path1.quadTo(88, 112.94264984130859375f, 88, 130);
1881 path1.quadTo(88, 131.544830322265625f, 88.08148956298828125f, 133.0560302734375f);
1882 path1.lineTo(98.68194580078125f, 140.343841552734375f);
1883 path1.lineTo(98.68194580078125f, 140.343841552734375f);
1884 path1.close();
1885 path1.moveTo(136.969696044921875f, 166.6666717529296875f);
1886 path1.lineTo(98.68194580078125f, 140.343841552734375f);
1887 path1.lineTo(98.68194580078125f, 140.343841552734375f);
1888 path1.lineTo(93.45894622802734375f, 153.02825927734375f);
1889 path1.lineTo(93.45894622802734375f, 153.02825927734375f);
1890 path1.quadTo(96.94116973876953125f, 159.65185546875f, 102.64466094970703125f, 165.3553466796875f);
1891 path1.quadTo(110.7924652099609375f, 173.503143310546875f, 120.8179779052734375f, 177.1177825927734375f);
1892 path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1893 path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1894 path1.close();
1895 path1.moveTo(175.8309783935546875f, 141.5211334228515625f);
1896 path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1897 path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1898 path1.lineTo(153.15728759765625f, 177.7956390380859375f);
1899 path1.lineTo(153.15728759765625f, 177.7956390380859375f);
1900 path1.quadTo(164.392425537109375f, 174.318267822265625f, 173.3553466796875f, 165.3553466796875f);
1901 path1.quadTo(177.805816650390625f, 160.9048614501953125f, 180.90380859375f, 155.8941650390625f);
1902 path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1903 path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1904 path1.close();
1905 path1.moveTo(175.8309783935546875f, 141.5211334228515625f);
1906 path1.lineTo(187.8782806396484375f, 133.7258148193359375f);
1907 path1.lineTo(187.8782806396484375f, 133.7258148193359375f);
1908 path1.quadTo(188, 131.8880615234375f, 188, 130);
1909 path1.quadTo(188, 112.942657470703125f, 178.0662384033203125f, 100);
1910 path1.lineTo(161.1764678955078125f, 100);
1911 path1.lineTo(161.1764678955078125f, 100);
1912 path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1913 path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1914 path1.close();
1915
1916 SkPath path2;
1917 path2.moveTo(174.117645263671875f, 100);
1918 path2.lineTo(161.1764678955078125f, 100);
1919 path2.lineTo(161.1764678955078125f, 100);
1920 path2.lineTo(155.1280364990234375f, 82.86279296875f);
1921 path2.lineTo(155.1280364990234375f, 82.86279296875f);
1922 path2.quadTo(153.14971923828125f, 82.15229034423828125f, 151.098419189453125f, 81.618133544921875f);
1923 path2.lineTo(143.5294189453125f, 100);
1924 path2.lineTo(143.5294189453125f, 100);
1925 path2.lineTo(161.1764678955078125f, 100);
1926 path2.lineTo(161.1764678955078125f, 100);
1927 path2.lineTo(168.23529052734375f, 120);
1928 path2.lineTo(168.23529052734375f, 120);
1929 path2.lineTo(181.1764678955078125f, 120);
1930 path2.lineTo(181.1764678955078125f, 120);
1931 path2.lineTo(186.3661956787109375f, 134.7042236328125f);
1932 path2.lineTo(186.3661956787109375f, 134.7042236328125f);
1933 path2.lineTo(187.8782806396484375f, 133.7258148193359375f);
1934 path2.lineTo(187.8782806396484375f, 133.7258148193359375f);
1935 path2.quadTo(188, 131.8880615234375f, 188, 130);
1936 path2.quadTo(188, 124.80947113037109375f, 187.080169677734375f, 120);
1937 path2.lineTo(181.1764678955078125f, 120);
1938 path2.lineTo(181.1764678955078125f, 120);
1939 path2.lineTo(174.117645263671875f, 100);
1940 path2.lineTo(174.117645263671875f, 100);
1941 path2.close();
1942 path2.moveTo(88.91983795166015625f, 120);
1943 path2.lineTo(107.0588226318359375f, 120);
1944 path2.lineTo(107.0588226318359375f, 120);
1945 path2.lineTo(98.68194580078125f, 140.343841552734375f);
1946 path2.lineTo(98.68194580078125f, 140.343841552734375f);
1947 path2.lineTo(88.08148956298828125f, 133.0560302734375f);
1948 path2.lineTo(88.08148956298828125f, 133.0560302734375f);
1949 path2.quadTo(88, 131.544830322265625f, 88, 130);
1950 path2.quadTo(88, 124.80951690673828125f, 88.91983795166015625f, 120);
1951 path2.close();
1952 path2.moveTo(96.67621612548828125f, 145.21490478515625f);
1953 path2.lineTo(98.68194580078125f, 140.343841552734375f);
1954 path2.lineTo(98.68194580078125f, 140.343841552734375f);
1955 path2.lineTo(120.68767547607421875f, 155.4727783203125f);
1956 path2.lineTo(120.68767547607421875f, 155.4727783203125f);
1957 path2.lineTo(118.68194580078125f, 160.343841552734375f);
1958 path2.lineTo(118.68194580078125f, 160.343841552734375f);
1959 path2.lineTo(96.67621612548828125f, 145.21490478515625f);
1960 path2.lineTo(96.67621612548828125f, 145.21490478515625f);
1961 path2.close();
1962 path2.moveTo(113.232177734375f, 173.5789947509765625f);
1963 path2.quadTo(116.8802642822265625f, 175.69805908203125f, 120.8179779052734375f, 177.1177825927734375f);
1964 path2.lineTo(132.2864990234375f, 169.6969757080078125f);
1965 path2.lineTo(132.2864990234375f, 169.6969757080078125f);
1966 path2.lineTo(118.68194580078125f, 160.343841552734375f);
1967 path2.lineTo(118.68194580078125f, 160.343841552734375f);
1968 path2.lineTo(113.232177734375f, 173.5789947509765625f);
1969 path2.lineTo(113.232177734375f, 173.5789947509765625f);
1970 path2.close();
1971 // FIXME : difficult data, circle back later
1972 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename);
1973}

◆ issue1418()

static void issue1418 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1975 of file PathOpsOpTest.cpp.

1975 {
1976 SkPath path1;
1977 path1.moveTo(0, 0);
1978 path1.lineTo(1, 0);
1979 path1.lineTo(1, 0);
1980 path1.lineTo(1, 1);
1981 path1.lineTo(1, 1);
1982 path1.lineTo(0, 1);
1983 path1.lineTo(0, 1);
1984 path1.lineTo(0, 0);
1985 path1.lineTo(0, 0);
1986 path1.close();
1987
1988 SkPath path2;
1989 path2.moveTo(0.64644664525985717773f, -0.35355341434478759766f);
1990 path2.quadTo(0.79289329051971435547f, -0.50000005960464477539f, 1.0000001192092895508f, -0.50000005960464477539f);
1991 path2.quadTo(1.2071068286895751953f, -0.50000005960464477539f, 1.3535535335540771484f, -0.35355341434478759766f);
1992 path2.quadTo(1.5000001192092895508f, -0.20710679888725280762f, 1.5000001192092895508f, 0);
1993 path2.quadTo(1.5000001192092895508f, 0.20710679888725280762f, 1.3535535335540771484f, 0.35355341434478759766f);
1994 path2.quadTo(1.2071068286895751953f, 0.50000005960464477539f, 1.0000001192092895508f, 0.50000005960464477539f);
1995 path2.quadTo(0.79289329051971435547f, 0.50000005960464477539f, 0.64644664525985717773f, 0.35355341434478759766f);
1996 path2.quadTo(0.50000005960464477539f, 0.20710679888725280762f, 0.50000005960464477539f, 0);
1997 path2.quadTo(0.50000005960464477539f, -0.20710679888725280762f, 0.64644664525985717773f, -0.35355341434478759766f);
1998 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename);
1999}

◆ issue1418b()

static void issue1418b ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2014 of file PathOpsOpTest.cpp.

2014 {
2015 SkPath path1;
2016 path1.moveTo(0, 0);
2017 path1.lineTo(1, 0);
2018 path1.lineTo(1, 1);
2019 path1.lineTo(0, 1);
2020 path1.lineTo(0, 0);
2021 path1.close();
2022 path1.setFillType(SkPathFillType::kWinding);
2023 SkPath path2;
2024 path2.moveTo(0.646446645f, -0.353553414f);
2025 path2.quadTo(0.792893291f, -0.50000006f, 1.00000012f, -0.50000006f);
2026 path2.quadTo(1.20710683f, -0.50000006f, 1.35355353f, -0.353553414f);
2027 path2.quadTo(1.50000012f, -0.207106799f, 1.50000012f, 0);
2028 path2.quadTo(1.50000012f, 0.207106799f, 1.35355353f, 0.353553414f);
2029 path2.quadTo(1.20710683f, 0.50000006f, 1.00000012f, 0.50000006f);
2030 path2.quadTo(0.792893291f, 0.50000006f, 0.646446645f, 0.353553414f);
2031 path2.quadTo(0.50000006f, 0.207106799f, 0.50000006f, 0);
2032 path2.quadTo(0.50000006f, -0.207106799f, 0.646446645f, -0.353553414f);
2033 path2.close();
2034 path2.moveTo(1.00000012f, 0.50000006f);
2035 path2.lineTo(1.00000012f, 1.00000012f);
2036 path2.lineTo(0.50000006f, 1.00000012f);
2037 path2.quadTo(0.50000006f, 0.792893291f, 0.646446645f, 0.646446645f);
2038 path2.quadTo(0.792893291f, 0.50000006f, 1.00000012f, 0.50000006f);
2039 path2.close();
2040 path2.setFillType(SkPathFillType::kEvenOdd);
2041 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename);
2042}

◆ issue1435()

static void issue1435 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2093 of file PathOpsOpTest.cpp.

2093 {
2094 SkPath path1;
2095 path1.moveTo(160, 60);
2096 path1.lineTo(220, 230);
2097 path1.lineTo(60, 120);
2098 path1.lineTo(260, 120);
2099 path1.lineTo(90, 230);
2100 path1.lineTo(160, 60);
2101 path1.close();
2102 path1.setFillType(SkPathFillType::kEvenOdd);
2103
2104 SkPath path2;
2105 path2.moveTo(142.589081f, 102.283646f);
2106 path2.quadTo(149.821579f, 100, 158, 100);
2107 path2.quadTo(167.156921f, 100, 175.128036f, 102.862793f);
2108 path2.lineTo(181.176468f, 120);
2109 path2.lineTo(135.294128f, 120);
2110 path2.lineTo(142.589081f, 102.283646f);
2111 path2.close();
2112 path2.moveTo(118.681946f, 160.343842f);
2113 path2.lineTo(135.294128f, 120);
2114 path2.lineTo(117.933762f, 120);
2115 path2.quadTo(108, 132.942657f, 108, 150);
2116 path2.quadTo(108, 151.54483f, 108.08149f, 153.05603f);
2117 path2.lineTo(118.681946f, 160.343842f);
2118 path2.close();
2119 path2.moveTo(156.969696f, 186.666672f);
2120 path2.lineTo(118.681946f, 160.343842f);
2121 path2.lineTo(113.458946f, 173.028259f);
2122 path2.quadTo(116.94117f, 179.651855f, 122.644661f, 185.355347f);
2123 path2.quadTo(130.792465f, 193.503143f, 140.817978f, 197.117783f);
2124 path2.lineTo(156.969696f, 186.666672f);
2125 path2.close();
2126 path2.moveTo(195.830978f, 161.521133f);
2127 path2.lineTo(156.969696f, 186.666672f);
2128 path2.lineTo(173.157288f, 197.795639f);
2129 path2.quadTo(184.392426f, 194.318268f, 193.355347f, 185.355347f);
2130 path2.quadTo(197.805817f, 180.904861f, 200.903809f, 175.894165f);
2131 path2.lineTo(195.830978f, 161.521133f);
2132 path2.close();
2133 path2.moveTo(195.830978f, 161.521133f);
2134 path2.lineTo(207.878281f, 153.725815f);
2135 path2.quadTo(208, 151.888062f, 208, 150);
2136 path2.quadTo(208, 132.942657f, 198.066238f, 120);
2137 path2.lineTo(181.176468f, 120);
2138 path2.lineTo(195.830978f, 161.521133f);
2139 path2.close();
2140 path2.setFillType(SkPathFillType::kEvenOdd);
2141 testPathOp(reporter, path1, path2, kIntersect_SkPathOp, filename);
2142}

◆ issue2504()

static void issue2504 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3365 of file PathOpsOpTest.cpp.

3365 {
3366 SkPath path1;
3367 path1.moveTo(34.2421875, -5.976562976837158203125);
3368 path1.lineTo(35.453121185302734375, 0);
3369 path1.lineTo(31.9375, 0);
3370 path1.close();
3371
3372 SkPath path2;
3373 path2.moveTo(36.71843719482421875, 0.8886508941650390625);
3374 path2.cubicTo(36.71843719482421875, 0.8886508941650390625,
3375 35.123386383056640625, 0.554015457630157470703125,
3376 34.511409759521484375, -0.1152553558349609375);
3377 path2.cubicTo(33.899425506591796875, -0.7845261096954345703125,
3378 34.53484344482421875, -5.6777553558349609375,
3379 34.53484344482421875, -5.6777553558349609375);
3380 path2.close();
3381 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename);
3382}

◆ issue2540()

static void issue2540 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3384 of file PathOpsOpTest.cpp.

3384 {
3385 SkPath path1;
3386 path1.moveTo(26.5054988861083984375, 85.73960113525390625);
3387 path1.cubicTo(84.19739532470703125, 17.77140045166015625, 16.93920135498046875, 101.86199951171875, 12.631000518798828125, 105.24700164794921875);
3388 path1.cubicTo(11.0819997787475585937500000, 106.46399688720703125, 11.5260000228881835937500000, 104.464996337890625, 11.5260000228881835937500000, 104.464996337890625);
3389 path1.lineTo(23.1654987335205078125, 89.72879791259765625);
3390 path1.cubicTo(23.1654987335205078125, 89.72879791259765625, -10.1713008880615234375, 119.9160003662109375, -17.1620006561279296875, 120.8249969482421875);
3391 path1.cubicTo(-19.1149997711181640625, 121.07900238037109375, -18.0380001068115234375, 119.79299163818359375, -18.0380001068115234375, 119.79299163818359375);
3392 path1.cubicTo(-18.0380001068115234375, 119.79299163818359375, 14.22100067138671875, 90.60700225830078125, 26.5054988861083984375, 85.73960113525390625);
3393 path1.close();
3394
3395 SkPath path2;
3396 path2.moveTo(-25.077999114990234375, 124.9120025634765625);
3397 path2.cubicTo(-25.077999114990234375, 124.9120025634765625, -25.9509983062744140625, 125.95400238037109375, -24.368999481201171875, 125.7480010986328125);
3398 path2.cubicTo(-16.06999969482421875, 124.66899871826171875, 1.2680000066757202148437500, 91.23999786376953125, 37.264003753662109375, 95.35400390625);
3399 path2.cubicTo(37.264003753662109375, 95.35400390625, 11.3710002899169921875, 83.7339935302734375, -25.077999114990234375, 124.9120025634765625);
3400 path2.close();
3401 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename);
3402}

◆ issue2753()

static void issue2753 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3480 of file PathOpsOpTest.cpp.

3480 {
3481 SkPath path1;
3482 path1.moveTo(142.701f, 110.568f);
3483 path1.lineTo(142.957f, 100);
3484 path1.lineTo(153.835f, 100);
3485 path1.lineTo(154.592f, 108.188f);
3486 path1.cubicTo(154.592f, 108.188f, 153.173f, 108.483f, 152.83f, 109.412f);
3487 path1.cubicTo(152.83f, 109.412f, 142.701f, 110.568f, 142.701f, 110.568f);
3488 path1.close();
3489
3490 SkPath path2;
3491 path2.moveTo(39, 124.001f);
3492 path2.cubicTo(39, 124.001f, 50.6f, 117.001f, 50.6f, 117.001f);
3493 path2.cubicTo(50.6f, 117.001f, 164.601f, 85.2f, 188.201f, 117.601f);
3494 path2.cubicTo(188.201f, 117.601f, 174.801f, 93, 39, 124.001f);
3495 path2.close();
3496
3497 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename);
3498}

◆ issue2808()

static void issue2808 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3500 of file PathOpsOpTest.cpp.

3500 {
3501 SkPath path1, path2;
3502
3503 path1.moveTo(509.20300293f, 385.601989746f);
3504 path1.quadTo(509.20300293f, 415.68838501f, 487.928710938f, 436.96270752f);
3505 path1.quadTo(466.654388428f, 458.236999512f, 436.567993164f, 458.236999512f);
3506 path1.quadTo(406.4815979f, 458.236999512f, 385.207275391f, 436.96270752f);
3507 path1.quadTo(363.932983398f, 415.68838501f, 363.932983398f, 385.601989746f);
3508 path1.quadTo(363.932983398f, 355.515594482f, 385.207275391f, 334.241271973f);
3509 path1.quadTo(406.4815979f, 312.96697998f, 436.567993164f, 312.96697998f);
3510 path1.quadTo(466.654388428f, 312.96697998f, 487.928710938f, 334.241271973f);
3511 path1.quadTo(509.20300293f, 355.515594482f, 509.20300293f, 385.601989746f);
3512 path1.close();
3513
3514 path2.moveTo(449.033996582f, 290.87298584f);
3515 path2.quadTo(449.033996582f, 301.028259277f, 441.853149414f, 308.209106445f);
3516 path2.quadTo(434.672271729f, 315.389984131f, 424.516998291f, 315.389984131f);
3517 path2.quadTo(414.361724854f, 315.389984131f, 407.180847168f, 308.209106445f);
3518 path2.quadTo(400, 301.028259277f, 400, 290.87298584f);
3519 path2.quadTo(400, 280.717712402f, 407.180847168f, 273.536865234f);
3520 path2.quadTo(414.361724854f, 266.355987549f, 424.516998291f, 266.355987549f);
3521 path2.quadTo(434.672271729f, 266.355987549f, 441.853149414f, 273.536865234f);
3522 path2.quadTo(449.033996582f, 280.717712402f, 449.033996582f, 290.87298584f);
3523 path2.close();
3524
3525 testPathOp(reporter, path1, path2, kUnion_SkPathOp, filename);
3526}

◆ issue3517()

static void issue3517 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3676 of file PathOpsOpTest.cpp.

3676 {
3677 SkPath path, pathB;
3678
3679 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";
3680 SkParsePath::FromSVGString(str, &path);
3681
3682 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";
3683 SkParsePath::FromSVGString(strB, &pathB);
3684 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3685}
SkParsePath::FromSVGString
static bool FromSVGString(const char str[], SkPath *)
Definition SkParsePath.cpp:103

◆ kari1()

static void kari1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3346 of file PathOpsOpTest.cpp.

3346 {
3347 SkPath path1;
3348 path1.moveTo(39.9375, -5.8359375);
3349 path1.lineTo(40.625, -5.7890625);
3350 path1.lineTo(37.7109375, 1.3515625);
3351 path1.lineTo(37.203125, 0.9609375);
3352 path1.close();
3353
3354 SkPath path2;
3355 path2.moveTo(37.52734375f, -1.44140625f);
3356 path2.cubicTo(37.8736991882324f, -1.69921875f, 38.1640625f, -2.140625f, 38.3984375f, -2.765625f);
3357 path2.lineTo(38.640625f, -2.609375f);
3358 path2.cubicTo(38.53125f, -1.89583337306976f, 38.0664443969727f, -0.154893040657043f, 38.0664443969727f, -0.154893040657043f);
3359 path2.cubicTo(38.0664443969727f, -0.154893040657043f, 37.1809883117676f, -1.18359375f, 37.52734375, -1.44140625f);
3360 path2.close();
3361
3362 testPathOp(reporter, path1, path2, kDifference_SkPathOp, filename);
3363}

◆ kfuzz2()

static void kfuzz2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 10368 of file PathOpsOpTest.cpp.

10368 {
10369 SkPath path1;
10370 SkPath path;
10371path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
10372path.close();
10373path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
10374path.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
10375path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
10376path.close();
10377path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
10378path.lineTo(SkBits2Float(0x60601a1d), SkBits2Float(0x60606060)); // 6.4593e+19f, 6.46721e+19f
10379path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0xfafadbfa)); // 0, -6.51268e+35f
10380path.close();
10381path.moveTo(SkBits2Float(0xe5e2f300), SkBits2Float(0xee244a40)); // -1.33967e+23f, -1.27113e+28f
10382path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
10383path.close();
10384path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
10385path.lineTo(SkBits2Float(0xfafafafa), SkBits2Float(0xe30000fa)); // -6.51582e+35f, -2.36125e+21f
10386path.conicTo(SkBits2Float(0x92e592e5), SkBits2Float(0xfafafafb), SkBits2Float(0xc4fa0000), SkBits2Float(0x6060fafa), SkBits2Float(0x60606060)); // -1.44881e-27f, -6.51582e+35f, -2000, 6.48462e+19f, 6.46721e+19f
10387path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
10388path.close();
10389path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
10390path.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
10391path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
10392path.close();
10393path.moveTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
10394path.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
10395path.lineTo(SkBits2Float(0xba98ffee), SkBits2Float(0xfafafa1a)); // -0.0011673f, -6.51573e+35f
10396path.close();
10397SkPath path2(path);
10398 testPathOpFuzz(reporter, path1, path2, kXOR_SkPathOp, filename);
10399}

◆ lineOp9d()

static void lineOp9d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 171 of file PathOpsOpTest.cpp.

171 {
172 SkPath path, pathB;
173 path.setFillType(SkPathFillType::kWinding);
174 path.moveTo(0,1);
175 path.lineTo(1,6);
176 path.lineTo(1.5f,1);
177 path.lineTo(1.8f,0.8f);
178 path.lineTo(2,1);
179 path.close();
180 pathB.setFillType(SkPathFillType::kWinding);
181 pathB.moveTo(0,1);
182 pathB.lineTo(1,2);
183 pathB.lineTo(1.4f,1);
184 pathB.lineTo(3,0.4f);
185 pathB.lineTo(6,1);
186 pathB.close();
187 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
188}

◆ loop1()

static void loop1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3601 of file PathOpsOpTest.cpp.

3601 {
3602 SkPath path, pathB;
3603 path.moveTo(0,1);
3604 path.cubicTo(1,5, -5.66666651f,3.33333349f, 8.83333302f,2.33333349f);
3605 path.close();
3606 pathB.moveTo(1,5);
3607 pathB.cubicTo(-5.66666651f,3.33333349f, 8.83333302f,2.33333349f, 0,1);
3608 pathB.close();
3609 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3610}

◆ loop10()

static void loop10 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4026 of file PathOpsOpTest.cpp.

4026 {
4027 SkPath path, pathB;
4028 path.moveTo(5,6);
4029 path.cubicTo(1,2, 1,2, -3.66666651f,13.333334f);
4030 path.close();
4031 pathB.moveTo(1,2);
4032 pathB.cubicTo(1,2, -3.66666651f,13.333334f, 5,6);
4033 pathB.close();
4034 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4035}

◆ loop11()

static void loop11 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4037 of file PathOpsOpTest.cpp.

4037 {
4038 SkPath path, pathB;
4039 path.moveTo(0,1);
4040 path.cubicTo(1,3, -1.83333349f,1.33333337f, 4,-1);
4041 path.close();
4042 pathB.moveTo(1,3);
4043 pathB.cubicTo(-1.83333349f,1.33333337f, 4,-1, 0,1);
4044 pathB.close();
4045 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4046}

◆ loop12()

static void loop12 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4061 of file PathOpsOpTest.cpp.

4061 {
4062 SkPath path, pathB;
4063 path.moveTo(1,2);
4064 path.cubicTo(0,6, -3.16666675f,3.66666675f, 6.33333349f,3.33333349f);
4065 path.close();
4066 pathB.moveTo(0,6);
4067 pathB.cubicTo(-3.16666675f,3.66666675f, 6.33333349f,3.33333349f, 1,2);
4068 pathB.close();
4069 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4070}

◆ loop17()

static void loop17 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5401 of file PathOpsOpTest.cpp.

5401 {
5402 SkPath path, pathB;
5403 path.moveTo(1, 2);
5404 path.cubicTo(0, 3, -0.333333343f, 3.33333325f, 0.833333373f, 3.5f);
5405 path.close();
5406 pathB.moveTo(0, 3);
5407 pathB.cubicTo(-0.333333343f, 3.33333325f, 0.833333373f, 3.5f, 1, 2);
5408 pathB.close();
5409 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5410}

◆ loop1asQuad()

static void loop1asQuad ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3612 of file PathOpsOpTest.cpp.

3612 {
3613 CubicPts cubic1 = {{{0,1}, {1,5}, {-5.66666651f,3.33333349f}, {8.83333302f,2.33333349f}}};
3614 CubicPts cubic2 = {{{1,5}, {-5.66666651f,3.33333349f}, {8.83333302f,2.33333349f}, {0,1}}};
3615 SkDCubic c1, c2;
3616 c1.debugSet(cubic1.fPts);
3617 c2.debugSet(cubic2.fPts);
3618 double c1InflectionTs[2], c2InflectionTs[2];
3619 SkDEBUGCODE(int c1InfTCount =) c1.findInflections(c1InflectionTs);
3620 SkASSERT(c1InfTCount == 2);
3621 SkDEBUGCODE(int c2InfTCount =) c2.findInflections(c2InflectionTs);
3622 SkASSERT(c2InfTCount == 1);
3623 SkASSERT(c1InflectionTs[0] > c1InflectionTs[1]);
3624 SkDCubicPair c1pair = c1.chopAt(c1InflectionTs[0]);
3625 SkDCubicPair c1apair = c1pair.first().chopAt(c1InflectionTs[1]);
3626 SkDCubicPair c2pair = c2.chopAt(c2InflectionTs[0]);
3627 SkDQuad q1[2] = { c1pair.first().toQuad(), c1pair.second().toQuad() };
3628 SkDQuad q1a[2] = { c1apair.first().toQuad(), c1apair.second().toQuad() };
3629 SkDQuad q2[2] = { c2pair.first().toQuad(), c2pair.second().toQuad() };
3630 SkPath path, pathB;
3631 path.moveTo(q1a[0].fPts[0].asSkPoint());
3632 path.quadTo(q1a[0].fPts[1].asSkPoint(), q1a[0].fPts[2].asSkPoint());
3633 path.quadTo(q1a[1].fPts[1].asSkPoint(), q1a[1].fPts[2].asSkPoint());
3634 path.quadTo(q1[1].fPts[1].asSkPoint(), q1[1].fPts[2].asSkPoint());
3635 path.close();
3636 pathB.moveTo(q2[0].fPts[0].asSkPoint());
3637 pathB.quadTo(q2[0].fPts[1].asSkPoint(), q2[0].fPts[2].asSkPoint());
3638 pathB.quadTo(q2[1].fPts[1].asSkPoint(), q2[1].fPts[2].asSkPoint());
3639 pathB.close();
3640 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3641}
fPts
SkPoint fPts[2]
Definition AAConvexPathRenderer.cpp:50
SkASSERT
#define SkASSERT(cond)
Definition SkAssert.h:116
SkDEBUGCODE
#define SkDEBUGCODE(...)
Definition SkDebug.h:23
CubicPts::fPts
SkDPoint fPts[kPointCount]
Definition PathOpsTestCommon.h:34
SkDCubic::debugSet
void debugSet(const SkDPoint *pts)
Definition SkPathOpsDebug.cpp:712

◆ loop2()

static void loop2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3643 of file PathOpsOpTest.cpp.

3643 {
3644 SkPath path, pathB;
3645 path.moveTo(0,1);
3646 path.cubicTo(3,4, 3.f,4.f, 4.5f,1.5f);
3647 path.close();
3648 pathB.moveTo(3,4);
3649 pathB.cubicTo(3.f,4.f, 4.5f,1.5f, 0,1);
3650 pathB.close();
3651 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3652}

◆ loop3()

static void loop3 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3654 of file PathOpsOpTest.cpp.

3654 {
3655 SkPath path, pathB;
3656 path.moveTo(0,1);
3657 path.cubicTo(3,5, -3.66666651f,0, 10.5f,-1.66666651f);
3658 path.close();
3659 pathB.moveTo(3,5);
3660 pathB.cubicTo(-3.66666651f,0, 10.5f,-1.66666651f, 0,1);
3661 pathB.close();
3662 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3663}

◆ loop4()

static void loop4 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3665 of file PathOpsOpTest.cpp.

3665 {
3666 SkPath path, pathB;
3667 path.moveTo(0,5);
3668 path.cubicTo(1,5, 1,4, 0.833333313f,3);
3669 path.close();
3670 pathB.moveTo(1,5);
3671 pathB.cubicTo(1,4, 0.833333313f,3, 0,5);
3672 pathB.close();
3673 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3674}

◆ loop5()

static void loop5 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3753 of file PathOpsOpTest.cpp.

3753 {
3754 SkPath path, pathB;
3755 path.moveTo(0,2);
3756 path.cubicTo(1,2, 1,1.66666663f, 0.833333313f,1.33333325f);
3757 path.close();
3758 pathB.moveTo(1,2);
3759 pathB.cubicTo(1,1.66666663f, 0.833333313f,1.33333325f, 0,2);
3760 pathB.close();
3761 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3762}

◆ loop6()

static void loop6 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3764 of file PathOpsOpTest.cpp.

3764 {
3765 SkPath path, pathB;
3766 path.moveTo(0,1);
3767 path.cubicTo(1,3, -1.66666675f,1.66666663f, 4.16666651f,1.00000012f);
3768 path.close();
3769 pathB.moveTo(1,3);
3770 pathB.cubicTo(-1.66666675f,1.66666663f, 4.16666651f,1.00000012f, 0,1);
3771 pathB.close();
3772 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3773}

◆ loop7()

static void loop7 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3973 of file PathOpsOpTest.cpp.

3973 {
3974 SkPath path, pathB;
3975 path.moveTo(0,1);
3976 path.cubicTo(3,4, -1,0, 8.5f,-2.5f);
3977 path.close();
3978 pathB.moveTo(3,4);
3979 pathB.cubicTo(-1,0, 8.5f,-2.5f, 0,1);
3980 pathB.close();
3981 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3982}

◆ loop8()

static void loop8 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3995 of file PathOpsOpTest.cpp.

3995 {
3996 SkPath path, pathB;
3997 path.moveTo(0,1);
3998 path.cubicTo(1,4, -3.83333325f,0.166666627f, 6,-1);
3999 path.close();
4000 pathB.moveTo(1,4);
4001 pathB.cubicTo(-3.83333325f,0.166666627f, 6,-1, 0,1);
4002 pathB.close();
4003 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4004}

◆ loop9()

static void loop9 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4006 of file PathOpsOpTest.cpp.

4006 {
4007 SkPath path, pathB;
4008 path.moveTo(0,1);
4009 path.cubicTo(1,3, -2.5f,0, 3.33333325f,-0.666666627f);
4010 path.close();
4011 pathB.moveTo(1,3);
4012 pathB.cubicTo(-2.5f,0, 3.33333325f,-0.666666627f, 0,1);
4013 pathB.close();
4014 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4015}

◆ loopEdge1()

static void loopEdge1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2168 of file PathOpsOpTest.cpp.

2168 {
2169 SkPath path;
2170 path.setFillType(SkPathFillType::kEvenOdd);
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(SkPathFillType::kEvenOdd);
2182 pathB.moveTo(1,2);
2183 pathB.lineTo(2,2);
2184 pathB.lineTo(2,4);
2185 pathB.lineTo(1,4);
2186 pathB.close();
2187 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2188}

◆ loopEdge2()

static void loopEdge2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2190 of file PathOpsOpTest.cpp.

2190 {
2191 SkPath path;
2192 path.setFillType(SkPathFillType::kEvenOdd);
2193 path.moveTo(0,0);
2194 path.lineTo(3,0);
2195 path.lineTo(3,2);
2196 path.lineTo(1,2);
2197 path.lineTo(1,1);
2198 path.lineTo(2,1);
2199 path.lineTo(2,3);
2200 path.lineTo(0,3);
2201 path.close();
2202 SkPath pathB;
2203 pathB.setFillType(SkPathFillType::kEvenOdd);
2204 pathB.moveTo(1 - 1e-6f,2);
2205 pathB.lineTo(2 - 1e-6f,2);
2206 pathB.lineTo(2 - 1e-6f,4);
2207 pathB.lineTo(1 - 1e-6f,4);
2208 pathB.close();
2209 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2210}

◆ loops20i()

static void loops20i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4510 of file PathOpsOpTest.cpp.

4510 {
4511 SkPath path, pathB;
4512 path.setFillType(SkPathFillType::kWinding);
4513 path.moveTo(1, 2);
4514 path.cubicTo(0, 2, 0.833333313f, 2, 1, 3.66666651f);
4515 path.close();
4516 pathB.setFillType(SkPathFillType::kWinding);
4517 pathB.moveTo(0, 2);
4518 pathB.cubicTo(0.833333313f, 2, 1, 3.66666651f, 1, 2);
4519 pathB.close();
4520 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4521}

◆ loops21i()

static void loops21i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4523 of file PathOpsOpTest.cpp.

4523 {
4524 SkPath path, pathB;
4525 path.setFillType(SkPathFillType::kWinding);
4526 path.moveTo(1, 2);
4527 path.cubicTo(0, 2, 0.833333313f, 2, 1, 4);
4528 path.close();
4529 pathB.setFillType(SkPathFillType::kWinding);
4530 pathB.moveTo(0, 2);
4531 pathB.cubicTo(0.833333313f, 2, 1, 4, 1, 2);
4532 pathB.close();
4533 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4534}

◆ loops22i()

static void loops22i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4536 of file PathOpsOpTest.cpp.

4536 {
4537 SkPath path, pathB;
4538 path.setFillType(SkPathFillType::kWinding);
4539 path.moveTo(1, 3);
4540 path.cubicTo(0, 3, 0.833333313f, 3, 1, 4.66666651f);
4541 path.close();
4542 pathB.setFillType(SkPathFillType::kWinding);
4543 pathB.moveTo(0, 3);
4544 pathB.cubicTo(0.833333313f, 3, 1, 4.66666651f, 1, 3);
4545 pathB.close();
4546 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4547}

◆ loops23i()

static void loops23i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4549 of file PathOpsOpTest.cpp.

4549 {
4550 SkPath path, pathB;
4551 path.setFillType(SkPathFillType::kWinding);
4552 path.moveTo(1, 5);
4553 path.cubicTo(0, 1, 6.16666698f, 5.66666698f, -5.66666651f, 6.66666651f);
4554 path.close();
4555 pathB.setFillType(SkPathFillType::kWinding);
4556 pathB.moveTo(0, 1);
4557 pathB.cubicTo(6.16666698f, 5.66666698f, -5.66666651f, 6.66666651f, 1, 5);
4558 pathB.close();
4559 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4560}

◆ loops24i()

static void loops24i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4562 of file PathOpsOpTest.cpp.

4562 {
4563 SkPath path, pathB;
4564 path.setFillType(SkPathFillType::kWinding);
4565 path.moveTo(1, 2);
4566 path.cubicTo(0, 2, 0.833333313f, 2, 1, 3);
4567 path.close();
4568 pathB.setFillType(SkPathFillType::kWinding);
4569 pathB.moveTo(0, 2);
4570 pathB.cubicTo(0.833333313f, 2, 1, 3, 1, 2);
4571 pathB.close();
4572 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4573}

◆ loops25i()

static void loops25i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4575 of file PathOpsOpTest.cpp.

4575 {
4576 SkPath path, pathB;
4577 path.setFillType(SkPathFillType::kWinding);
4578 path.moveTo(1, 5);
4579 path.cubicTo(0, 5, 0.833333313f, 5, 1, 7);
4580 path.close();
4581 pathB.setFillType(SkPathFillType::kWinding);
4582 pathB.moveTo(0, 5);
4583 pathB.cubicTo(0.833333313f, 5, 1, 7, 1, 5);
4584 pathB.close();
4585 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4586}

◆ loops26i()

static void loops26i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4588 of file PathOpsOpTest.cpp.

4588 {
4589 SkPath path, pathB;
4590 path.setFillType(SkPathFillType::kWinding);
4591 path.moveTo(1, 6);
4592 path.cubicTo(0, 2, 6.16666698f, 6.66666698f, -5.66666651f, 7.66666651f);
4593 path.close();
4594 pathB.setFillType(SkPathFillType::kWinding);
4595 pathB.moveTo(0, 2);
4596 pathB.cubicTo(6.16666698f, 6.66666698f, -5.66666651f, 7.66666651f, 1, 6);
4597 pathB.close();
4598 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4599}

◆ loops27i()

static void loops27i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4601 of file PathOpsOpTest.cpp.

4601 {
4602 SkPath path, pathB;
4603 path.setFillType(SkPathFillType::kWinding);
4604 path.moveTo(1, 3);
4605 path.cubicTo(0, 3, 0.833333313f, 3, 1, 4.33333349f);
4606 path.close();
4607 pathB.setFillType(SkPathFillType::kWinding);
4608 pathB.moveTo(0, 3);
4609 pathB.cubicTo(0.833333313f, 3, 1, 4.33333349f, 1, 3);
4610 pathB.close();
4611 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4612}

◆ loops28i()

static void loops28i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4614 of file PathOpsOpTest.cpp.

4614 {
4615 SkPath path, pathB;
4616 path.setFillType(SkPathFillType::kWinding);
4617 path.moveTo(2, 3);
4618 path.cubicTo(1, 3, 1.83333337f, 3, 2, 4.66666651f);
4619 path.close();
4620 pathB.setFillType(SkPathFillType::kWinding);
4621 pathB.moveTo(1, 3);
4622 pathB.cubicTo(1.83333337f, 3, 2, 4.66666651f, 2, 3);
4623 pathB.close();
4624 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4625}

◆ loops29i()

static void loops29i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4627 of file PathOpsOpTest.cpp.

4627 {
4628 SkPath path, pathB;
4629 path.setFillType(SkPathFillType::kWinding);
4630 path.moveTo(2, 4);
4631 path.cubicTo(0, 4, 1.66666663f, 4, 2, 7.33333302f);
4632 path.close();
4633 pathB.setFillType(SkPathFillType::kWinding);
4634 pathB.moveTo(0, 4);
4635 pathB.cubicTo(1.66666663f, 4, 2, 7.33333302f, 2, 4);
4636 pathB.close();
4637 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4638}

◆ loops30i()

static void loops30i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4640 of file PathOpsOpTest.cpp.

4640 {
4641 SkPath path, pathB;
4642 path.setFillType(SkPathFillType::kWinding);
4643 path.moveTo(2, 4);
4644 path.cubicTo(0, 4, 1.66666663f, 4, 2, 8);
4645 path.close();
4646 pathB.setFillType(SkPathFillType::kWinding);
4647 pathB.moveTo(0, 4);
4648 pathB.cubicTo(1.66666663f, 4, 2, 8, 2, 4);
4649 pathB.close();
4650 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4651}

◆ loops31i()

static void loops31i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4653 of file PathOpsOpTest.cpp.

4653 {
4654 SkPath path, pathB;
4655 path.setFillType(SkPathFillType::kWinding);
4656 path.moveTo(2, 5);
4657 path.cubicTo(1, 5, 1.83333337f, 5, 2, 6.66666651f);
4658 path.close();
4659 pathB.setFillType(SkPathFillType::kWinding);
4660 pathB.moveTo(1, 5);
4661 pathB.cubicTo(1.83333337f, 5, 2, 6.66666651f, 2, 5);
4662 pathB.close();
4663 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4664}

◆ loops32i()

static void loops32i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4666 of file PathOpsOpTest.cpp.

4666 {
4667 SkPath path, pathB;
4668 path.setFillType(SkPathFillType::kWinding);
4669 path.moveTo(2, 6);
4670 path.cubicTo(1, 6, 1.83333337f, 6, 2, 8);
4671 path.close();
4672 pathB.setFillType(SkPathFillType::kWinding);
4673 pathB.moveTo(1, 6);
4674 pathB.cubicTo(1.83333337f, 6, 2, 8, 2, 6);
4675 pathB.close();
4676 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4677}

◆ loops33i()

static void loops33i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4679 of file PathOpsOpTest.cpp.

4679 {
4680 SkPath path, pathB;
4681 path.setFillType(SkPathFillType::kWinding);
4682 path.moveTo(2, 6);
4683 path.cubicTo(1, 2, 7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f);
4684 path.close();
4685 pathB.setFillType(SkPathFillType::kWinding);
4686 pathB.moveTo(1, 2);
4687 pathB.cubicTo(7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f, 2, 6);
4688 pathB.close();
4689 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4690}

◆ loops33iAsQuads()

static void loops33iAsQuads ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4726 of file PathOpsOpTest.cpp.

4726 {
4727 SkPath path, pathB;
4728 path.setFillType(SkPathFillType::kWinding);
4729 path.moveTo(2, 6);
4730 path.cubicTo(1, 2, 7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f);
4731 path.close();
4732 pathB.setFillType(SkPathFillType::kWinding);
4733 pathB.moveTo(1, 2);
4734 pathB.cubicTo(7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f, 2, 6);
4735 pathB.close();
4736 SkPath qPath, qPathB;
4737 CubicPathToQuads(path, &qPath);
4738 CubicPathToQuads(pathB, &qPathB);
4739 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename);
4740}

◆ loops33iMod()

static void loops33iMod ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4692 of file PathOpsOpTest.cpp.

4692 {
4693 SkPoint pts[] = {{2, 6}, {1, 2}, {7.16666698f, 6.66666698f}, {-4.66666651f, 7.66666651f},
4694 {1, 2}, {7.16666698f, 6.66666698f}, {-4.66666651f, 7.66666651f}, {2, 6}};
4695 bool up = false;
4696 float offset = 0.0380172729f;
4697 float step = 7.62939453e-006f;
4698 bool lastResult = true;
4699 // for (int i = 0; i < 30; ++i) {
4700 SkString name(filename);
4701 // name.appendS32(i);
4702 // if (i > 0) {
4703 // SkDebugf("\n\n<div id=\"%s\">\n", name.c_str());
4704 // }
4705 pts[5].fY = 6.66666698f + offset;
4706 SkPath path, pathB;
4707 path.setFillType(SkPathFillType::kWinding);
4708 path.moveTo(pts[0]);
4709 path.cubicTo(pts[1], pts[2], pts[3]);
4710 path.close();
4711 pathB.setFillType(SkPathFillType::kWinding);
4712 pathB.moveTo(pts[4]);
4713 pathB.cubicTo(pts[5], pts[6], pts[7]);
4714 pathB.close();
4715 bool result = testPathOp(reporter, path, pathB, kIntersect_SkPathOp, name.c_str());
4716 if (lastResult != result) {
4717 up = !up;
4718 }
4719 step /= 2;
4720 offset += up ? step : -step;
4721 lastResult = result;
4722 // }
4723}
step
static int step(int x, SkScalar min, SkScalar max)
Definition BlurTest.cpp:215
result
GAsyncResult * result
Definition fl_text_input_plugin.cc:106
name
const char * name
Definition fuchsia.cc:50
offset
Point offset
Definition stroke_path_geometry.cc:256
SkPoint::fY
float fY
y-axis value
Definition SkPoint_impl.h:165

◆ loops34i()

static void loops34i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4742 of file PathOpsOpTest.cpp.

4742 {
4743 SkPath path, pathB;
4744 path.setFillType(SkPathFillType::kWinding);
4745 path.moveTo(3, 4);
4746 path.cubicTo(0, 4, 2.5f, 4, 3, 9);
4747 path.close();
4748 pathB.setFillType(SkPathFillType::kWinding);
4749 pathB.moveTo(0, 4);
4750 pathB.cubicTo(2.5f, 4, 3, 9, 3, 4);
4751 pathB.close();
4752 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4753}

◆ loops35i()

static void loops35i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4755 of file PathOpsOpTest.cpp.

4755 {
4756 SkPath path, pathB;
4757 path.setFillType(SkPathFillType::kWinding);
4758 path.moveTo(3, 4);
4759 path.cubicTo(0, 4, 2.5f, 4, 3, 10);
4760 path.close();
4761 pathB.setFillType(SkPathFillType::kWinding);
4762 pathB.moveTo(0, 4);
4763 pathB.cubicTo(2.5f, 4, 3, 10, 3, 4);
4764 pathB.close();
4765 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4766}

◆ loops36i()

static void loops36i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4768 of file PathOpsOpTest.cpp.

4768 {
4769 SkPath path, pathB;
4770 path.setFillType(SkPathFillType::kWinding);
4771 path.moveTo(3, 4);
4772 path.cubicTo(1, 4, 2.66666675f, 4, 3, 8);
4773 path.close();
4774 pathB.setFillType(SkPathFillType::kWinding);
4775 pathB.moveTo(1, 4);
4776 pathB.cubicTo(2.66666675f, 4, 3, 8, 3, 4);
4777 pathB.close();
4778 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4779}

◆ loops37i()

static void loops37i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4781 of file PathOpsOpTest.cpp.

4781 {
4782 SkPath path, pathB;
4783 path.setFillType(SkPathFillType::kWinding);
4784 path.moveTo(2, 4);
4785 path.cubicTo(1, 4, 1.83333337f, 4, 2, 5.33333349f);
4786 path.close();
4787 pathB.setFillType(SkPathFillType::kWinding);
4788 pathB.moveTo(1, 4);
4789 pathB.cubicTo(1.83333337f, 4, 2, 5.33333349f, 2, 4);
4790 pathB.close();
4791 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4792}

◆ loops38i()

static void loops38i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4794 of file PathOpsOpTest.cpp.

4794 {
4795 SkPath path, pathB;
4796 path.setFillType(SkPathFillType::kWinding);
4797 path.moveTo(3, 4);
4798 path.cubicTo(2, 4, 2.83333325f, 4, 3, 6);
4799 path.close();
4800 pathB.setFillType(SkPathFillType::kWinding);
4801 pathB.moveTo(2, 4);
4802 pathB.cubicTo(2.83333325f, 4, 3, 6, 3, 4);
4803 pathB.close();
4804 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4805}

◆ loops39i()

static void loops39i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4807 of file PathOpsOpTest.cpp.

4807 {
4808 SkPath path, pathB;
4809 path.setFillType(SkPathFillType::kWinding);
4810 path.moveTo(3, 5);
4811 path.cubicTo(0, 5, 2.5f, 5, 3, 10);
4812 path.close();
4813 pathB.setFillType(SkPathFillType::kWinding);
4814 pathB.moveTo(0, 5);
4815 pathB.cubicTo(2.5f, 5, 3, 10, 3, 5);
4816 pathB.close();
4817 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4818}

◆ loops40i()

static void loops40i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4820 of file PathOpsOpTest.cpp.

4820 {
4821 SkPath path, pathB;
4822 path.setFillType(SkPathFillType::kWinding);
4823 path.moveTo(3, 5);
4824 path.cubicTo(0, 5, 2.5f, 5, 3, 11);
4825 path.close();
4826 pathB.setFillType(SkPathFillType::kWinding);
4827 pathB.moveTo(0, 5);
4828 pathB.cubicTo(2.5f, 5, 3, 11, 3, 5);
4829 pathB.close();
4830 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4831}

◆ loops40iAsQuads()

static void loops40iAsQuads ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4833 of file PathOpsOpTest.cpp.

4833 {
4834 SkPath path, pathB;
4835 path.setFillType(SkPathFillType::kWinding);
4836 path.moveTo(3, 5);
4837 path.cubicTo(0, 5, 2.5f, 5, 3, 11);
4838 path.close();
4839 pathB.setFillType(SkPathFillType::kWinding);
4840 pathB.moveTo(0, 5);
4841 pathB.cubicTo(2.5f, 5, 3, 11, 3, 5);
4842 pathB.close();
4843 SkPath qPath, qPathB;
4844 CubicPathToQuads(path, &qPath);
4845 CubicPathToQuads(pathB, &qPathB);
4846 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename);
4847}

◆ loops44i()

static void loops44i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4849 of file PathOpsOpTest.cpp.

4849 {
4850 SkPath path, pathB;
4851 path.setFillType(SkPathFillType::kWinding);
4852 path.moveTo(1, 5);
4853 path.cubicTo(0, 1, 7.33333302f, 5.33333349f, -7, 7);
4854 path.close();
4855 pathB.setFillType(SkPathFillType::kWinding);
4856 pathB.moveTo(0, 1);
4857 pathB.cubicTo(7.33333302f, 5.33333349f, -7, 7, 1, 5);
4858 pathB.close();
4859 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4860}

◆ loops45i()

static void loops45i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4862 of file PathOpsOpTest.cpp.

4862 {
4863 SkPath path, pathB;
4864 path.setFillType(SkPathFillType::kWinding);
4865 path.moveTo(1, 6);
4866 path.cubicTo(0, 2, 7.33333302f, 6.33333302f, -7, 8);
4867 path.close();
4868 pathB.setFillType(SkPathFillType::kWinding);
4869 pathB.moveTo(0, 2);
4870 pathB.cubicTo(7.33333302f, 6.33333302f, -7, 8, 1, 6);
4871 pathB.close();
4872 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4873}

◆ loops46i()

static void loops46i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4875 of file PathOpsOpTest.cpp.

4875 {
4876 SkPath path, pathB;
4877 path.setFillType(SkPathFillType::kWinding);
4878 path.moveTo(2, 6);
4879 path.cubicTo(1, 2, 8.33333302f, 6.33333302f, -6, 8);
4880 path.close();
4881 pathB.setFillType(SkPathFillType::kWinding);
4882 pathB.moveTo(1, 2);
4883 pathB.cubicTo(8.33333302f, 6.33333302f, -6, 8, 2, 6);
4884 pathB.close();
4885 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4886}

◆ loops47i()

static void loops47i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4890 of file PathOpsOpTest.cpp.

4890 {
4891 SkPath path, pathB;
4892 path.setFillType(SkPathFillType::kWinding);
4893 path.moveTo(2, 4);
4894 path.cubicTo(0, 1, 6, 5.83333302f, -4, 8);
4895 path.close();
4896 pathB.setFillType(SkPathFillType::kWinding);
4897 pathB.moveTo(0, 1);
4898 pathB.cubicTo(6, 5.83333302f, -4, 8, 2, 4);
4899 pathB.close();
4900 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4901}

◆ loops48i()

static void loops48i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4903 of file PathOpsOpTest.cpp.

4903 {
4904 SkPath path, pathB;
4905 path.setFillType(SkPathFillType::kWinding);
4906 path.moveTo(2, 6);
4907 path.cubicTo(0, 1, 9.33333302f, 6.83333302f, -8.33333302f, 9.16666603f);
4908 path.close();
4909 pathB.setFillType(SkPathFillType::kWinding);
4910 pathB.moveTo(0, 1);
4911 pathB.cubicTo(9.33333302f, 6.83333302f, -8.33333302f, 9.16666603f, 2, 6);
4912 pathB.close();
4913 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4914}

◆ loops49i()

static void loops49i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4916 of file PathOpsOpTest.cpp.

4916 {
4917 SkPath path, pathB;
4918 path.setFillType(SkPathFillType::kWinding);
4919 path.moveTo(0, 2);
4920 path.cubicTo(1, 4, -0.166666687f, 2.66666675f, 1.66666675f, 2);
4921 path.close();
4922 pathB.setFillType(SkPathFillType::kWinding);
4923 pathB.moveTo(1, 4);
4924 pathB.cubicTo(-0.166666687f, 2.66666675f, 1.66666675f, 2, 0, 2);
4925 pathB.close();
4926 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4927}

◆ loops4i()

static void loops4i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4263 of file PathOpsOpTest.cpp.

4263 {
4264 SkPath path, pathB;
4265 path.setFillType(SkPathFillType::kWinding);
4266 path.moveTo(0, 3);
4267 path.cubicTo(0, 2, 0, 2, -1.66666663f, 2.16666675f);
4268 path.close();
4269 pathB.setFillType(SkPathFillType::kWinding);
4270 pathB.moveTo(0, 2);
4271 pathB.cubicTo(0, 2, -1.66666663f, 2.16666675f, 0, 3);
4272 pathB.close();
4273 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4274}

◆ loops50i()

static void loops50i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4929 of file PathOpsOpTest.cpp.

4929 {
4930 SkPath path, pathB;
4931 path.setFillType(SkPathFillType::kWinding);
4932 path.moveTo(0, 3);
4933 path.cubicTo(1, 5, -0.166666687f, 3.66666675f, 1.66666675f, 3);
4934 path.close();
4935 pathB.setFillType(SkPathFillType::kWinding);
4936 pathB.moveTo(1, 5);
4937 pathB.cubicTo(-0.166666687f, 3.66666675f, 1.66666675f, 3, 0, 3);
4938 pathB.close();
4939 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4940}

◆ loops51i()

static void loops51i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4942 of file PathOpsOpTest.cpp.

4942 {
4943 SkPath path, pathB;
4944 path.setFillType(SkPathFillType::kWinding);
4945 path.moveTo(1, 2);
4946 path.cubicTo(2, 4, 0.833333313f, 2.66666675f, 2.66666675f, 2);
4947 path.close();
4948 pathB.setFillType(SkPathFillType::kWinding);
4949 pathB.moveTo(2, 4);
4950 pathB.cubicTo(0.833333313f, 2.66666675f, 2.66666675f, 2, 1, 2);
4951 pathB.close();
4952 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4953}

◆ loops52i()

static void loops52i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4955 of file PathOpsOpTest.cpp.

4955 {
4956 SkPath path, pathB;
4957 path.setFillType(SkPathFillType::kWinding);
4958 path.moveTo(1, 3);
4959 path.cubicTo(2, 5, 0.833333313f, 3.66666675f, 2.66666675f, 3);
4960 path.close();
4961 pathB.setFillType(SkPathFillType::kWinding);
4962 pathB.moveTo(2, 5);
4963 pathB.cubicTo(0.833333313f, 3.66666675f, 2.66666675f, 3, 1, 3);
4964 pathB.close();
4965 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4966}

◆ loops53i()

static void loops53i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4968 of file PathOpsOpTest.cpp.

4968 {
4969 SkPath path, pathB;
4970 path.setFillType(SkPathFillType::kWinding);
4971 path.moveTo(2, 3);
4972 path.cubicTo(3, 5, 1.83333325f, 3.66666675f, 3.66666651f, 3);
4973 path.close();
4974 pathB.setFillType(SkPathFillType::kWinding);
4975 pathB.moveTo(3, 5);
4976 pathB.cubicTo(1.83333325f, 3.66666675f, 3.66666651f, 3, 2, 3);
4977 pathB.close();
4978 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4979}

◆ loops54i()

static void loops54i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4981 of file PathOpsOpTest.cpp.

4981 {
4982 SkPath path, pathB;
4983 path.setFillType(SkPathFillType::kWinding);
4984 path.moveTo(0, 2);
4985 path.cubicTo(1, 4, 0, 3, 1.66666675f, 2);
4986 path.close();
4987 pathB.setFillType(SkPathFillType::kWinding);
4988 pathB.moveTo(1, 4);
4989 pathB.cubicTo(0, 3, 1.66666675f, 2, 0, 2);
4990 pathB.close();
4991 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4992}

◆ loops55i()

static void loops55i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4994 of file PathOpsOpTest.cpp.

4994 {
4995 SkPath path, pathB;
4996 path.setFillType(SkPathFillType::kWinding);
4997 path.moveTo(0, 3);
4998 path.cubicTo(1, 5, 0, 4, 1.66666675f, 3);
4999 path.close();
5000 pathB.setFillType(SkPathFillType::kWinding);
5001 pathB.moveTo(1, 5);
5002 pathB.cubicTo(0, 4, 1.66666675f, 3, 0, 3);
5003 pathB.close();
5004 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5005}

◆ loops56i()

static void loops56i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5007 of file PathOpsOpTest.cpp.

5007 {
5008 SkPath path, pathB;
5009 path.setFillType(SkPathFillType::kWinding);
5010 path.moveTo(1, 2);
5011 path.cubicTo(2, 4, 0.99999994f, 3, 2.66666675f, 2);
5012 path.close();
5013 pathB.setFillType(SkPathFillType::kWinding);
5014 pathB.moveTo(2, 4);
5015 pathB.cubicTo(0.99999994f, 3, 2.66666675f, 2, 1, 2);
5016 pathB.close();
5017 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5018}

◆ loops57i()

static void loops57i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5020 of file PathOpsOpTest.cpp.

5020 {
5021 SkPath path, pathB;
5022 path.setFillType(SkPathFillType::kWinding);
5023 path.moveTo(1, 3);
5024 path.cubicTo(2, 5, 0.99999994f, 4, 2.66666675f, 3);
5025 path.close();
5026 pathB.setFillType(SkPathFillType::kWinding);
5027 pathB.moveTo(2, 5);
5028 pathB.cubicTo(0.99999994f, 4, 2.66666675f, 3, 1, 3);
5029 pathB.close();
5030 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5031}

◆ loops58i()

static void loops58i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5033 of file PathOpsOpTest.cpp.

5033 {
5034 SkPath path, pathB;
5035 path.setFillType(SkPathFillType::kWinding);
5036 path.moveTo(2, 3);
5037 path.cubicTo(3, 5, 2, 4, 3.66666651f, 3);
5038 path.close();
5039 pathB.setFillType(SkPathFillType::kWinding);
5040 pathB.moveTo(3, 5);
5041 pathB.cubicTo(2, 4, 3.66666651f, 3, 2, 3);
5042 pathB.close();
5043 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5044}

◆ loops58iAsQuads()

static void loops58iAsQuads ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5046 of file PathOpsOpTest.cpp.

5046 {
5047 SkPath path, pathB;
5048 path.setFillType(SkPathFillType::kWinding);
5049 path.moveTo(2, 3);
5050 path.cubicTo(3, 5, 2, 4, 3.66666651f, 3);
5051 path.close();
5052 pathB.setFillType(SkPathFillType::kWinding);
5053 pathB.moveTo(3, 5);
5054 pathB.cubicTo(2, 4, 3.66666651f, 3, 2, 3);
5055 pathB.close();
5056 SkPath qPath, qPathB;
5057 CubicPathToQuads(path, &qPath);
5058 CubicPathToQuads(pathB, &qPathB);
5059// SkPoint from = {2.61714339f,1.90228665f};
5060// SkPoint to = {2.617045833359139f,1.9013528935803314f};
5061// path_edit(from, to, &qPathB);
5062 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename);
5063}

◆ loops59i()

static void loops59i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5065 of file PathOpsOpTest.cpp.

5065 {
5066 SkPath path, pathB;
5067 path.setFillType(SkPathFillType::kWinding);
5068 path.moveTo(0, 6);
5069 path.cubicTo(1, 2, 7.33333302f, 1.66666663f, -7.5f, 2);
5070 path.close();
5071 pathB.setFillType(SkPathFillType::kWinding);
5072 pathB.moveTo(1, 2);
5073 pathB.cubicTo(7.33333302f, 1.66666663f, -7.5f, 2, 0, 6);
5074 pathB.close();
5075 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5076}

◆ loops59iasQuads()

static void loops59iasQuads ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5078 of file PathOpsOpTest.cpp.

5078 {
5079 SkPath path, pathB;
5080 path.setFillType(SkPathFillType::kWinding);
5081 path.moveTo(0, 6);
5082 path.cubicTo(1, 2, 7.33333302f, 1.66666663f, -7.5f, 2);
5083 path.close();
5084 pathB.setFillType(SkPathFillType::kWinding);
5085 pathB.moveTo(1, 2);
5086 pathB.cubicTo(7.33333302f, 1.66666663f, -7.5f, 2, 0, 6);
5087 pathB.close();
5088 SkPath qPath, qPathB;
5089 CubicPathToQuads(path, &qPath);
5090 CubicPathToQuads(pathB, &qPathB);
5091 SkPoint from = {2.61714339f,1.90228665f};
5092 SkPoint to = {2.617045833359139f,1.9013528935803314f};
5093 path_edit(from, to, &qPathB);
5094 testPathOp(reporter, qPath, qPathB, kIntersect_SkPathOp, filename);
5095}
path_edit
static void path_edit(const SkPoint &from, const SkPoint &to, SkPath *path)
Definition PathOpsOpTest.cpp:42

◆ loops5i()

static void loops5i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4276 of file PathOpsOpTest.cpp.

4276 {
4277 SkPath path, pathB;
4278 path.setFillType(SkPathFillType::kWinding);
4279 path.moveTo(1, 2);
4280 path.cubicTo(0, 2, 0, 2, 0.166666672f, 2.66666675f);
4281 path.close();
4282 pathB.setFillType(SkPathFillType::kWinding);
4283 pathB.moveTo(0, 2);
4284 pathB.cubicTo(0, 2, 0.166666672f, 2.66666675f, 1, 2);
4285 pathB.close();
4286 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4287}

◆ loops61i()

void loops61i ( skiatest::Reporter *  reporter,
const char *  filename 
)

Definition at line 5110 of file PathOpsOpTest.cpp.

5110 {
5111 SkPath path, pathB;
5112 path.setFillType(SkPathFillType::kWinding);
5113 path.moveTo(0, 1);
5114 path.cubicTo(1, 5, -6.33333302f, 0.666666627f, 8, -1);
5115 path.close();
5116 pathB.setFillType(SkPathFillType::kWinding);
5117 pathB.moveTo(1, 5);
5118 pathB.cubicTo(-6.33333302f, 0.666666627f, 8, -1, 0, 1);
5119 pathB.close();
5120 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5121}

◆ loops62i()

static void loops62i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5123 of file PathOpsOpTest.cpp.

5123 {
5124 SkPath path, pathB;
5125 path.setFillType(SkPathFillType::kWinding);
5126 path.moveTo(0, 2);
5127 path.cubicTo(1, 6, -6.33333302f, 1.66666663f, 8, 0);
5128 path.close();
5129 pathB.setFillType(SkPathFillType::kWinding);
5130 pathB.moveTo(1, 6);
5131 pathB.cubicTo(-6.33333302f, 1.66666663f, 8, 0, 0, 2);
5132 pathB.close();
5133 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5134}

◆ loops63i()

static void loops63i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5136 of file PathOpsOpTest.cpp.

5136 {
5137 SkPath path, pathB;
5138 path.setFillType(SkPathFillType::kWinding);
5139 path.moveTo(0, 1);
5140 path.cubicTo(2, 4, -4, -0.833333254f, 6, -3);
5141 path.close();
5142 pathB.setFillType(SkPathFillType::kWinding);
5143 pathB.moveTo(2, 4);
5144 pathB.cubicTo(-4, -0.833333254f, 6, -3, 0, 1);
5145 pathB.close();
5146 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5147}

◆ loops_i1()

static void loops_i1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5284 of file PathOpsOpTest.cpp.

5284 {
5285 SkPath path, pathB;
5286 path.setFillType(SkPathFillType::kWinding);
5287 path.moveTo(2, 3);
5288 path.cubicTo(0, 4, -0.333333343f, 4.66666651f, 3, 5.83333349f);
5289 path.close();
5290 pathB.setFillType(SkPathFillType::kWinding);
5291 pathB.moveTo(0, 4);
5292 pathB.cubicTo(-0.333333343f, 4.66666651f, 3, 5.83333349f, 2, 3);
5293 pathB.close();
5294 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5295}

◆ loops_i2()

static void loops_i2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5297 of file PathOpsOpTest.cpp.

5297 {
5298 SkPath path, pathB;
5299 path.setFillType(SkPathFillType::kWinding);
5300 path.moveTo(2, 4);
5301 path.cubicTo(0, 5, -0.333333343f, 5.66666651f, 3, 6.83333302f);
5302 path.close();
5303 pathB.setFillType(SkPathFillType::kWinding);
5304 pathB.moveTo(0, 5);
5305 pathB.cubicTo(-0.333333343f, 5.66666651f, 3, 6.83333302f, 2, 4);
5306 pathB.close();
5307 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5308}

◆ loops_i3()

static void loops_i3 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5310 of file PathOpsOpTest.cpp.

5310 {
5311 SkPath path, pathB;
5312 path.setFillType(SkPathFillType::kWinding);
5313 path.moveTo(2, 5);
5314 path.cubicTo(0, 6, -0.333333343f, 6.66666651f, 3, 7.83333302f);
5315 path.close();
5316 pathB.setFillType(SkPathFillType::kWinding);
5317 pathB.moveTo(0, 6);
5318 pathB.cubicTo(-0.333333343f, 6.66666651f, 3, 7.83333302f, 2, 5);
5319 pathB.close();
5320 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5321}

◆ loops_i4()

static void loops_i4 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5323 of file PathOpsOpTest.cpp.

5323 {
5324 SkPath path, pathB;
5325 path.setFillType(SkPathFillType::kWinding);
5326 path.moveTo(3, 4);
5327 path.cubicTo(1, 5, 0.666666627f, 5.66666651f, 4, 6.83333302f);
5328 path.close();
5329 pathB.setFillType(SkPathFillType::kWinding);
5330 pathB.moveTo(1, 5);
5331 pathB.cubicTo(0.666666627f, 5.66666651f, 4, 6.83333302f, 3, 4);
5332 pathB.close();
5333 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5334}

◆ loops_i5()

static void loops_i5 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5336 of file PathOpsOpTest.cpp.

5336 {
5337 SkPath path, pathB;
5338 path.setFillType(SkPathFillType::kWinding);
5339 path.moveTo(3, 5);
5340 path.cubicTo(1, 6, 0.666666627f, 6.66666651f, 4, 7.83333302f);
5341 path.close();
5342 pathB.setFillType(SkPathFillType::kWinding);
5343 pathB.moveTo(1, 6);
5344 pathB.cubicTo(0.666666627f, 6.66666651f, 4, 7.83333302f, 3, 5);
5345 pathB.close();
5346 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5347}

◆ loops_i6()

static void loops_i6 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5349 of file PathOpsOpTest.cpp.

5349 {
5350 SkPath path, pathB;
5351 path.setFillType(SkPathFillType::kWinding);
5352 path.moveTo(4, 5);
5353 path.cubicTo(2, 6, 1.66666663f, 6.66666651f, 5, 7.83333302f);
5354 path.close();
5355 pathB.setFillType(SkPathFillType::kWinding);
5356 pathB.moveTo(2, 6);
5357 pathB.cubicTo(1.66666663f, 6.66666651f, 5, 7.83333302f, 4, 5);
5358 pathB.close();
5359 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5360}

◆ op_1()

static void op_1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8966 of file PathOpsOpTest.cpp.

8966 {
8967 SkPath path;
8968 path.setFillType((SkPathFillType) 0);
8969path.setFillType(SkPathFillType::kWinding);
8970path.moveTo(SkBits2Float(0x15e80300), SkBits2Float(0x400004dc)); // 9.37088e-26f, 2.0003f
8971path.quadTo(SkBits2Float(0xe56c206c), SkBits2Float(0x646c5f40), SkBits2Float(0x6c80885e), SkBits2Float(0xb4bc576c)); // -6.96923e+22f, 1.74412e+22f, 1.24309e+27f, -3.50813e-07f
8972
8973 SkPath path1(path);
8974 path.reset();
8975 path.setFillType((SkPathFillType) 0);
8976path.setFillType(SkPathFillType::kWinding);
8977path.moveTo(SkBits2Float(0x1b000010), SkBits2Float(0x6e5a5a1b)); // 1.05879e-22f, 1.68942e+28f
8978path.quadTo(SkBits2Float(0xef646464), SkBits2Float(0xefefefef), SkBits2Float(0x000000ef), SkBits2Float(0x1bb4bc00)); // -7.06839e+28f, -1.48514e+29f, 3.3491e-43f, 2.99e-22f
8979
8980 SkPath path2(path);
8981 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
8982}

◆ op_2()

static void op_2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 8985 of file PathOpsOpTest.cpp.

8985 {
8986 SkPath path;
8987 path.setFillType((SkPathFillType) 1);
8988path.setFillType(SkPathFillType::kEvenOdd);
8989path.moveTo(SkBits2Float(0xeee3ef57), SkBits2Float(0xef6300f8)); // -3.52712e+28f, -7.02543e+28f
8990path.quadTo(SkBits2Float(0xeeee9c6e), SkBits2Float(0xef609993), SkBits2Float(0x00000000), SkBits2Float(0x6e5a5a1b)); // -3.69233e+28f, -6.95103e+28f, 0, 1.68942e+28f
8991path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8992path.quadTo(SkBits2Float(0xe56c206c), SkBits2Float(0x646c5f40), SkBits2Float(0x6c80885e), SkBits2Float(0x00000000)); // -6.96923e+22f, 1.74412e+22f, 1.24309e+27f, 0
8993path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
8994path.quadTo(SkBits2Float(0xeeda2c5a), SkBits2Float(0xef6533a7), SkBits2Float(0xeee3ef57), SkBits2Float(0xef6300f8)); // -3.37607e+28f, -7.09345e+28f, -3.52712e+28f, -7.02543e+28f
8995path.close();
8996
8997 SkPath path1(path);
8998 path.reset();
8999 path.setFillType((SkPathFillType) 0);
9000path.setFillType(SkPathFillType::kWinding);
9001path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
9002path.lineTo(SkBits2Float(0x1b1b1b00), SkBits2Float(0x1b5a5a1b)); // 1.283e-22f, 1.80617e-22f
9003
9004 SkPath path2(path);
9005 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
9006}

◆ op_3()

static void op_3 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9009 of file PathOpsOpTest.cpp.

9009 {
9010 SkPath path;
9011 path.setFillType((SkPathFillType) 1);
9012path.setFillType(SkPathFillType::kEvenOdd);
9013path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x6e5a5a1b)); // 0, 1.68942e+28f
9014path.quadTo(SkBits2Float(0xeeee9c6e), SkBits2Float(0xef609993), SkBits2Float(0xeee3ef57), SkBits2Float(0xef6300f8)); // -3.69233e+28f, -6.95103e+28f, -3.52712e+28f, -7.02543e+28f
9015path.quadTo(SkBits2Float(0xeeda2c5a), SkBits2Float(0xef6533a7), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // -3.37607e+28f, -7.09345e+28f, 0, 0
9016path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x6e5a5a1b)); // 0, 1.68942e+28f
9017path.close();
9018path.moveTo(SkBits2Float(0x6c80885e), SkBits2Float(0x00000000)); // 1.24309e+27f, 0
9019path.quadTo(SkBits2Float(0xe56c206c), SkBits2Float(0x646c5f40), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // -6.96923e+22f, 1.74412e+22f, 0, 0
9020path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
9021path.lineTo(SkBits2Float(0x6c80885e), SkBits2Float(0x00000000)); // 1.24309e+27f, 0
9022path.close();
9023
9024 SkPath path1(path);
9025 path.reset();
9026 path.setFillType((SkPathFillType) 0);
9027path.setFillType(SkPathFillType::kWinding);
9028
9029 SkPath path2(path);
9030 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 0, filename);
9031}

◆ op_4()

static void op_4 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 9033 of file PathOpsOpTest.cpp.

9033 {
9034 SkPath patha, pathb;
9035
9036 patha.setFillType(SkPathFillType::kEvenOdd);
9037 patha.moveTo(SkBits2Float(0x40d7ea90), SkBits2Float(0x3fa58930)); // 6.74738f, 1.29325f
9038 patha.lineTo(SkBits2Float(0x40ad3d93), SkBits2Float(0x3fa58930)); // 5.41377f, 1.29325f
9039 patha.lineTo(SkBits2Float(0x40ad3d93), SkBits2Float(0x3edba819)); // 5.41377f, 0.429017f
9040 patha.lineTo(SkBits2Float(0x40fc41e0), SkBits2Float(0x3edba819)); // 7.88304f, 0.429017f
9041 patha.lineTo(SkBits2Float(0x40fc41e0), SkBits2Float(0x3f3b7c94)); // 7.88304f, 0.73237f
9042 patha.lineTo(SkBits2Float(0x40d7ea90), SkBits2Float(0x3f3b7c94)); // 6.74738f, 0.73237f
9043 patha.lineTo(SkBits2Float(0x40d7ea90), SkBits2Float(0x3fa58930)); // 6.74738f, 1.29325f
9044 patha.close();
9045
9046 pathb.setFillType(SkPathFillType::kEvenOdd);
9047 pathb.moveTo(SkBits2Float(0x40d7ea89), SkBits2Float(0x409a721d)); // 6.74738f, 4.82643f
9048 pathb.lineTo(SkBits2Float(0x411a9d73), SkBits2Float(0x409a721d)); // 9.66344f, 4.82643f
9049 pathb.lineTo(SkBits2Float(0x411a9d73), SkBits2Float(0x3f3b7c9a)); // 9.66344f, 0.73237f
9050 pathb.lineTo(SkBits2Float(0x40d7ea89), SkBits2Float(0x3f3b7c9a)); // 6.74738f, 0.73237f
9051 pathb.lineTo(SkBits2Float(0x40d7ea89), SkBits2Float(0x409a721d)); // 6.74738f, 4.82643f
9052 pathb.close();
9053 testPathOp(reporter, patha, pathb, kDifference_SkPathOp, filename);
9054}

◆ path_edit()

static void path_edit ( const SkPoint &  from,
const SkPoint &  to,
SkPath *  path 
)
static

Definition at line 42 of file PathOpsOpTest.cpp.

42 {
43 PathTest_Private testPath(path);
44 for (int index = 0; index < path->countPoints(); ++index) {
45 if (SkDPoint::ApproximatelyEqual(path->getPoint(index), from)) {
46 testPath.setPt(index, to.fX, to.fY);
47 return;
48 }
49 }
50}
PathTest_Private
Definition PathOpsOpTest.cpp:30
SkDPoint::ApproximatelyEqual
static bool ApproximatelyEqual(const SkPoint &a, const SkPoint &b)
Definition SkPathOpsPoint.h:197
SkPoint::fX
float fX
x-axis value
Definition SkPoint_impl.h:164

◆ quadOp10i()

static void quadOp10i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3334 of file PathOpsOpTest.cpp.

3334 {
3335 SkPath path, pathB;
3336 path.moveTo(0, 0);
3337 path.quadTo(1, 8, 3, 5);
3338 path.lineTo(8, 1);
3339 path.close();
3340 pathB.moveTo(0, 0);
3341 pathB.quadTo(8, 1, 4, 8);
3342 pathB.close();
3343 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3344}

◆ quadOp9d()

static void quadOp9d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 156 of file PathOpsOpTest.cpp.

156 {
157 SkPath path, pathB;
158 path.setFillType(SkPathFillType::kWinding);
159 path.moveTo(0,1);
160 path.quadTo(1,6, 1.5f,1);
161 path.quadTo(1.5f,0.5f, 2,1);
162 path.close();
163 pathB.setFillType(SkPathFillType::kWinding);
164 pathB.moveTo(0,1);
165 pathB.quadTo(1,2, 1.4f,1);
166 pathB.quadTo(3,0.4f, 6,1);
167 pathB.close();
168 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
169}

◆ quadRect1()

static void quadRect1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4203 of file PathOpsOpTest.cpp.

4203 {
4204 SkPath path, pathB;
4205 path.moveTo(6,15);
4206 path.quadTo(16,0, 8,4);
4207 path.quadTo(2,7, 12,12);
4208 path.close();
4209 pathB.addRect(4,11, 13,16);
4210 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4211}

◆ quadRect2()

static void quadRect2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4213 of file PathOpsOpTest.cpp.

4213 {
4214 SkPath path, pathB;
4215 path.moveTo(5,12);
4216 path.quadTo(15,7, 9,4);
4217 path.quadTo(1,0, 11,15);
4218 path.close();
4219 pathB.addRect(4,11, 13,16);
4220 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4221}

◆ quadRect3()

static void quadRect3 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4223 of file PathOpsOpTest.cpp.

4223 {
4224 SkPath path, pathB;
4225 path.moveTo(12,12);
4226 path.quadTo(2,7, 8,4);
4227 path.quadTo(16,0, 6,15);
4228 path.close();
4229 pathB.addRect(4,11, 13,16);
4230 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4231}

◆ quadRect4()

static void quadRect4 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4233 of file PathOpsOpTest.cpp.

4233 {
4234 SkPath path, pathB;
4235 path.moveTo(11,15);
4236 path.quadTo(1,0, 9,4);
4237 path.quadTo(15,7, 5,12);
4238 path.close();
4239 pathB.addRect(4,11, 13,16);
4240 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4241}

◆ quadRect5()

static void quadRect5 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4243 of file PathOpsOpTest.cpp.

4243 {
4244 SkPath path, pathB;
4245 path.moveTo(11,13);
4246 path.quadTo(4,4, 8,4);
4247 path.quadTo(12,4, 5,13);
4248 path.close();
4249 pathB.addRect(4,11, 13,16);
4250 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4251}

◆ quadRect6()

static void quadRect6 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 4253 of file PathOpsOpTest.cpp.

4253 {
4254 SkPath path, pathB;
4255 path.moveTo(5,13);
4256 path.quadTo(12,4, 8,4);
4257 path.quadTo(4,4, 11,13);
4258 path.close();
4259 pathB.addRect(4,11, 13,16);
4260 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4261}

◆ rectOp1d()

static void rectOp1d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1120 of file PathOpsOpTest.cpp.

1120 {
1121 SkPath path, pathB;
1122 path.moveTo(0,1);
1123 path.cubicTo(0,1, 1,0, 3,0);
1124 path.lineTo(0,1);
1125 path.close();
1126 pathB.moveTo(0,1);
1127 pathB.cubicTo(0,3, 1,0, 1,0);
1128 pathB.lineTo(0,1);
1129 pathB.close();
1130 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1131}

◆ rectOp1i()

static void rectOp1i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2044 of file PathOpsOpTest.cpp.

2044 {
2045 SkPath path, pathB;
2046 path.setFillType(SkPathFillType::kWinding);
2047 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
2048 path.addRect(2, 2, 4, 4, SkPathDirection::kCW);
2049 pathB.setFillType(SkPathFillType::kWinding);
2050 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
2051 pathB.addRect(0, 0, 2, 2, SkPathDirection::kCW);
2052 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2053}

◆ rectOp2i()

static void rectOp2i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2055 of file PathOpsOpTest.cpp.

2055 {
2056 SkPath path, pathB;
2057 path.setFillType(SkPathFillType::kEvenOdd);
2058 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
2059 path.addRect(0, 0, 3, 3, SkPathDirection::kCW);
2060 pathB.setFillType(SkPathFillType::kWinding);
2061 pathB.addRect(0, 0, 2, 2, SkPathDirection::kCW);
2062 pathB.addRect(0, 0, 2, 2, SkPathDirection::kCW);
2063 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2064}

◆ rectOp3x()

static void rectOp3x ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2066 of file PathOpsOpTest.cpp.

2066 {
2067 SkPath path, pathB;
2068 path.setFillType(SkPathFillType::kEvenOdd);
2069 path.moveTo(0, 0);
2070 path.lineTo(3, 0);
2071 path.lineTo(3, 3);
2072 path.lineTo(0, 3);
2073 path.close();
2074 path.moveTo(2, 2);
2075 path.lineTo(3, 2);
2076 path.lineTo(3, 3);
2077 path.lineTo(2, 3);
2078 path.close();
2079 pathB.setFillType(SkPathFillType::kWinding);
2080 pathB.moveTo(1, 1);
2081 pathB.lineTo(3, 1);
2082 pathB.lineTo(3, 3);
2083 pathB.lineTo(1, 3);
2084 pathB.close();
2085 pathB.moveTo(2, 2);
2086 pathB.lineTo(3, 2);
2087 pathB.lineTo(3, 3);
2088 pathB.lineTo(2, 3);
2089 pathB.close();
2090 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
2091}

◆ rects1()

static void rects1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3404 of file PathOpsOpTest.cpp.

3404 {
3405 SkPath path, pathB;
3406 path.setFillType(SkPathFillType::kEvenOdd);
3407 path.moveTo(0, 0);
3408 path.lineTo(1, 0);
3409 path.lineTo(1, 1);
3410 path.lineTo(0, 1);
3411 path.close();
3412 path.moveTo(0, 0);
3413 path.lineTo(6, 0);
3414 path.lineTo(6, 6);
3415 path.lineTo(0, 6);
3416 path.close();
3417 pathB.setFillType(SkPathFillType::kEvenOdd);
3418 pathB.moveTo(0, 0);
3419 pathB.lineTo(1, 0);
3420 pathB.lineTo(1, 1);
3421 pathB.lineTo(0, 1);
3422 pathB.close();
3423 pathB.moveTo(0, 0);
3424 pathB.lineTo(2, 0);
3425 pathB.lineTo(2, 2);
3426 pathB.lineTo(0, 2);
3427 pathB.close();
3428 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3429}

◆ rects2()

static void rects2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3431 of file PathOpsOpTest.cpp.

3431 {
3432 SkPath path, pathB;
3433 path.setFillType(SkPathFillType::kEvenOdd);
3434 path.moveTo(0, 0);
3435 path.lineTo(4, 0);
3436 path.lineTo(4, 4);
3437 path.lineTo(0, 4);
3438 path.close();
3439 path.moveTo(3, 3);
3440 path.lineTo(4, 3);
3441 path.lineTo(4, 4);
3442 path.lineTo(3, 4);
3443 path.close();
3444 pathB.setFillType(SkPathFillType::kWinding);
3445 pathB.moveTo(3, 3);
3446 pathB.lineTo(6, 3);
3447 pathB.lineTo(6, 6);
3448 pathB.lineTo(3, 6);
3449 pathB.close();
3450 pathB.moveTo(3, 3);
3451 pathB.lineTo(4, 3);
3452 pathB.lineTo(4, 4);
3453 pathB.lineTo(3, 4);
3454 pathB.close();
3455 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3456}

◆ rects3()

static void rects3 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3458 of file PathOpsOpTest.cpp.

3458 {
3459 SkPath path, pathB;
3460 path.setFillType(SkPathFillType::kEvenOdd);
3461 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
3462 path.addRect(0, 0, 4, 4, SkPathDirection::kCW);
3463 pathB.setFillType(SkPathFillType::kWinding);
3464 pathB.addRect(0, 0, 2, 2, SkPathDirection::kCW);
3465 pathB.addRect(0, 0, 2, 2, SkPathDirection::kCW);
3466 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3467}

◆ rects4()

static void rects4 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3469 of file PathOpsOpTest.cpp.

3469 {
3470 SkPath path, pathB;
3471 path.setFillType(SkPathFillType::kEvenOdd);
3472 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
3473 path.addRect(0, 0, 2, 2, SkPathDirection::kCW);
3474 pathB.setFillType(SkPathFillType::kWinding);
3475 pathB.addRect(0, 0, 2, 2, SkPathDirection::kCW);
3476 pathB.addRect(0, 0, 3, 3, SkPathDirection::kCW);
3477 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3478}

◆ rects5()

static void rects5 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3984 of file PathOpsOpTest.cpp.

3984 {
3985 SkPath path, pathB;
3986 path.setFillType(SkPathFillType::kWinding);
3987 path.addRect(5, 5, 6, 6, SkPathDirection::kCW);
3988 path.addRect(5, 5, 6, 6, SkPathDirection::kCW);
3989 pathB.setFillType(SkPathFillType::kEvenOdd);
3990 pathB.addRect(0, 0, 6, 6, SkPathDirection::kCW);
3991 pathB.addRect(5, 5, 6, 6, SkPathDirection::kCW);
3992 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3993}

◆ release_13()

static void release_13 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 12197 of file PathOpsOpTest.cpp.

12197 {
12198 SkPath path;
12199 path.setFillType((SkPathFillType) 1);
12200path.setFillType(SkPathFillType::kEvenOdd);
12201path.moveTo(SkBits2Float(0xd4438848), SkBits2Float(0xd488cf64)); // -3.35922e+12f, -4.70076e+12f
12202path.lineTo(SkBits2Float(0xd43a056e), SkBits2Float(0xd4851696)); // -3.19582e+12f, -4.57288e+12f
12203path.quadTo(SkBits2Float(0xd3d48e79), SkBits2Float(0xd49fb136), SkBits2Float(0x00000000), SkBits2Float(0xd4d4d4d4)); // -1.82585e+12f, -5.48698e+12f, 0, -7.31283e+12f
12204path.quadTo(SkBits2Float(0xd3d06670), SkBits2Float(0xd4a0bb38), SkBits2Float(0xd41d628f), SkBits2Float(0xd472c531)); // -1.79014e+12f, -5.52269e+12f, -2.70385e+12f, -4.17076e+12f
12205path.lineTo(SkBits2Float(0xd43a0559), SkBits2Float(0xd485168e)); // -3.19581e+12f, -4.57287e+12f
12206path.lineTo(SkBits2Float(0xd446958b), SkBits2Float(0xd4810278)); // -3.41165e+12f, -4.43274e+12f
12207path.lineTo(SkBits2Float(0xd443884a), SkBits2Float(0xd488cf65)); // -3.35922e+12f, -4.70076e+12f
12208path.quadTo(SkBits2Float(0xd47efa09), SkBits2Float(0xd49fd72a), SkBits2Float(0xd4a63f0f), SkBits2Float(0xd4b83ab3)); // -4.38047e+12f, -5.49208e+12f, -5.71218e+12f, -6.33007e+12f
12209path.lineTo(SkBits2Float(0xd497ca70), SkBits2Float(0xd4c4d4ae)); // -5.21549e+12f, -6.76305e+12f
12210path.lineTo(SkBits2Float(0xd459d4d4), SkBits2Float(0xd4c4d4d4)); // -3.74231e+12f, -6.76307e+12f
12211path.lineTo(SkBits2Float(0xd440daf9), SkBits2Float(0xd4c632d3)); // -3.31323e+12f, -6.81005e+12f
12212path.lineTo(SkBits2Float(0xd4438848), SkBits2Float(0xd488cf64)); // -3.35922e+12f, -4.70076e+12f
12213path.close();
12214path.moveTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f
12215path.lineTo(SkBits2Float(0xd4422174), SkBits2Float(0xd4d02069)); // -3.33514e+12f, -7.15118e+12f
12216path.lineTo(SkBits2Float(0xd440daa3), SkBits2Float(0xd4c632d9)); // -3.31321e+12f, -6.81005e+12f
12217path.lineTo(SkBits2Float(0xd41017bc), SkBits2Float(0xd4cb99b6)); // -2.47549e+12f, -6.99566e+12f
12218path.lineTo(SkBits2Float(0xd442213b), SkBits2Float(0xd4d02067)); // -3.33512e+12f, -7.15117e+12f
12219path.lineTo(SkBits2Float(0xd442d4d4), SkBits2Float(0xd4d4d4d4)); // -3.34718e+12f, -7.31283e+12f
12220path.lineTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f
12221path.close();
12222path.moveTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f
12223path.lineTo(SkBits2Float(0xd484e02c), SkBits2Float(0xd45fafcd)); // -4.56557e+12f, -3.84291e+12f
12224path.lineTo(SkBits2Float(0xd462c867), SkBits2Float(0xd45655f7)); // -3.8961e+12f, -3.68226e+12f
12225path.lineTo(SkBits2Float(0xd45ac463), SkBits2Float(0xd45ac505)); // -3.75839e+12f, -3.75843e+12f
12226path.lineTo(SkBits2Float(0xd43d2fa9), SkBits2Float(0xd43d2fb5)); // -3.25019e+12f, -3.2502e+12f
12227path.lineTo(SkBits2Float(0xd41d6287), SkBits2Float(0xd472c52a)); // -2.70385e+12f, -4.17076e+12f
12228path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0xd3db1b95), SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, -1.88212e+12f, 0, 0
12229path.quadTo(SkBits2Float(0xd4b7efac), SkBits2Float(0x00000000), SkBits2Float(0xd4d0e88f), SkBits2Float(0xd40b8b46)); // -6.32e+12f, 0, -7.17804e+12f, -2.39735e+12f
12230path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0x00000000)); // -7.31283e+12f, 0
12231path.lineTo(SkBits2Float(0xdcdc154b), SkBits2Float(0x00000000)); // -4.95583e+17f, 0
12232path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4c4d477)); // -7.31283e+12f, -6.76303e+12f
12233path.lineTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d442)); // -7.31283e+12f, -7.31275e+12f
12234path.lineTo(SkBits2Float(0xd4d4a691), SkBits2Float(0xd4d4d442)); // -7.30662e+12f, -7.31275e+12f
12235path.lineTo(SkBits2Float(0xd454d4d4), SkBits2Float(0xd4d4aa30)); // -3.65641e+12f, -7.30711e+12f
12236path.lineTo(SkBits2Float(0xd4bd9def), SkBits2Float(0xd4d43df0)); // -6.51519e+12f, -7.29258e+12f
12237path.lineTo(SkBits2Float(0xd4767560), SkBits2Float(0xd4d1ca84)); // -4.23412e+12f, -7.20837e+12f
12238path.lineTo(SkBits2Float(0xd497ca70), SkBits2Float(0xd4c4d4ae)); // -5.21549e+12f, -6.76305e+12f
12239path.lineTo(SkBits2Float(0xd4bab953), SkBits2Float(0xd4c4d48e)); // -6.41579e+12f, -6.76304e+12f
12240path.lineTo(SkBits2Float(0xd4a63f0f), SkBits2Float(0xd4b83ab3)); // -5.71218e+12f, -6.33007e+12f
12241path.lineTo(SkBits2Float(0xd4ae61eb), SkBits2Float(0xd4ae61f4)); // -5.99174e+12f, -5.99174e+12f
12242path.lineTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f
12243path.close();
12244path.moveTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f
12245path.lineTo(SkBits2Float(0xd446965c), SkBits2Float(0xd4810237)); // -3.4117e+12f, -4.4327e+12f
12246path.lineTo(SkBits2Float(0xd45ac549), SkBits2Float(0xd45ac55f)); // -3.75845e+12f, -3.75846e+12f
12247path.lineTo(SkBits2Float(0xd46c7a11), SkBits2Float(0xd46c7a2e)); // -4.06264e+12f, -4.06265e+12f
12248path.close();
12249path.moveTo(SkBits2Float(0xd4b46028), SkBits2Float(0xd41e572a)); // -6.19766e+12f, -2.72027e+12f
12250path.lineTo(SkBits2Float(0xd4cde20a), SkBits2Float(0xd434bb57)); // -7.07408e+12f, -3.10495e+12f
12251path.lineTo(SkBits2Float(0xd4c75ffe), SkBits2Float(0xd46f215d)); // -6.85047e+12f, -4.10823e+12f
12252path.lineTo(SkBits2Float(0xd4b46028), SkBits2Float(0xd41e572a)); // -6.19766e+12f, -2.72027e+12f
12253path.close();
12254
12255 SkPath path1(path);
12256 path.reset();
12257 path.setFillType((SkPathFillType) 0);
12258path.setFillType(SkPathFillType::kWinding);
12259path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
12260path.quadTo(SkBits2Float(0x00000000), SkBits2Float(0xa5a50000), SkBits2Float(0xd4d4a5a5), SkBits2Float(0xd4d4d4d4)); // 0, -2.86229e-16f, -7.3065e+12f, -7.31283e+12f
12261path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4cfd4d4), SkBits2Float(0xd4d41dd4)); // -7.31283e+12f, -7.31283e+12f, -7.14103e+12f, -7.28827e+12f
12262path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d432d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4a5a5d4)); // -7.31283e+12f, -7.29109e+12f, -7.31283e+12f, -5.69161e+12f
12263path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0x00000000)); // -7.31283e+12f, -7.31283e+12f, -7.31283e+12f, 0
12264path.moveTo(SkBits2Float(0xa5a5a500), SkBits2Float(0xd4d4d4a5)); // -2.87347e-16f, -7.31281e+12f
12265path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0x2ad4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4cfd4d4)); // -7.31283e+12f, 3.78064e-13f, -7.31283e+12f, -7.14103e+12f
12266path.quadTo(SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4)); // -7.31283e+12f, -7.31283e+12f, -7.31283e+12f, -7.31283e+12f
12267path.quadTo(SkBits2Float(0xd4d40000), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4), SkBits2Float(0xd4d4d4d4)); // -7.28426e+12f, -7.31283e+12f, -7.31283e+12f, -7.31283e+12f
12268
12269 SkPath path2(path);
12270 testPathOpFuzz(reporter, path1, path2, (SkPathOp) 2, filename);
12271}

◆ rRect1()

static void rRect1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1189 of file PathOpsOpTest.cpp.

1189 {
1190 SkScalar xA = 0.65f;
1191 SkScalar xB = 10.65f;
1192 SkScalar xC = 20.65f;
1193 SkScalar xD = 30.65f;
1194 SkScalar xE = 40.65f;
1195 SkScalar xF = 50.65f;
1196
1197 SkScalar yA = 0.65f;
1198 SkScalar yB = 10.65f;
1199 SkScalar yC = 20.65f;
1200 SkScalar yD = 30.65f;
1201 SkScalar yE = 40.65f;
1202 SkScalar yF = 50.65f;
1203 SkPath paths[5];
1204 SkRect rects[5];
1205 rects[0].setLTRB(xB, yB, xE, yE);
1206 paths[0].addRoundRect(rects[0], SkIntToScalar(5), SkIntToScalar(5)); // red
1207 rects[1].setLTRB(xA, yA, xD, yD);
1208 paths[1].addRoundRect(rects[1], SkIntToScalar(5), SkIntToScalar(5)); // green
1209 rects[2].setLTRB(xC, yA, xF, yD);
1210 paths[2].addRoundRect(rects[2], SkIntToScalar(5), SkIntToScalar(5)); // blue
1211 rects[3].setLTRB(xA, yC, xD, yF);
1212 paths[3].addRoundRect(rects[3], SkIntToScalar(5), SkIntToScalar(5)); // yellow
1213 rects[4].setLTRB(xC, yC, xF, yF);
1214 paths[4].addRoundRect(rects[4], SkIntToScalar(5), SkIntToScalar(5)); // cyan
1215 SkPath path;
1216 path.setFillType(SkPathFillType::kInverseEvenOdd);
1217 for (int index = 0; index < 5; ++index) {
1218 SkString uniqueName;
1219 uniqueName.printf("%s%d", filename, index);
1220 testPathOp(reporter, path, paths[index], ops[index], uniqueName.c_str());
1221 REPORTER_ASSERT(reporter, Op(path, paths[index], ops[index], &path));
1222 }
1223}
ops
SkPathOp ops[]
Definition PathOpsOpTest.cpp:1181
SkIntToScalar
#define SkIntToScalar(x)
Definition SkScalar.h:57
REPORTER_ASSERT
#define REPORTER_ASSERT(r, cond,...)
Definition Test.h:286
SkPath::addRoundRect
SkPath & addRoundRect(const SkRect &rect, SkScalar rx, SkScalar ry, SkPathDirection dir=SkPathDirection::kCW)
Definition SkPath.cpp:1088
SkString::printf
void printf(const char format[],...) SK_PRINTF_LIKE(2
Definition SkString.cpp:534
SkString::c_str
const char * c_str() const
Definition SkString.h:133
skcms_private::Op
Op
Definition skcms_Transform.h:106
SkRect::setLTRB
void setLTRB(float left, float top, float right, float bottom)
Definition SkRect.h:865

◆ rRect1x()

static void rRect1x ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3929 of file PathOpsOpTest.cpp.

3929 {
3930 SkPath path, pathB;
3931 path.setFillType(SkPathFillType::kEvenOdd);
3932 path.moveTo(20.65f, 5.65f);
3933 path.conicTo(20.65f, 1.13612f, 25.1404f, 0.65f, 0.888488f);
3934 path.lineTo(25.65f, 0.65f);
3935 path.lineTo(26.1596f, 0.67604f);
3936 path.conicTo(30.65f, 1.13612f, 30.65f, 5.65f, 0.888488f);
3937 path.lineTo(30.65f, 25.65f);
3938 path.conicTo(30.65f, 20.65f, 25.65f, 20.65f, 0.707107f);
3939 path.lineTo(20.65f, 20.65f);
3940 path.lineTo(20.65f, 5.65f);
3941 path.close();
3942 path.moveTo(20.65f, 20.65f);
3943 path.lineTo(5.65f, 20.65f);
3944 path.conicTo(0.65f, 20.65f, 0.65f, 25.65f, 0.707107f);
3945 path.lineTo(0.65f, 45.65f);
3946 path.conicTo(0.65f, 50.65f, 5.65f, 50.65f, 0.707107f);
3947 path.lineTo(25.65f, 50.65f);
3948 path.conicTo(30.65f, 50.65f, 30.65f, 45.65f, 0.707107f);
3949 path.lineTo(30.65f, 25.65f);
3950 path.conicTo(30.65f, 30.65f, 25.65f, 30.65f, 0.707107f);
3951 path.conicTo(20.65f, 30.65f, 20.65f, 25.65f, 0.707107f);
3952 path.lineTo(20.65f, 20.65f);
3953 path.close();
3954 SkPath path1(path);
3955
3956 path.reset();
3957 path.setFillType(SkPathFillType::kWinding);
3958 path.moveTo(20.65f, 45.65f);
3959 path.lineTo(20.65f, 25.65f);
3960 path.conicTo(20.65f, 20.65f, 25.65f, 20.65f, 0.707107f);
3961 path.lineTo(45.65f, 20.65f);
3962 path.conicTo(50.65f, 20.65f, 50.65f, 25.65f, 0.707107f);
3963 path.lineTo(50.65f, 45.65f);
3964 path.conicTo(50.65f, 50.65f, 45.65f, 50.65f, 0.707107f);
3965 path.lineTo(25.65f, 50.65f);
3966 path.conicTo(20.65f, 50.65f, 20.65f, 45.65f, 0.707107f);
3967 path.close();
3968 SkPath path2(path);
3969
3970 testPathOp(reporter, path1, path2, kDifference_SkPathOp, filename);
3971}

◆ seanbug()

static void seanbug ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5449 of file PathOpsOpTest.cpp.

5449 {
5450 SkPath path;
5451 path.setFillType(SkPathFillType::kEvenOdd);
5452 path.moveTo(SkBits2Float(0x45b56000), SkBits2Float(0x45bca000)); // 5804, 6036
5453 path.lineTo(SkBits2Float(0x45b55f0a), SkBits2Float(0x45bc9fc0)); // 5803.88f, 6035.97f
5454 path.lineTo(SkBits2Float(0x45b55e15), SkBits2Float(0x45bc9f7b)); // 5803.76f, 6035.94f
5455 path.lineTo(SkBits2Float(0x45b55d1f), SkBits2Float(0x45bc9f32)); // 5803.64f, 6035.9f
5456 path.lineTo(SkBits2Float(0x45b55c29), SkBits2Float(0x45bc9ee3)); // 5803.52f, 6035.86f
5457 path.lineTo(SkBits2Float(0x45b55b34), SkBits2Float(0x45bc9e90)); // 5803.4f, 6035.82f
5458 path.lineTo(SkBits2Float(0x45b55a3f), SkBits2Float(0x45bc9e38)); // 5803.28f, 6035.78f
5459 path.lineTo(SkBits2Float(0x45b5594a), SkBits2Float(0x45bc9ddc)); // 5803.16f, 6035.73f
5460 path.lineTo(SkBits2Float(0x45b55856), SkBits2Float(0x45bc9d7a)); // 5803.04f, 6035.68f
5461 path.lineTo(SkBits2Float(0x45b55762), SkBits2Float(0x45bc9d14)); // 5802.92f, 6035.63f
5462 path.lineTo(SkBits2Float(0x45b5566f), SkBits2Float(0x45bc9caa)); // 5802.8f, 6035.58f
5463 path.lineTo(SkBits2Float(0x45b5557c), SkBits2Float(0x45bc9c3b)); // 5802.69f, 6035.53f
5464 path.lineTo(SkBits2Float(0x45b55489), SkBits2Float(0x45bc9bc7)); // 5802.57f, 6035.47f
5465 path.lineTo(SkBits2Float(0x45b55397), SkBits2Float(0x45bc9b4f)); // 5802.45f, 6035.41f
5466 path.lineTo(SkBits2Float(0x45b552a6), SkBits2Float(0x45bc9ad3)); // 5802.33f, 6035.35f
5467 path.lineTo(SkBits2Float(0x45b551b5), SkBits2Float(0x45bc9a52)); // 5802.21f, 6035.29f
5468 path.lineTo(SkBits2Float(0x45b550c5), SkBits2Float(0x45bc99cd)); // 5802.1f, 6035.23f
5469 path.lineTo(SkBits2Float(0x45b54fd6), SkBits2Float(0x45bc9943)); // 5801.98f, 6035.16f
5470 path.lineTo(SkBits2Float(0x45b54ee8), SkBits2Float(0x45bc98b6)); // 5801.86f, 6035.09f
5471 path.lineTo(SkBits2Float(0x45b54dfb), SkBits2Float(0x45bc9824)); // 5801.75f, 6035.02f
5472 path.lineTo(SkBits2Float(0x45b54d0e), SkBits2Float(0x45bc978d)); // 5801.63f, 6034.94f
5473 path.lineTo(SkBits2Float(0x45b54c23), SkBits2Float(0x45bc96f3)); // 5801.52f, 6034.87f
5474 path.lineTo(SkBits2Float(0x45b54b39), SkBits2Float(0x45bc9654)); // 5801.4f, 6034.79f
5475 path.lineTo(SkBits2Float(0x45b54a4f), SkBits2Float(0x45bc95b2)); // 5801.29f, 6034.71f
5476 path.lineTo(SkBits2Float(0x45b54967), SkBits2Float(0x45bc950b)); // 5801.18f, 6034.63f
5477 path.lineTo(SkBits2Float(0x45b54880), SkBits2Float(0x45bc9460)); // 5801.06f, 6034.55f
5478 path.lineTo(SkBits2Float(0x45b5479a), SkBits2Float(0x45bc93b1)); // 5800.95f, 6034.46f
5479 path.lineTo(SkBits2Float(0x45b546b6), SkBits2Float(0x45bc92fe)); // 5800.84f, 6034.37f
5480 path.lineTo(SkBits2Float(0x45b545d3), SkBits2Float(0x45bc9248)); // 5800.73f, 6034.29f
5481 path.lineTo(SkBits2Float(0x45b544f1), SkBits2Float(0x45bc918d)); // 5800.62f, 6034.19f
5482 path.lineTo(SkBits2Float(0x45b54410), SkBits2Float(0x45bc90cf)); // 5800.51f, 6034.1f
5483 path.lineTo(SkBits2Float(0x45b54331), SkBits2Float(0x45bc900d)); // 5800.4f, 6034.01f
5484 path.lineTo(SkBits2Float(0x45b54254), SkBits2Float(0x45bc8f47)); // 5800.29f, 6033.91f
5485 path.lineTo(SkBits2Float(0x45b54178), SkBits2Float(0x45bc8e7d)); // 5800.18f, 6033.81f
5486 path.lineTo(SkBits2Float(0x45b5409e), SkBits2Float(0x45bc8db0)); // 5800.08f, 6033.71f
5487 path.lineTo(SkBits2Float(0x45b53fc6), SkBits2Float(0x45bc8cde)); // 5799.97f, 6033.61f
5488 path.lineTo(SkBits2Float(0x45b53eef), SkBits2Float(0x45bc8c0a)); // 5799.87f, 6033.5f
5489 path.lineTo(SkBits2Float(0x45b53e1a), SkBits2Float(0x45bc8b31)); // 5799.76f, 6033.4f
5490 path.lineTo(SkBits2Float(0x45b53d47), SkBits2Float(0x45bc8a56)); // 5799.66f, 6033.29f
5491 path.lineTo(SkBits2Float(0x45b53c75), SkBits2Float(0x45bc8976)); // 5799.56f, 6033.18f
5492 path.lineTo(SkBits2Float(0x45b53ba6), SkBits2Float(0x45bc8893)); // 5799.46f, 6033.07f
5493 path.lineTo(SkBits2Float(0x45b53ad8), SkBits2Float(0x45bc87ad)); // 5799.36f, 6032.96f
5494 path.lineTo(SkBits2Float(0x45b53a0d), SkBits2Float(0x45bc86c4)); // 5799.26f, 6032.85f
5495 path.lineTo(SkBits2Float(0x45b53944), SkBits2Float(0x45bc85d6)); // 5799.16f, 6032.73f
5496 path.lineTo(SkBits2Float(0x45b5387c), SkBits2Float(0x45bc84e6)); // 5799.06f, 6032.61f
5497 path.lineTo(SkBits2Float(0x45b537b7), SkBits2Float(0x45bc83f2)); // 5798.96f, 6032.49f
5498 path.lineTo(SkBits2Float(0x45b536f4), SkBits2Float(0x45bc82fc)); // 5798.87f, 6032.37f
5499 path.lineTo(SkBits2Float(0x45b53634), SkBits2Float(0x45bc8201)); // 5798.78f, 6032.25f
5500 path.lineTo(SkBits2Float(0x45b53575), SkBits2Float(0x45bc8104)); // 5798.68f, 6032.13f
5501 path.lineTo(SkBits2Float(0x45b534ba), SkBits2Float(0x45bc8004)); // 5798.59f, 6032
5502 path.lineTo(SkBits2Float(0x45b53400), SkBits2Float(0x45bc7f00)); // 5798.5f, 6031.88f
5503 path.lineTo(SkBits2Float(0x45b53349), SkBits2Float(0x45bc7df9)); // 5798.41f, 6031.75f
5504 path.lineTo(SkBits2Float(0x45b53294), SkBits2Float(0x45bc7cf0)); // 5798.32f, 6031.62f
5505 path.lineTo(SkBits2Float(0x45b531e2), SkBits2Float(0x45bc7be3)); // 5798.24f, 6031.49f
5506 path.lineTo(SkBits2Float(0x45b53133), SkBits2Float(0x45bc7ad3)); // 5798.15f, 6031.35f
5507 path.lineTo(SkBits2Float(0x45b53086), SkBits2Float(0x45bc79c1)); // 5798.07f, 6031.22f
5508 path.lineTo(SkBits2Float(0x45b52fdc), SkBits2Float(0x45bc78ab)); // 5797.98f, 6031.08f
5509 path.lineTo(SkBits2Float(0x45b52f35), SkBits2Float(0x45bc7793)); // 5797.9f, 6030.95f
5510 path.lineTo(SkBits2Float(0x45b52e90), SkBits2Float(0x45bc7678)); // 5797.82f, 6030.81f
5511 path.lineTo(SkBits2Float(0x45b52def), SkBits2Float(0x45bc755a)); // 5797.74f, 6030.67f
5512 path.lineTo(SkBits2Float(0x45b52d50), SkBits2Float(0x45bc7439)); // 5797.66f, 6030.53f
5513 path.lineTo(SkBits2Float(0x45b52cb4), SkBits2Float(0x45bc7316)); // 5797.59f, 6030.39f
5514 path.lineTo(SkBits2Float(0x45b52c1b), SkBits2Float(0x45bc71f0)); // 5797.51f, 6030.24f
5515 path.lineTo(SkBits2Float(0x45b52b86), SkBits2Float(0x45bc70c7)); // 5797.44f, 6030.1f
5516 path.lineTo(SkBits2Float(0x45b52af3), SkBits2Float(0x45bc6f9c)); // 5797.37f, 6029.95f
5517 path.lineTo(SkBits2Float(0x45b52a63), SkBits2Float(0x45bc6e6e)); // 5797.3f, 6029.8f
5518 path.lineTo(SkBits2Float(0x45b529d7), SkBits2Float(0x45bc6d3e)); // 5797.23f, 6029.66f
5519 path.lineTo(SkBits2Float(0x45b5294e), SkBits2Float(0x45bc6c0b)); // 5797.16f, 6029.51f
5520 path.lineTo(SkBits2Float(0x45b528c8), SkBits2Float(0x45bc6ad6)); // 5797.1f, 6029.35f
5521 path.lineTo(SkBits2Float(0x45b52846), SkBits2Float(0x45bc699e)); // 5797.03f, 6029.2f
5522 path.lineTo(SkBits2Float(0x45b527c7), SkBits2Float(0x45bc6864)); // 5796.97f, 6029.05f
5523 path.lineTo(SkBits2Float(0x45b5274b), SkBits2Float(0x45bc6728)); // 5796.91f, 6028.89f
5524 path.lineTo(SkBits2Float(0x45b526d3), SkBits2Float(0x45bc65e9)); // 5796.85f, 6028.74f
5525 path.lineTo(SkBits2Float(0x45b5265e), SkBits2Float(0x45bc64a8)); // 5796.8f, 6028.58f
5526 path.lineTo(SkBits2Float(0x45b52600), SkBits2Float(0x45bc639b)); // 5796.75f, 6028.45f
5527 path.lineTo(SkBits2Float(0x45b52600), SkBits2Float(0x45bab032)); // 5796.75f, 5974.02f
5528 path.lineTo(SkBits2Float(0x45b52611), SkBits2Float(0x45baaffd)); // 5796.76f, 5974
5529 path.lineTo(SkBits2Float(0x45b52687), SkBits2Float(0x45baae9d)); // 5796.82f, 5973.83f
5530 path.lineTo(SkBits2Float(0x45b52700), SkBits2Float(0x45baad40)); // 5796.88f, 5973.66f
5531 path.lineTo(SkBits2Float(0x45b5277d), SkBits2Float(0x45baabe7)); // 5796.94f, 5973.49f
5532 path.lineTo(SkBits2Float(0x45b527fe), SkBits2Float(0x45baaa91)); // 5797, 5973.32f
5533 path.lineTo(SkBits2Float(0x45b52883), SkBits2Float(0x45baa93f)); // 5797.06f, 5973.16f
5534 path.lineTo(SkBits2Float(0x45b5290b), SkBits2Float(0x45baa7f1)); // 5797.13f, 5972.99f
5535 path.lineTo(SkBits2Float(0x45b52998), SkBits2Float(0x45baa6a6)); // 5797.2f, 5972.83f
5536 path.lineTo(SkBits2Float(0x45b52a28), SkBits2Float(0x45baa55f)); // 5797.27f, 5972.67f
5537 path.lineTo(SkBits2Float(0x45b52abb), SkBits2Float(0x45baa41c)); // 5797.34f, 5972.51f
5538 path.lineTo(SkBits2Float(0x45b52b52), SkBits2Float(0x45baa2dc)); // 5797.42f, 5972.36f
5539 path.lineTo(SkBits2Float(0x45b52bed), SkBits2Float(0x45baa1a0)); // 5797.49f, 5972.2f
5540 path.lineTo(SkBits2Float(0x45b52c8c), SkBits2Float(0x45baa068)); // 5797.57f, 5972.05f
5541 path.lineTo(SkBits2Float(0x45b52d2e), SkBits2Float(0x45ba9f34)); // 5797.65f, 5971.9f
5542 path.lineTo(SkBits2Float(0x45b52dd3), SkBits2Float(0x45ba9e04)); // 5797.73f, 5971.75f
5543 path.lineTo(SkBits2Float(0x45b52e7c), SkBits2Float(0x45ba9cd8)); // 5797.81f, 5971.61f
5544 path.lineTo(SkBits2Float(0x45b52f28), SkBits2Float(0x45ba9baf)); // 5797.89f, 5971.46f
5545 path.lineTo(SkBits2Float(0x45b52fd8), SkBits2Float(0x45ba9a8b)); // 5797.98f, 5971.32f
5546 path.lineTo(SkBits2Float(0x45b5308b), SkBits2Float(0x45ba996b)); // 5798.07f, 5971.18f
5547 path.lineTo(SkBits2Float(0x45b53141), SkBits2Float(0x45ba984f)); // 5798.16f, 5971.04f
5548 path.lineTo(SkBits2Float(0x45b531fa), SkBits2Float(0x45ba9736)); // 5798.25f, 5970.9f
5549 path.lineTo(SkBits2Float(0x45b532b7), SkBits2Float(0x45ba9623)); // 5798.34f, 5970.77f
5550 path.lineTo(SkBits2Float(0x45b53377), SkBits2Float(0x45ba9513)); // 5798.43f, 5970.63f
5551 path.lineTo(SkBits2Float(0x45b5343a), SkBits2Float(0x45ba9407)); // 5798.53f, 5970.5f
5552 path.lineTo(SkBits2Float(0x45b53500), SkBits2Float(0x45ba9300)); // 5798.63f, 5970.38f
5553 path.lineTo(SkBits2Float(0x45b535c9), SkBits2Float(0x45ba91fd)); // 5798.72f, 5970.25f
5554 path.lineTo(SkBits2Float(0x45b53695), SkBits2Float(0x45ba90fe)); // 5798.82f, 5970.12f
5555 path.lineTo(SkBits2Float(0x45b53765), SkBits2Float(0x45ba9004)); // 5798.92f, 5970
5556 path.lineTo(SkBits2Float(0x45b53837), SkBits2Float(0x45ba8f0e)); // 5799.03f, 5969.88f
5557 path.lineTo(SkBits2Float(0x45b5390c), SkBits2Float(0x45ba8e1d)); // 5799.13f, 5969.76f
5558 path.lineTo(SkBits2Float(0x45b539e4), SkBits2Float(0x45ba8d30)); // 5799.24f, 5969.65f
5559 path.lineTo(SkBits2Float(0x45b53abf), SkBits2Float(0x45ba8c48)); // 5799.34f, 5969.54f
5560 path.lineTo(SkBits2Float(0x45b53b9d), SkBits2Float(0x45ba8b64)); // 5799.45f, 5969.42f
5561 path.lineTo(SkBits2Float(0x45b53c7d), SkBits2Float(0x45ba8a85)); // 5799.56f, 5969.31f
5562 path.lineTo(SkBits2Float(0x45b53d60), SkBits2Float(0x45ba89aa)); // 5799.67f, 5969.21f
5563 path.lineTo(SkBits2Float(0x45b53e46), SkBits2Float(0x45ba88d4)); // 5799.78f, 5969.1f
5564 path.lineTo(SkBits2Float(0x45b53f2f), SkBits2Float(0x45ba8803)); // 5799.9f, 5969
5565 path.lineTo(SkBits2Float(0x45b5401a), SkBits2Float(0x45ba8736)); // 5800.01f, 5968.9f
5566 path.lineTo(SkBits2Float(0x45b54108), SkBits2Float(0x45ba866f)); // 5800.13f, 5968.8f
5567 path.lineTo(SkBits2Float(0x45b541f8), SkBits2Float(0x45ba85ac)); // 5800.25f, 5968.71f
5568 path.lineTo(SkBits2Float(0x45b542eb), SkBits2Float(0x45ba84ee)); // 5800.36f, 5968.62f
5569 path.lineTo(SkBits2Float(0x45b543e0), SkBits2Float(0x45ba8435)); // 5800.48f, 5968.53f
5570 path.lineTo(SkBits2Float(0x45b544d8), SkBits2Float(0x45ba8380)); // 5800.61f, 5968.44f
5571 path.lineTo(SkBits2Float(0x45b545d2), SkBits2Float(0x45ba82d1)); // 5800.73f, 5968.35f
5572 path.lineTo(SkBits2Float(0x45b546cf), SkBits2Float(0x45ba8227)); // 5800.85f, 5968.27f
5573 path.lineTo(SkBits2Float(0x45b547ce), SkBits2Float(0x45ba8182)); // 5800.98f, 5968.19f
5574 path.lineTo(SkBits2Float(0x45b548cf), SkBits2Float(0x45ba80e2)); // 5801.1f, 5968.11f
5575 path.lineTo(SkBits2Float(0x45b549d2), SkBits2Float(0x45ba8047)); // 5801.23f, 5968.03f
5576 path.lineTo(SkBits2Float(0x45b54ad8), SkBits2Float(0x45ba7fb1)); // 5801.36f, 5967.96f
5577 path.lineTo(SkBits2Float(0x45b54be0), SkBits2Float(0x45ba7f20)); // 5801.48f, 5967.89f
5578 path.lineTo(SkBits2Float(0x45b54cea), SkBits2Float(0x45ba7e95)); // 5801.61f, 5967.82f
5579 path.lineTo(SkBits2Float(0x45b54df6), SkBits2Float(0x45ba7e0e)); // 5801.75f, 5967.76f
5580 path.lineTo(SkBits2Float(0x45b54f04), SkBits2Float(0x45ba7d8d)); // 5801.88f, 5967.69f
5581 path.lineTo(SkBits2Float(0x45b55015), SkBits2Float(0x45ba7d12)); // 5802.01f, 5967.63f
5582 path.lineTo(SkBits2Float(0x45b55127), SkBits2Float(0x45ba7c9c)); // 5802.14f, 5967.58f
5583 path.lineTo(SkBits2Float(0x45b551b5), SkBits2Float(0x45ba7c62)); // 5802.21f, 5967.55f
5584 path.lineTo(SkBits2Float(0x45c7b29a), SkBits2Float(0x45ba7c62)); // 6390.33f, 5967.55f
5585 path.lineTo(SkBits2Float(0x45c7b2f2), SkBits2Float(0x45ba7c8b)); // 6390.37f, 5967.57f
5586 path.lineTo(SkBits2Float(0x45c7b3dd), SkBits2Float(0x45ba7cff)); // 6390.48f, 5967.62f
5587 path.lineTo(SkBits2Float(0x45c7b4c7), SkBits2Float(0x45ba7d78)); // 6390.6f, 5967.68f
5588 path.lineTo(SkBits2Float(0x45c7b5b1), SkBits2Float(0x45ba7df5)); // 6390.71f, 5967.74f
5589 path.lineTo(SkBits2Float(0x45c7b699), SkBits2Float(0x45ba7e78)); // 6390.82f, 5967.81f
5590 path.lineTo(SkBits2Float(0x45c7b780), SkBits2Float(0x45ba7f00)); // 6390.94f, 5967.88f
5591 path.lineTo(SkBits2Float(0x45c7b866), SkBits2Float(0x45ba7f8d)); // 6391.05f, 5967.94f
5592 path.lineTo(SkBits2Float(0x45c7b94a), SkBits2Float(0x45ba801e)); // 6391.16f, 5968.01f
5593 path.lineTo(SkBits2Float(0x45c7ba2d), SkBits2Float(0x45ba80b5)); // 6391.27f, 5968.09f
5594 path.lineTo(SkBits2Float(0x45c7bb0f), SkBits2Float(0x45ba8150)); // 6391.38f, 5968.16f
5595 path.lineTo(SkBits2Float(0x45c7bbf0), SkBits2Float(0x45ba81f0)); // 6391.49f, 5968.24f
5596 path.lineTo(SkBits2Float(0x45c7bccf), SkBits2Float(0x45ba8294)); // 6391.6f, 5968.32f
5597 path.lineTo(SkBits2Float(0x45c7bdac), SkBits2Float(0x45ba833d)); // 6391.71f, 5968.4f
5598 path.lineTo(SkBits2Float(0x45c7be88), SkBits2Float(0x45ba83eb)); // 6391.82f, 5968.49f
5599 path.lineTo(SkBits2Float(0x45c7bf62), SkBits2Float(0x45ba849d)); // 6391.92f, 5968.58f
5600 path.lineTo(SkBits2Float(0x45c7c03a), SkBits2Float(0x45ba8554)); // 6392.03f, 5968.67f
5601 path.lineTo(SkBits2Float(0x45c7c111), SkBits2Float(0x45ba860f)); // 6392.13f, 5968.76f
5602 path.lineTo(SkBits2Float(0x45c7c1e6), SkBits2Float(0x45ba86cf)); // 6392.24f, 5968.85f
5603 path.lineTo(SkBits2Float(0x45c7c2b9), SkBits2Float(0x45ba8792)); // 6392.34f, 5968.95f
5604 path.lineTo(SkBits2Float(0x45c7c38b), SkBits2Float(0x45ba885b)); // 6392.44f, 5969.04f
5605 path.lineTo(SkBits2Float(0x45c7c45a), SkBits2Float(0x45ba8927)); // 6392.54f, 5969.14f
5606 path.lineTo(SkBits2Float(0x45c7c528), SkBits2Float(0x45ba89f7)); // 6392.64f, 5969.25f
5607 path.lineTo(SkBits2Float(0x45c7c5f3), SkBits2Float(0x45ba8acc)); // 6392.74f, 5969.35f
5608 path.lineTo(SkBits2Float(0x45c7c6bc), SkBits2Float(0x45ba8ba5)); // 6392.84f, 5969.46f
5609 path.lineTo(SkBits2Float(0x45c7c784), SkBits2Float(0x45ba8c82)); // 6392.94f, 5969.56f
5610 path.lineTo(SkBits2Float(0x45c7c849), SkBits2Float(0x45ba8d62)); // 6393.04f, 5969.67f
5611 path.lineTo(SkBits2Float(0x45c7c90c), SkBits2Float(0x45ba8e47)); // 6393.13f, 5969.78f
5612 path.lineTo(SkBits2Float(0x45c7c9cc), SkBits2Float(0x45ba8f30)); // 6393.22f, 5969.9f
5613 path.lineTo(SkBits2Float(0x45c7ca8b), SkBits2Float(0x45ba901c)); // 6393.32f, 5970.01f
5614 path.lineTo(SkBits2Float(0x45c7cb46), SkBits2Float(0x45ba910c)); // 6393.41f, 5970.13f
5615 path.lineTo(SkBits2Float(0x45c7cc00), SkBits2Float(0x45ba9200)); // 6393.5f, 5970.25f
5616 path.lineTo(SkBits2Float(0x45c7ccb7), SkBits2Float(0x45ba92f8)); // 6393.59f, 5970.37f
5617 path.lineTo(SkBits2Float(0x45c7cd6c), SkBits2Float(0x45ba93f3)); // 6393.68f, 5970.49f
5618 path.lineTo(SkBits2Float(0x45c7ce1e), SkBits2Float(0x45ba94f2)); // 6393.76f, 5970.62f
5619 path.lineTo(SkBits2Float(0x45c7cecd), SkBits2Float(0x45ba95f4)); // 6393.85f, 5970.74f
5620 path.lineTo(SkBits2Float(0x45c7cf7a), SkBits2Float(0x45ba96fa)); // 6393.93f, 5970.87f
5621 path.lineTo(SkBits2Float(0x45c7d024), SkBits2Float(0x45ba9803)); // 6394.02f, 5971
5622 path.lineTo(SkBits2Float(0x45c7d0cb), SkBits2Float(0x45ba9910)); // 6394.1f, 5971.13f
5623 path.lineTo(SkBits2Float(0x45c7d170), SkBits2Float(0x45ba9a20)); // 6394.18f, 5971.27f
5624 path.lineTo(SkBits2Float(0x45c7d211), SkBits2Float(0x45ba9b33)); // 6394.26f, 5971.4f
5625 path.lineTo(SkBits2Float(0x45c7d2b0), SkBits2Float(0x45ba9c4a)); // 6394.34f, 5971.54f
5626 path.lineTo(SkBits2Float(0x45c7d34c), SkBits2Float(0x45ba9d63)); // 6394.41f, 5971.67f
5627 path.lineTo(SkBits2Float(0x45c7d3e5), SkBits2Float(0x45ba9e80)); // 6394.49f, 5971.81f
5628 path.lineTo(SkBits2Float(0x45c7d47a), SkBits2Float(0x45ba9fa0)); // 6394.56f, 5971.95f
5629 path.lineTo(SkBits2Float(0x45c7d50d), SkBits2Float(0x45baa0c3)); // 6394.63f, 5972.1f
5630 path.lineTo(SkBits2Float(0x45c7d59d), SkBits2Float(0x45baa1e9)); // 6394.7f, 5972.24f
5631 path.lineTo(SkBits2Float(0x45c7d629), SkBits2Float(0x45baa312)); // 6394.77f, 5972.38f
5632 path.lineTo(SkBits2Float(0x45c7d6b2), SkBits2Float(0x45baa43e)); // 6394.84f, 5972.53f
5633 path.lineTo(SkBits2Float(0x45c7d738), SkBits2Float(0x45baa56d)); // 6394.9f, 5972.68f
5634 path.lineTo(SkBits2Float(0x45c7d7ba), SkBits2Float(0x45baa69f)); // 6394.97f, 5972.83f
5635 path.lineTo(SkBits2Float(0x45c7d839), SkBits2Float(0x45baa7d3)); // 6395.03f, 5972.98f
5636 path.lineTo(SkBits2Float(0x45c7d8b5), SkBits2Float(0x45baa90a)); // 6395.09f, 5973.13f
5637 path.lineTo(SkBits2Float(0x45c7d92d), SkBits2Float(0x45baaa44)); // 6395.15f, 5973.28f
5638 path.lineTo(SkBits2Float(0x45c7d9a2), SkBits2Float(0x45baab80)); // 6395.2f, 5973.44f
5639 path.lineTo(SkBits2Float(0x45c7da13), SkBits2Float(0x45baacbf)); // 6395.26f, 5973.59f
5640 path.lineTo(SkBits2Float(0x45c7da80), SkBits2Float(0x45baae00)); // 6395.31f, 5973.75f
5641 path.lineTo(SkBits2Float(0x45c7daea), SkBits2Float(0x45baaf44)); // 6395.36f, 5973.91f
5642 path.lineTo(SkBits2Float(0x45c7db50), SkBits2Float(0x45bab08a)); // 6395.41f, 5974.07f
5643 path.lineTo(SkBits2Float(0x45c7dbb2), SkBits2Float(0x45bab1d3)); // 6395.46f, 5974.23f
5644 path.lineTo(SkBits2Float(0x45c7dc10), SkBits2Float(0x45bab31d)); // 6395.51f, 5974.39f
5645 path.lineTo(SkBits2Float(0x45c7dc6a), SkBits2Float(0x45bab46a)); // 6395.55f, 5974.55f
5646 path.lineTo(SkBits2Float(0x45c7dc6b), SkBits2Float(0x45bc5fbe)); // 6395.55f, 6027.97f
5647 path.lineTo(SkBits2Float(0x45c7dc10), SkBits2Float(0x45bc60e7)); // 6395.51f, 6028.11f
5648 path.lineTo(SkBits2Float(0x45c7dbb2), SkBits2Float(0x45bc620f)); // 6395.46f, 6028.26f
5649 path.lineTo(SkBits2Float(0x45c7db50), SkBits2Float(0x45bc6336)); // 6395.41f, 6028.4f
5650 path.lineTo(SkBits2Float(0x45c7daea), SkBits2Float(0x45bc645c)); // 6395.36f, 6028.54f
5651 path.lineTo(SkBits2Float(0x45c7da80), SkBits2Float(0x45bc6580)); // 6395.31f, 6028.69f
5652 path.lineTo(SkBits2Float(0x45c7da13), SkBits2Float(0x45bc66a3)); // 6395.26f, 6028.83f
5653 path.lineTo(SkBits2Float(0x45c7d9a2), SkBits2Float(0x45bc67c5)); // 6395.2f, 6028.97f
5654 path.lineTo(SkBits2Float(0x45c7d92d), SkBits2Float(0x45bc68e6)); // 6395.15f, 6029.11f
5655 path.lineTo(SkBits2Float(0x45c7d8b5), SkBits2Float(0x45bc6a05)); // 6395.09f, 6029.25f
5656 path.lineTo(SkBits2Float(0x45c7d839), SkBits2Float(0x45bc6b23)); // 6395.03f, 6029.39f
5657 path.lineTo(SkBits2Float(0x45c7d7ba), SkBits2Float(0x45bc6c3f)); // 6394.97f, 6029.53f
5658 path.lineTo(SkBits2Float(0x45c7d738), SkBits2Float(0x45bc6d5a)); // 6394.9f, 6029.67f
5659 path.lineTo(SkBits2Float(0x45c7d6b2), SkBits2Float(0x45bc6e73)); // 6394.84f, 6029.81f
5660 path.lineTo(SkBits2Float(0x45c7d629), SkBits2Float(0x45bc6f8b)); // 6394.77f, 6029.94f
5661 path.lineTo(SkBits2Float(0x45c7d59d), SkBits2Float(0x45bc70a1)); // 6394.7f, 6030.08f
5662 path.lineTo(SkBits2Float(0x45c7d50d), SkBits2Float(0x45bc71b5)); // 6394.63f, 6030.21f
5663 path.lineTo(SkBits2Float(0x45c7d47a), SkBits2Float(0x45bc72c7)); // 6394.56f, 6030.35f
5664 path.lineTo(SkBits2Float(0x45c7d3e5), SkBits2Float(0x45bc73d8)); // 6394.49f, 6030.48f
5665 path.lineTo(SkBits2Float(0x45c7d34c), SkBits2Float(0x45bc74e7)); // 6394.41f, 6030.61f
5666 path.lineTo(SkBits2Float(0x45c7d2b0), SkBits2Float(0x45bc75f4)); // 6394.34f, 6030.74f
5667 path.lineTo(SkBits2Float(0x45c7d211), SkBits2Float(0x45bc76ff)); // 6394.26f, 6030.87f
5668 path.lineTo(SkBits2Float(0x45c7d170), SkBits2Float(0x45bc7807)); // 6394.18f, 6031
5669 path.lineTo(SkBits2Float(0x45c7d0cb), SkBits2Float(0x45bc790e)); // 6394.1f, 6031.13f
5670 path.lineTo(SkBits2Float(0x45c7d024), SkBits2Float(0x45bc7a13)); // 6394.02f, 6031.26f
5671 path.lineTo(SkBits2Float(0x45c7cf7a), SkBits2Float(0x45bc7b16)); // 6393.93f, 6031.39f
5672 path.lineTo(SkBits2Float(0x45c7cecd), SkBits2Float(0x45bc7c16)); // 6393.85f, 6031.51f
5673 path.lineTo(SkBits2Float(0x45c7ce1e), SkBits2Float(0x45bc7d14)); // 6393.76f, 6031.63f
5674 path.lineTo(SkBits2Float(0x45c7cd6c), SkBits2Float(0x45bc7e10)); // 6393.68f, 6031.76f
5675 path.lineTo(SkBits2Float(0x45c7ccb7), SkBits2Float(0x45bc7f09)); // 6393.59f, 6031.88f
5676 path.lineTo(SkBits2Float(0x45c7cc00), SkBits2Float(0x45bc8000)); // 6393.5f, 6032
5677 path.lineTo(SkBits2Float(0x45c7cb46), SkBits2Float(0x45bc80f5)); // 6393.41f, 6032.12f
5678 path.lineTo(SkBits2Float(0x45c7ca8b), SkBits2Float(0x45bc81e7)); // 6393.32f, 6032.24f
5679 path.lineTo(SkBits2Float(0x45c7c9cc), SkBits2Float(0x45bc82d6)); // 6393.22f, 6032.35f
5680 path.lineTo(SkBits2Float(0x45c7c90c), SkBits2Float(0x45bc83c3)); // 6393.13f, 6032.47f
5681 path.lineTo(SkBits2Float(0x45c7c849), SkBits2Float(0x45bc84ad)); // 6393.04f, 6032.58f
5682 path.lineTo(SkBits2Float(0x45c7c784), SkBits2Float(0x45bc8595)); // 6392.94f, 6032.7f
5683 path.lineTo(SkBits2Float(0x45c7c6bc), SkBits2Float(0x45bc8679)); // 6392.84f, 6032.81f
5684 path.lineTo(SkBits2Float(0x45c7c5f3), SkBits2Float(0x45bc875b)); // 6392.74f, 6032.92f
5685 path.lineTo(SkBits2Float(0x45c7c528), SkBits2Float(0x45bc883a)); // 6392.64f, 6033.03f
5686 path.lineTo(SkBits2Float(0x45c7c45a), SkBits2Float(0x45bc8917)); // 6392.54f, 6033.14f
5687 path.lineTo(SkBits2Float(0x45c7c38b), SkBits2Float(0x45bc89f0)); // 6392.44f, 6033.24f
5688 path.lineTo(SkBits2Float(0x45c7c2b9), SkBits2Float(0x45bc8ac6)); // 6392.34f, 6033.35f
5689 path.lineTo(SkBits2Float(0x45c7c1e6), SkBits2Float(0x45bc8b99)); // 6392.24f, 6033.45f
5690 path.lineTo(SkBits2Float(0x45c7c111), SkBits2Float(0x45bc8c69)); // 6392.13f, 6033.55f
5691 path.lineTo(SkBits2Float(0x45c7c03a), SkBits2Float(0x45bc8d36)); // 6392.03f, 6033.65f
5692 path.lineTo(SkBits2Float(0x45c7bf62), SkBits2Float(0x45bc8e00)); // 6391.92f, 6033.75f
5693 path.lineTo(SkBits2Float(0x45c7be88), SkBits2Float(0x45bc8ec7)); // 6391.82f, 6033.85f
5694 path.lineTo(SkBits2Float(0x45c7bdac), SkBits2Float(0x45bc8f8a)); // 6391.71f, 6033.94f
5695 path.lineTo(SkBits2Float(0x45c7bccf), SkBits2Float(0x45bc904a)); // 6391.6f, 6034.04f
5696 path.lineTo(SkBits2Float(0x45c7bbf0), SkBits2Float(0x45bc9106)); // 6391.49f, 6034.13f
5697 path.lineTo(SkBits2Float(0x45c7bb0f), SkBits2Float(0x45bc91bf)); // 6391.38f, 6034.22f
5698 path.lineTo(SkBits2Float(0x45c7ba2d), SkBits2Float(0x45bc9275)); // 6391.27f, 6034.31f
5699 path.lineTo(SkBits2Float(0x45c7b94a), SkBits2Float(0x45bc9327)); // 6391.16f, 6034.39f
5700 path.lineTo(SkBits2Float(0x45c7b866), SkBits2Float(0x45bc93d5)); // 6391.05f, 6034.48f
5701 path.lineTo(SkBits2Float(0x45c7b780), SkBits2Float(0x45bc9480)); // 6390.94f, 6034.56f
5702 path.lineTo(SkBits2Float(0x45c7b699), SkBits2Float(0x45bc9527)); // 6390.82f, 6034.64f
5703 path.lineTo(SkBits2Float(0x45c7b5b1), SkBits2Float(0x45bc95ca)); // 6390.71f, 6034.72f
5704 path.lineTo(SkBits2Float(0x45c7b4c8), SkBits2Float(0x45bc966a)); // 6390.6f, 6034.8f
5705 path.lineTo(SkBits2Float(0x45c7b3dd), SkBits2Float(0x45bc9706)); // 6390.48f, 6034.88f
5706 path.lineTo(SkBits2Float(0x45c7b2f2), SkBits2Float(0x45bc979e)); // 6390.37f, 6034.95f
5707 path.lineTo(SkBits2Float(0x45c7b205), SkBits2Float(0x45bc9832)); // 6390.25f, 6035.02f
5708 path.lineTo(SkBits2Float(0x45c7b118), SkBits2Float(0x45bc98c2)); // 6390.14f, 6035.09f
5709 path.lineTo(SkBits2Float(0x45c7b02a), SkBits2Float(0x45bc994e)); // 6390.02f, 6035.16f
5710 path.lineTo(SkBits2Float(0x45c7af3b), SkBits2Float(0x45bc99d5)); // 6389.9f, 6035.23f
5711 path.lineTo(SkBits2Float(0x45c7ae4b), SkBits2Float(0x45bc9a59)); // 6389.79f, 6035.29f
5712 path.lineTo(SkBits2Float(0x45c7ad5a), SkBits2Float(0x45bc9ad9)); // 6389.67f, 6035.36f
5713 path.lineTo(SkBits2Float(0x45c7ac69), SkBits2Float(0x45bc9b54)); // 6389.55f, 6035.42f
5714 path.lineTo(SkBits2Float(0x45c7ab77), SkBits2Float(0x45bc9bcb)); // 6389.43f, 6035.47f
5715 path.lineTo(SkBits2Float(0x45c7aa84), SkBits2Float(0x45bc9c3e)); // 6389.31f, 6035.53f
5716 path.lineTo(SkBits2Float(0x45c7a991), SkBits2Float(0x45bc9cac)); // 6389.2f, 6035.58f
5717 path.lineTo(SkBits2Float(0x45c7a89e), SkBits2Float(0x45bc9d16)); // 6389.08f, 6035.64f
5718 path.lineTo(SkBits2Float(0x45c7a7aa), SkBits2Float(0x45bc9d7b)); // 6388.96f, 6035.69f
5719 path.lineTo(SkBits2Float(0x45c7a6b6), SkBits2Float(0x45bc9ddc)); // 6388.84f, 6035.73f
5720 path.lineTo(SkBits2Float(0x45c7a5c1), SkBits2Float(0x45bc9e39)); // 6388.72f, 6035.78f
5721 path.lineTo(SkBits2Float(0x45c7a4cc), SkBits2Float(0x45bc9e90)); // 6388.6f, 6035.82f
5722 path.lineTo(SkBits2Float(0x45c7a3d7), SkBits2Float(0x45bc9ee3)); // 6388.48f, 6035.86f
5723 path.lineTo(SkBits2Float(0x45c7a2e1), SkBits2Float(0x45bc9f32)); // 6388.36f, 6035.9f
5724 path.lineTo(SkBits2Float(0x45c7a1eb), SkBits2Float(0x45bc9f7b)); // 6388.24f, 6035.94f
5725 path.lineTo(SkBits2Float(0x45c7a0f6), SkBits2Float(0x45bc9fc0)); // 6388.12f, 6035.97f
5726 path.lineTo(SkBits2Float(0x45c7a000), SkBits2Float(0x45bca000)); // 6388, 6036
5727 path.lineTo(SkBits2Float(0x45b56000), SkBits2Float(0x45bca000)); // 5804, 6036
5728 path.close();
5729
5730 SkPath path2;
5731 path2.setFillType(SkPathFillType::kWinding);
5732 path2.moveTo(SkBits2Float(0x45b52600), SkBits2Float(0x45ba7c62)); // 5796.75f, 5967.55f
5733 path2.lineTo(SkBits2Float(0x45c7dc6b), SkBits2Float(0x45ba7c62)); // 6395.55f, 5967.55f
5734 path2.lineTo(SkBits2Float(0x45c7dc6b), SkBits2Float(0x45bca239)); // 6395.55f, 6036.28f
5735 path2.lineTo(SkBits2Float(0x45b52600), SkBits2Float(0x45bca239)); // 5796.75f, 6036.28f
5736 path2.lineTo(SkBits2Float(0x45b52600), SkBits2Float(0x45ba7c62)); // 5796.75f, 5967.55f
5737 path2.close();
5738
5739 SkPath result_path;
5740 testPathOp(reporter, path, path2, kIntersect_SkPathOp, filename);
5741}

◆ skp1()

static void skp1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1225 of file PathOpsOpTest.cpp.

1225 {
1226 SkPath path;
1227 path.setFillType(SkPathFillType::kEvenOdd);
1228 path.moveTo(189,7);
1229 path.cubicTo(189,5.34314585f, 190.34314f,4, 192,4);
1230 path.lineTo(243,4);
1231 path.cubicTo(244.65686f,4, 246,5.34314585f, 246,7);
1232 path.lineTo(246,21);
1233 path.cubicTo(246,22.6568546f, 244.65686f,24, 243,24);
1234 path.lineTo(192,24);
1235 path.cubicTo(190.34314f,24, 189,22.6568546f, 189,21);
1236 path.lineTo(189,7);
1237 path.close();
1238 path.moveTo(191,8);
1239 path.cubicTo(191,6.89543009f, 191.895432f,6, 193,6);
1240 path.lineTo(242,6);
1241 path.cubicTo(243.104568f,6, 244,6.89543009f, 244,8);
1242 path.lineTo(244,20);
1243 path.cubicTo(244,21.1045704f, 243.104568f,22, 242,22);
1244 path.lineTo(193,22);
1245 path.cubicTo(191.895432f,22, 191,21.1045704f, 191,20);
1246 path.lineTo(191,8);
1247 path.close();
1248 SkPath pathB;
1249 pathB.setFillType(SkPathFillType::kWinding);
1250 pathB.moveTo(189,4);
1251 pathB.lineTo(199,14);
1252 pathB.lineTo(236,14);
1253 pathB.lineTo(246,4);
1254 pathB.lineTo(189,4);
1255 pathB.close();
1256 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1257}

◆ skp2()

static void skp2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1259 of file PathOpsOpTest.cpp.

1259 {
1260 SkPath path;
1261 path.setFillType(SkPathFillType::kEvenOdd);
1262 path.moveTo(253.000000f, 11757.0000f);
1263 path.lineTo(253.000000f, 222.000000f);
1264 path.lineTo(823.000000f, 222.000000f);
1265 path.lineTo(823.000000f, 11757.0000f);
1266 path.lineTo(253.000000f, 11757.0000f);
1267 path.close();
1268 SkPath pathB;
1269 pathB.setFillType(SkPathFillType::kWinding);
1270 pathB.moveTo(258.000000f, 1028.00000f);
1271 pathB.lineTo(258.000000f, 1027.00000f);
1272 pathB.lineTo(823.000000f, 1027.00000f);
1273 pathB.lineTo(823.000000f, 1028.00000f);
1274 pathB.lineTo(258.000000f, 1028.00000f);
1275 pathB.close();
1276 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1277}

◆ skp3()

static void skp3 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1279 of file PathOpsOpTest.cpp.

1279 {
1280 SkPath path;
1281 path.setFillType(SkPathFillType::kEvenOdd);
1282 path.moveTo(717.000000f, 507.000000f);
1283 path.lineTo(717.000000f, 425.000000f);
1284 path.lineTo(973.000000f, 425.000000f);
1285 path.lineTo(973.000000f, 507.000000f);
1286 path.quadTo(973.000000f, 508.242645f, 972.121582f, 509.121613f);
1287 path.quadTo(971.242615f, 510.000000f, 970.000000f, 510.000000f);
1288 path.lineTo(720.000000f, 510.000000f);
1289 path.quadTo(718.757385f, 510.000000f, 717.878418f, 509.121613f);
1290 path.quadTo(717.000000f, 508.242645f, 717.000000f, 507.000000f);
1291 path.close();
1292 path.moveTo(719.000000f, 426.000000f);
1293 path.lineTo(971.000000f, 426.000000f);
1294 path.lineTo(971.000000f, 506.000000f);
1295 path.cubicTo(971.000000f, 507.104584f, 970.104553f, 508.000000f, 969.000000f, 508.000000f);
1296 path.lineTo(721.000000f, 508.000000f);
1297 path.cubicTo(719.895447f, 508.000000f, 719.000000f, 507.104584f, 719.000000f, 506.000000f);
1298 path.lineTo(719.000000f, 426.000000f);
1299 path.close();
1300 SkPath pathB;
1301 pathB.setFillType(SkPathFillType::kWinding);
1302 pathB.moveTo(717.000000f, 510.000000f);
1303 pathB.lineTo(760.000000f, 467.000000f);
1304 pathB.lineTo(930.000000f, 467.000000f);
1305 pathB.lineTo(973.000000f, 510.000000f);
1306 pathB.lineTo(717.000000f, 510.000000f);
1307 pathB.close();
1308 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1309}

◆ skp4()

static void skp4 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1311 of file PathOpsOpTest.cpp.

1311 {
1312 SkPath path;
1313 path.setFillType(SkPathFillType::kEvenOdd);
1314 path.moveTo(230.756805f, 591.756775f);
1315 path.quadTo(232.514725f, 590.000000f, 235.000000f, 590.000000f);
1316 path.lineTo(300.000000f, 590.000000f);
1317 path.quadTo(302.485291f, 590.000000f, 304.243195f, 591.756775f);
1318 path.quadTo(306.000000f, 593.514709f, 306.000000f, 596.000000f);
1319 path.lineTo(306.000000f, 617.000000f);
1320 path.lineTo(229.000000f, 617.000000f);
1321 path.lineTo(229.000000f, 596.000000f);
1322 path.quadTo(229.000000f, 593.514709f, 230.756805f, 591.756775f);
1323 path.close();
1324 path.moveTo(231.000000f, 597.000000f);
1325 path.cubicTo(231.000000f, 594.238586f, 233.238571f, 592.000000f, 236.000000f, 592.000000f);
1326 path.lineTo(299.000000f, 592.000000f);
1327 path.cubicTo(301.761414f, 592.000000f, 304.000000f, 594.238586f, 304.000000f, 597.000000f);
1328 path.lineTo(304.000000f, 616.000000f);
1329 path.lineTo(231.000000f, 616.000000f);
1330 path.lineTo(231.000000f, 597.000000f);
1331 path.close();
1332 SkPath pathB;
1333 pathB.setFillType(SkPathFillType::kWinding);
1334 pathB.moveTo(306.000000f, 590.000000f);
1335 pathB.lineTo(292.000000f, 604.000000f);
1336 pathB.lineTo(305.000000f, 617.000000f);
1337 pathB.lineTo(306.000000f, 617.000000f);
1338 pathB.lineTo(306.000000f, 590.000000f);
1339 pathB.close();
1340 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1341}

◆ skp5()

static void skp5 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1343 of file PathOpsOpTest.cpp.

1343 {
1344 SkPath path;
1345 path.setFillType(SkPathFillType::kEvenOdd);
1346 path.moveTo(18.0000000f, 226.000000f);
1347 path.quadTo(14.6862917f, 226.000000f, 12.3423996f, 228.342407f);
1348 path.quadTo(10.0000000f, 230.686295f, 10.0000000f, 234.000000f);
1349 path.lineTo(10.0000000f, 253.000000f);
1350 path.lineTo(1247.00000f, 253.000000f);
1351 path.lineTo(1247.00000f, 234.000000f);
1352 path.quadTo(1247.00000f, 230.686295f, 1244.65759f, 228.342407f);
1353 path.quadTo(1242.31372f, 226.000000f, 1239.00000f, 226.000000f);
1354 path.lineTo(18.0000000f, 226.000000f);
1355 path.close();
1356 SkPath pathB;
1357 pathB.setFillType(SkPathFillType::kInverseWinding);
1358 pathB.moveTo(18.0000000f, 226.000000f);
1359 pathB.lineTo(1239.00000f, 226.000000f);
1360 pathB.cubicTo(1243.41833f, 226.000000f, 1247.00000f, 229.581726f, 1247.00000f, 234.000000f);
1361 pathB.lineTo(1247.00000f, 252.000000f);
1362 pathB.lineTo(10.0000000f, 252.000000f);
1363 pathB.lineTo(10.0000000f, 234.000000f);
1364 pathB.cubicTo(10.0000000f, 229.581726f, 13.5817204f, 226.000000f, 18.0000000f, 226.000000f);
1365 pathB.close();
1366 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1367}

◆ skp96prezzi1()

static void skp96prezzi1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1636 of file PathOpsOpTest.cpp.

1636 {
1637 SkPath path;
1638 path.setFillType(SkPathFillType::kEvenOdd);
1639 path.moveTo(157.464005f, 670.463989f);
1640 path.quadTo(158.928925f, 669.000000f, 161.000000f, 669.000000f);
1641 path.lineTo(248.000000f, 669.000000f);
1642 path.quadTo(250.071075f, 669.000000f, 251.535995f, 670.463989f);
1643 path.quadTo(253.000000f, 671.928955f, 253.000000f, 674.000000f);
1644 path.lineTo(253.000000f, 706.000000f);
1645 path.lineTo(251.000000f, 706.000000f);
1646 path.lineTo(251.000000f, 675.000000f);
1647 path.cubicTo(251.000000f, 672.790833f, 249.209137f, 671.000000f, 247.000000f, 671.000000f);
1648 path.lineTo(162.000000f, 671.000000f);
1649 path.cubicTo(159.790863f, 671.000000f, 158.000000f, 672.790833f, 158.000000f, 675.000000f);
1650 path.lineTo(158.000000f, 706.000000f);
1651 path.lineTo(156.000000f, 706.000000f);
1652 path.lineTo(156.000000f, 674.000000f);
1653 path.quadTo(156.000000f, 671.928955f, 157.464005f, 670.463989f);
1654 path.close();
1655 SkPath pathB;
1656 pathB.setFillType(SkPathFillType::kWinding);
1657 pathB.moveTo(156.000000f, 669.000000f);
1658 pathB.lineTo(178.500000f, 691.500000f);
1659 pathB.lineTo(230.500000f, 691.500000f);
1660 pathB.lineTo(253.000000f, 669.000000f);
1661 pathB.lineTo(156.000000f, 669.000000f);
1662 pathB.close();
1663 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1664}

◆ skpaaalgarve_org53()

static void skpaaalgarve_org53 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2291 of file PathOpsOpTest.cpp.

2291 {
2292 SkPath path;
2293 path.setFillType(SkPathFillType::kEvenOdd);
2294 path.moveTo(-1.24344979e-014f, 348);
2295 path.lineTo(258, 348);
2296 path.lineTo(258, 322);
2297 path.quadTo(258, 317.857849f, 255.072006f, 314.928009f);
2298 path.quadTo(252.142136f, 312, 248, 312);
2299 path.lineTo(1.77635684e-015f, 312);
2300 path.lineTo(-1.24344979e-014f, 348);
2301 path.close();
2302 SkPath pathB;
2303 pathB.setFillType(SkPathFillType::kWinding);
2304 pathB.moveTo(0, 312);
2305 pathB.lineTo(258, 312);
2306 pathB.lineTo(258, 348);
2307 pathB.lineTo(0, 348);
2308 pathB.close();
2309 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2310}

◆ skpabcspark_ca103()

static void skpabcspark_ca103 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2312 of file PathOpsOpTest.cpp.

2312 {
2313 SkPath path;
2314 path.setFillType(SkPathFillType::kEvenOdd);
2315 path.moveTo(1.99840144e-015f, 494);
2316 path.lineTo(97, 494);
2317 path.quadTo(100.313705f, 494, 102.6576f, 491.657593f);
2318 path.quadTo(105, 489.313721f, 105, 486);
2319 path.lineTo(105, 425);
2320 path.quadTo(105, 421.686279f, 102.6576f, 419.342407f);
2321 path.quadTo(100.313705f, 417, 97, 417);
2322 path.lineTo(2.22044605e-016f, 417);
2323 path.lineTo(1.99840144e-015f, 494);
2324 path.close();
2325 SkPath pathB;
2326 pathB.setFillType(SkPathFillType::kWinding);
2327 pathB.moveTo(0, 417);
2328 pathB.lineTo(105, 417);
2329 pathB.lineTo(105, 494);
2330 pathB.lineTo(0, 494);
2331 pathB.close();
2332 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2333}

◆ skpacesoftech_com47()

static void skpacesoftech_com47 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2335 of file PathOpsOpTest.cpp.

2335 {
2336 SkPath path;
2337 path.setFillType(SkPathFillType::kEvenOdd);
2338 path.moveTo(670.537415f, 285);
2339 path.lineTo(670.387451f, 285);
2340 path.lineTo(596.315186f, 314.850708f);
2341 path.lineTo(626.19696f, 389);
2342 path.lineTo(626.346863f, 389);
2343 path.lineTo(700.419189f, 359.149261f);
2344 path.lineTo(670.537415f, 285);
2345 path.close();
2346 SkPath pathB;
2347 pathB.setFillType(SkPathFillType::kWinding);
2348 pathB.moveTo(663.318542f, 374.100616f);
2349 pathB.quadTo(647.950989f, 380.293671f, 632.705322f, 373.806305f);
2350 pathB.quadTo(617.459595f, 367.318909f, 611.266541f, 351.951355f);
2351 pathB.quadTo(605.073486f, 336.58374f, 611.560913f, 321.338074f);
2352 pathB.quadTo(618.048279f, 306.092407f, 633.415833f, 299.899353f);
2353 pathB.quadTo(648.783447f, 293.706299f, 664.029114f, 300.193665f);
2354 pathB.quadTo(679.27478f, 306.68103f, 685.467834f, 322.048645f);
2355 pathB.quadTo(691.660889f, 337.416199f, 685.173523f, 352.661896f);
2356 pathB.quadTo(678.686157f, 367.907562f, 663.318542f, 374.100616f);
2357 pathB.close();
2358 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2359}

◆ skpact_com43()

static void skpact_com43 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2361 of file PathOpsOpTest.cpp.

2361 {
2362 SkPath path;
2363 path.setFillType(SkPathFillType::kEvenOdd);
2364 path.moveTo(1.45716772e-016f, 924.336121f);
2365 path.lineTo(-1.11022302e-016f, 920);
2366 path.lineTo(6, 920);
2367 path.lineTo(6, 926);
2368 path.lineTo(1.66389287f, 926);
2369 path.quadTo(1.18842196f, 925.674561f, 0.756800175f, 925.243225f);
2370 path.quadTo(0.325406998f, 924.811523f, 1.45716772e-016f, 924.336121f);
2371 path.close();
2372 path.moveTo(1, 921);
2373 path.lineTo(5, 921);
2374 path.lineTo(5, 925);
2375 path.cubicTo(2.79086018f, 925, 1, 923.209167f, 1, 921);
2376 path.close();
2377 SkPath pathB;
2378 pathB.setFillType(SkPathFillType::kWinding);
2379 pathB.moveTo(-1, 920);
2380 pathB.lineTo(0, 920);
2381 pathB.lineTo(3, 927);
2382 pathB.lineTo(-1, 927);
2383 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2384}

◆ skpadbox_lt15()

static void skpadbox_lt15 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2543 of file PathOpsOpTest.cpp.

2543 {
2544 SkPath path;
2545 path.setFillType(SkPathFillType::kEvenOdd);
2546 path.moveTo(333.292084f, 624.570984f);
2547 path.lineTo(614.229797f, 98.9735107f);
2548 path.lineTo(933.457764f, 269.604431f);
2549 path.lineTo(652.52002f, 795.201904f);
2550 path.lineTo(333.292084f, 624.570984f);
2551 path.close();
2552 SkPath pathB;
2553 pathB.setFillType(SkPathFillType::kWinding);
2554 pathB.moveTo(613.368042f, 100.585754f);
2555 pathB.cubicTo(613.685303f, 99.9921265f, 614.423767f, 99.7681885f, 615.017395f, 100.085449f);
2556 pathB.lineTo(932.633057f, 269.854553f);
2557 pathB.cubicTo(933.226685f, 270.171875f, 933.450623f, 270.910278f, 933.133301f, 271.503906f);
2558 pathB.lineTo(653.631897f, 794.414307f);
2559 pathB.cubicTo(653.314636f, 795.007935f, 652.576172f, 795.231934f, 651.982544f, 794.914612f);
2560 pathB.lineTo(334.366943f, 625.145508f);
2561 pathB.cubicTo(333.773315f, 624.828247f, 333.549286f, 624.089783f, 333.866608f, 623.496155f);
2562 pathB.lineTo(613.368042f, 100.585754f);
2563 pathB.close();
2564 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2565}

◆ skpadbox_lt8()

static void skpadbox_lt8 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2386 of file PathOpsOpTest.cpp.

2386 {
2387 SkPath path;
2388 path.setFillType(SkPathFillType::kEvenOdd);
2389 path.moveTo(320.097229f, 628.573669f);
2390 path.lineTo(610.227173f, 85.7786865f);
2391 path.lineTo(946.652588f, 265.601807f);
2392 path.lineTo(656.522644f, 808.39679f);
2393 path.lineTo(320.097229f, 628.573669f);
2394 path.close();
2395 SkPath pathB;
2396 pathB.setFillType(SkPathFillType::kInverseWinding);
2397 pathB.moveTo(333.866608f, 623.496155f);
2398 pathB.lineTo(613.368042f, 100.585754f);
2399 pathB.cubicTo(613.685303f, 99.9921265f, 614.423767f, 99.7681885f, 615.017395f, 100.085449f);
2400 pathB.lineTo(932.633057f, 269.854553f);
2401 pathB.cubicTo(933.226685f, 270.171875f, 933.450623f, 270.910278f, 933.133301f, 271.503906f);
2402 pathB.lineTo(653.631897f, 794.414307f);
2403 pathB.cubicTo(653.314636f, 795.007935f, 652.576172f, 795.231934f, 651.982544f, 794.914612f);
2404 pathB.lineTo(334.366943f, 625.145508f);
2405 pathB.cubicTo(333.773315f, 624.828247f, 333.549286f, 624.089783f, 333.866608f, 623.496155f);
2406 pathB.close();
2407 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2408}

◆ skpadindex_de4()

static void skpadindex_de4 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2410 of file PathOpsOpTest.cpp.

2410 {
2411 SkPath path;
2412 path.setFillType(SkPathFillType::kEvenOdd);
2413 path.moveTo(0, 926);
2414 path.lineTo(0, 0);
2415 path.lineTo(1280, 0);
2416 path.lineTo(1280, 926);
2417 path.lineTo(0, 926);
2418 path.close();
2419 SkPath pathB;
2420 pathB.setFillType(SkPathFillType::kWinding);
2421 pathB.moveTo(0, 312);
2422 pathB.lineTo(8.20486257e-015f, 178);
2423 pathB.lineTo(49, 178);
2424 pathB.lineTo(49, 312);
2425 pathB.close();
2426 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2427}

◆ skpadithya_putr4_blogspot_com551()

static void skpadithya_putr4_blogspot_com551 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2429 of file PathOpsOpTest.cpp.

2429 {
2430 SkPath path;
2431 path.setFillType(SkPathFillType::kEvenOdd);
2432 path.moveTo(205.605804f, 142.334625f);
2433 path.lineTo(254.665359f, 85.6058044f);
2434 path.lineTo(311.394196f, 134.665359f);
2435 path.lineTo(262.334625f, 191.39418f);
2436 path.lineTo(205.605804f, 142.334625f);
2437 path.close();
2438 SkPath pathB;
2439 pathB.setFillType(SkPathFillType::kWinding);
2440 pathB.moveTo(283.407959f, 110.462646f);
2441 pathB.cubicTo(298.864319f, 123.829437f, 300.558258f, 147.195221f, 287.191467f, 162.651581f);
2442 pathB.lineTo(286.537354f, 163.407959f);
2443 pathB.cubicTo(273.170563f, 178.864334f, 249.804779f, 180.558258f, 234.348419f, 167.191467f);
2444 pathB.lineTo(233.592026f, 166.537338f);
2445 pathB.cubicTo(218.135666f, 153.170547f, 216.441727f, 129.804779f, 229.808517f, 114.348412f);
2446 pathB.lineTo(230.462646f, 113.592026f);
2447 pathB.cubicTo(243.829437f, 98.1356659f, 267.195221f, 96.4417267f, 282.651581f, 109.808517f);
2448 pathB.lineTo(283.407959f, 110.462646f);
2449 pathB.close();
2450 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2451}

◆ skpadoption_org196()

static void skpadoption_org196 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2567 of file PathOpsOpTest.cpp.

2567 {
2568 SkPath path;
2569 path.setFillType(SkPathFillType::kEvenOdd);
2570 path.moveTo(802, 367);
2571 path.lineTo(802, 324);
2572 path.lineTo(956, 324);
2573 path.lineTo(956, 371);
2574 path.quadTo(956, 373.071075f, 954.536011f, 374.536011f);
2575 path.quadTo(953.071045f, 376, 951, 376);
2576 path.lineTo(811, 376);
2577 path.cubicTo(806.029419f, 376, 802, 371.970551f, 802, 367);
2578 path.close();
2579 SkPath pathB;
2580 pathB.setFillType(SkPathFillType::kInverseWinding);
2581 pathB.moveTo(803, 326);
2582 pathB.lineTo(955, 326);
2583 pathB.lineTo(955, 370);
2584 pathB.cubicTo(955, 372.761414f, 952.761414f, 375, 950, 375);
2585 pathB.lineTo(808, 375);
2586 pathB.cubicTo(805.238586f, 375, 803, 372.761414f, 803, 370);
2587 pathB.lineTo(803, 326);
2588 pathB.close();
2589 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2590}

◆ skpadspert_de11()

static void skpadspert_de11 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2453 of file PathOpsOpTest.cpp.

2453 {
2454 SkPath path;
2455 path.setFillType(SkPathFillType::kEvenOdd);
2456 path.moveTo(-4.4408921e-016f, 682.5f);
2457 path.lineTo(30.5f, 682.5f);
2458 path.cubicTo(32.709137f, 682.5f, 34.5f, 680.709167f, 34.5f, 678.5f);
2459 path.lineTo(34.5f, 486.5f);
2460 path.cubicTo(34.5f, 484.290863f, 32.709137f, 482.5f, 30.5f, 482.5f);
2461 path.lineTo(0, 482.5f);
2462 path.lineTo(-4.4408921e-016f, 682.5f);
2463 path.close();
2464 SkPath pathB;
2465 pathB.setFillType(SkPathFillType::kWinding);
2466 pathB.moveTo(0, 482);
2467 pathB.lineTo(35, 482);
2468 pathB.lineTo(35, 683);
2469 pathB.lineTo(0, 683);
2470 pathB.close();
2471 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2472}

◆ skpadspert_net23()

static void skpadspert_net23 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2592 of file PathOpsOpTest.cpp.

2592 {
2593 SkPath path;
2594 path.setFillType(SkPathFillType::kEvenOdd);
2595 path.moveTo(-2.220446e-018f, 483.5f);
2596 path.lineTo(0, 482.5f);
2597 path.lineTo(30.5f, 482.5f);
2598 path.cubicTo(32.709137f, 482.5f, 34.5f, 484.290863f, 34.5f, 486.5f);
2599 path.lineTo(34.5f, 678.5f);
2600 path.cubicTo(34.5f, 680.709167f, 32.709137f, 682.5f, 30.5f, 682.5f);
2601 path.lineTo(-4.4408921e-016f, 682.5f);
2602 path.lineTo(-4.41868766e-016f, 681.5f);
2603 path.lineTo(30.5f, 681.5f);
2604 path.cubicTo(32.1568565f, 681.5f, 33.5f, 680.15686f, 33.5f, 678.5f);
2605 path.lineTo(33.5f, 486.5f);
2606 path.cubicTo(33.5f, 484.84314f, 32.1568565f, 483.5f, 30.5f, 483.5f);
2607 path.lineTo(-2.220446e-018f, 483.5f);
2608 path.close();
2609 SkPath pathB;
2610 pathB.setFillType(SkPathFillType::kWinding);
2611 pathB.moveTo(0, 482);
2612 pathB.lineTo(35, 482);
2613 pathB.lineTo(35, 683);
2614 pathB.lineTo(0, 683);
2615 pathB.close();
2616 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2617}

◆ skpadventistmission_org572()

static void skpadventistmission_org572 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2619 of file PathOpsOpTest.cpp.

2619 {
2620 SkPath path;
2621 path.setFillType(SkPathFillType::kEvenOdd);
2622 path.moveTo(1182.00037f, 926);
2623 path.cubicTo(1181.08813f, 924.785583f, 1179.63586f, 924, 1178, 924);
2624 path.lineTo(938, 924);
2625 path.cubicTo(936.364197f, 924, 934.911865f, 924.785583f, 933.999634f, 926);
2626 path.lineTo(1182.00037f, 926);
2627 path.close();
2628 SkPath pathB;
2629 pathB.setFillType(SkPathFillType::kWinding);
2630 pathB.moveTo(934, 924);
2631 pathB.lineTo(1182, 924);
2632 pathB.lineTo(1182, 926);
2633 pathB.lineTo(934, 926);
2634 pathB.close();
2635 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2636}

◆ skpagentxsites_com55()

static void skpagentxsites_com55 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2638 of file PathOpsOpTest.cpp.

2638 {
2639 SkPath path;
2640 path.setFillType(SkPathFillType::kEvenOdd);
2641 path.moveTo(925, 27);
2642 path.cubicTo(924.447693f, 27, 924, 27.4477158f, 924, 28);
2643 path.lineTo(924, 55);
2644 path.cubicTo(924, 55.5522842f, 924.447693f, 56, 925, 56);
2645 path.lineTo(1103, 56);
2646 path.cubicTo(1103.55225f, 56, 1104, 55.5522842f, 1104, 55);
2647 path.lineTo(1104, 28);
2648 path.cubicTo(1104, 27.4477158f, 1103.55225f, 27, 1103, 27);
2649 path.lineTo(925, 27);
2650 path.close();
2651 SkPath pathB;
2652 pathB.setFillType(SkPathFillType::kWinding);
2653 pathB.moveTo(1103, 27);
2654 pathB.cubicTo(1104.10461f, 27, 1105, 27.8954315f, 1105, 29);
2655 pathB.lineTo(1105, 54);
2656 pathB.cubicTo(1105, 55.1045685f, 1104.10461f, 56, 1103, 56);
2657 pathB.lineTo(926, 56);
2658 pathB.cubicTo(924.895447f, 56, 924, 55.1045685f, 924, 54);
2659 pathB.lineTo(924, 29);
2660 pathB.cubicTo(924, 27.8954315f, 924.895447f, 27, 926, 27);
2661 pathB.lineTo(1103, 27);
2662 pathB.close();
2663 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2664}

◆ skpahrefs_com29()

static void skpahrefs_com29 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1791 of file PathOpsOpTest.cpp.

1791 {
1792 SkPath path;
1793 path.setFillType(SkPathFillType::kEvenOdd);
1794 path.moveTo(1037.17114f, 7.17119980f);
1795 path.quadTo(1038.34314f, 6.00000000f, 1040.00000f, 6.00000000f);
1796 path.lineTo(1074.00000f, 6.00000000f);
1797 path.lineTo(1074.00000f, 32.0000000f);
1798 path.lineTo(1040.00000f, 32.0000000f);
1799 path.quadTo(1038.34314f, 32.0000000f, 1037.17114f, 30.8288002f);
1800 path.quadTo(1036.00000f, 29.6568546f, 1036.00000f, 28.0000000f);
1801 path.lineTo(1036.00000f, 10.0000000f);
1802 path.quadTo(1036.00000f, 8.34314537f, 1037.17114f, 7.17119980f);
1803 path.close();
1804 path.moveTo(1037.00000f, 10.0000000f);
1805 path.cubicTo(1037.00000f, 8.34314537f, 1038.34314f, 7.00000000f, 1040.00000f, 7.00000000f);
1806 path.lineTo(1073.00000f, 7.00000000f);
1807 path.lineTo(1073.00000f, 31.0000000f);
1808 path.lineTo(1040.00000f, 31.0000000f);
1809 path.cubicTo(1038.34314f, 31.0000000f, 1037.00000f, 29.6568546f, 1037.00000f, 28.0000000f);
1810 path.lineTo(1037.00000f, 10.0000000f);
1811 path.close();
1812 SkPath pathB;
1813 pathB.setFillType(SkPathFillType::kWinding);
1814 pathB.moveTo(1036.00000f, 32.0000000f);
1815 pathB.lineTo(1049.00000f, 19.0000000f);
1816 pathB.lineTo(1073.00000f, 31.0000000f);
1817 pathB.lineTo(1074.00000f, 32.0000000f);
1818 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1819}

◆ skpahrefs_com88()

static void skpahrefs_com88 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1765 of file PathOpsOpTest.cpp.

1765 {
1766 SkPath path;
1767 path.setFillType(SkPathFillType::kEvenOdd);
1768 path.moveTo(1099.82886f, 7.17117119f);
1769 path.lineTo(1099.12134f, 7.87867832f);
1770 path.cubicTo(1099.66418f, 8.42157173f, 1100.00000f, 9.17157173f, 1100.00000f, 10.0000000f);
1771 path.lineTo(1100.00000f, 28.0000000f);
1772 path.cubicTo(1100.00000f, 29.6568546f, 1098.65686f, 31.0000000f, 1097.00000f, 31.0000000f);
1773 path.lineTo(1088.00000f, 31.0000000f);
1774 path.lineTo(1088.00000f, 32.0000000f);
1775 path.lineTo(1097.00000f, 32.0000000f);
1776 path.quadTo(1098.65686f, 32.0000000f, 1099.82886f, 30.8288002f);
1777 path.quadTo(1101.00000f, 29.6568546f, 1101.00000f, 28.0000000f);
1778 path.lineTo(1101.00000f, 10.0000000f);
1779 path.quadTo(1101.00000f, 8.34314537f, 1099.82886f, 7.17119980f);
1780 path.lineTo(1099.82886f, 7.17117119f);
1781 path.close();
1782 SkPath pathB;
1783 pathB.setFillType(SkPathFillType::kWinding);
1784 pathB.moveTo(1101.00000f, 6.00000000f);
1785 pathB.lineTo(1088.00000f, 6.00000000f);
1786 pathB.lineTo(1088.00000f, 19.0000000f);
1787 pathB.lineTo(1101.00000f, 32.0000000f);
1788 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1789}

◆ skpaiaigames_com870()

static void skpaiaigames_com870 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2474 of file PathOpsOpTest.cpp.

2474 {
2475 SkPath path;
2476 path.setFillType(SkPathFillType::kEvenOdd);
2477 path.moveTo(324.071075f, 845.071045f);
2478 path.cubicTo(324.405151f, 844.737f, 324.715668f, 844.379395f, 325, 844.000977f);
2479 path.lineTo(325, 842.127197f);
2480 path.cubicTo(324.571411f, 842.956238f, 324.017761f, 843.710144f, 323.363953f, 844.363953f);
2481 path.lineTo(324.071075f, 845.071045f);
2482 path.close();
2483 path.moveTo(323.363953f, 714.636047f);
2484 path.lineTo(324.071075f, 713.928955f);
2485 path.cubicTo(324.405151f, 714.263f, 324.715668f, 714.620605f, 325, 714.999023f);
2486 path.lineTo(325, 716.872803f);
2487 path.cubicTo(324.571411f, 716.043762f, 324.017761f, 715.289856f, 323.363953f, 714.636047f);
2488 path.close();
2489 SkPath pathB;
2490 pathB.setFillType(SkPathFillType::kWinding);
2491 pathB.moveTo(317, 711);
2492 pathB.cubicTo(322.522858f, 711, 327, 715.477173f, 327, 721);
2493 pathB.lineTo(327, 838);
2494 pathB.cubicTo(327, 843.522827f, 322.522858f, 848, 317, 848);
2495 pathB.lineTo(155, 848);
2496 pathB.cubicTo(149.477158f, 848, 145, 843.522827f, 145, 838);
2497 pathB.lineTo(145, 721);
2498 pathB.cubicTo(145, 715.477173f, 149.477158f, 711, 155, 711);
2499 pathB.lineTo(317, 711);
2500 pathB.close();
2501 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2502}

◆ skpakmmos_ru100()

static void skpakmmos_ru100 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2716 of file PathOpsOpTest.cpp.

2716 {
2717 SkPath path;
2718 path.setFillType(SkPathFillType::kEvenOdd);
2719 path.moveTo(693.000488f, 926);
2720 path.cubicTo(692.164734f, 925.37207f, 691.125793f, 925, 690, 925);
2721 path.lineTo(578, 925);
2722 path.cubicTo(576.874207f, 925, 575.835266f, 925.37207f, 574.999512f, 926);
2723 path.lineTo(693.000488f, 926);
2724 path.close();
2725 SkPath pathB;
2726 pathB.setFillType(SkPathFillType::kWinding);
2727 pathB.moveTo(575, 925);
2728 pathB.lineTo(693, 925);
2729 pathB.lineTo(693, 926);
2730 pathB.lineTo(575, 926);
2731 pathB.close();
2732 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2733}

◆ skpancestry_com1()

static void skpancestry_com1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1666 of file PathOpsOpTest.cpp.

1666 {
1667 SkPath path;
1668 path.setFillType(SkPathFillType::kEvenOdd);
1669 path.moveTo(161.000000f, 925.000000f);
1670 path.cubicTo(159.874390f, 925.000000f, 158.835663f, 925.371948f, 158.000000f, 925.999634f);
1671 path.lineTo(158.000000f, 926.000000f);
1672 path.lineTo(1108.00000f, 926.000000f);
1673 path.lineTo(1108.00000f, 925.999634f);
1674 path.cubicTo(1107.16443f, 925.371948f, 1106.12561f, 925.000000f, 1105.00000f, 925.000000f);
1675 path.lineTo(161.000000f, 925.000000f);
1676 path.close();
1677 SkPath pathB;
1678 pathB.setFillType(SkPathFillType::kEvenOdd);
1679 pathB.moveTo(161.000000f, 926.000000f);
1680 pathB.lineTo(1105.00000f, 926.000000f);
1681 pathB.cubicTo(1107.20911f, 926.000000f, 1109.00000f, 927.790833f, 1109.00000f, 930.000000f);
1682 pathB.lineTo(1109.00000f, 956.000000f);
1683 pathB.cubicTo(1109.00000f, 958.209167f, 1107.20911f, 960.000000f, 1105.00000f, 960.000000f);
1684 pathB.lineTo(161.000000f, 960.000000f);
1685 pathB.cubicTo(158.790863f, 960.000000f, 157.000000f, 958.209167f, 157.000000f, 956.000000f);
1686 pathB.lineTo(157.000000f, 930.000000f);
1687 pathB.cubicTo(157.000000f, 927.790833f, 158.790863f, 926.000000f, 161.000000f, 926.000000f);
1688 pathB.close();
1689 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1690}

◆ skpbakosoft_com10()

static void skpbakosoft_com10 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2666 of file PathOpsOpTest.cpp.

2666 {
2667 SkPath path;
2668 path.setFillType(SkPathFillType::kEvenOdd);
2669 path.moveTo(190, 170);
2670 path.cubicTo(178.9543f, 170, 170, 178.9543f, 170, 190);
2671 path.cubicTo(170, 201.0457f, 178.9543f, 210, 190, 210);
2672 path.lineTo(370, 210);
2673 path.cubicTo(381.045685f, 210, 390, 201.0457f, 390, 190);
2674 path.cubicTo(390, 178.9543f, 381.045685f, 170, 370, 170);
2675 path.lineTo(190, 170);
2676 path.close();
2677 SkPath pathB;
2678 pathB.setFillType(SkPathFillType::kWinding);
2679 pathB.moveTo(210, 190);
2680 pathB.quadTo(210, 198.284271f, 204.142136f, 204.142136f);
2681 pathB.quadTo(198.284271f, 210, 190, 210);
2682 pathB.quadTo(181.715729f, 210, 175.857864f, 204.142136f);
2683 pathB.quadTo(170, 198.284271f, 170, 190);
2684 pathB.quadTo(170, 181.715729f, 175.857864f, 175.857864f);
2685 pathB.quadTo(181.715729f, 170, 190, 170);
2686 pathB.quadTo(198.284271f, 170, 204.142136f, 175.857864f);
2687 pathB.quadTo(210, 181.715729f, 210, 190);
2688 pathB.close();
2689 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2690}

◆ skpbambootheme_com12()

static void skpbambootheme_com12 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2692 of file PathOpsOpTest.cpp.

2692 {
2693 SkPath path;
2694 path.setFillType(SkPathFillType::kEvenOdd);
2695 path.moveTo(47.8780937f, 58);
2696 path.lineTo(0, 58);
2697 path.lineTo(-8.65973959e-015f, 96.9914017f);
2698 path.quadTo(20.0654926f, 96.6451874f, 34.3553391f, 82.3553391f);
2699 path.quadTo(44.9466133f, 71.764061f, 47.8780937f, 58);
2700 path.close();
2701 SkPath pathB;
2702 pathB.setFillType(SkPathFillType::kEvenOdd);
2703 pathB.moveTo(-1, -3);
2704 pathB.lineTo(-1, -3);
2705 pathB.cubicTo(26.6142502f, -3, 49, 19.3857498f, 49, 47);
2706 pathB.lineTo(49, 47);
2707 pathB.cubicTo(49, 74.6142502f, 26.6142502f, 97, -1, 97);
2708 pathB.lineTo(-1, 97);
2709 pathB.cubicTo(-28.6142502f, 97, -51, 74.6142502f, -51, 47);
2710 pathB.lineTo(-51, 47);
2711 pathB.cubicTo(-51, 19.3857498f, -28.6142502f, -3, -1, -3);
2712 pathB.close();
2713 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2714}

◆ skpbangalorenest_com4()

static void skpbangalorenest_com4 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2785 of file PathOpsOpTest.cpp.

2785 {
2786 SkPath path;
2787 path.setFillType(SkPathFillType::kEvenOdd);
2788 path.moveTo(0, 926);
2789 path.lineTo(0, 0);
2790 path.lineTo(1265, 0);
2791 path.lineTo(1265, 926);
2792 path.lineTo(0, 926);
2793 path.close();
2794 SkPath pathB;
2795 pathB.setFillType(SkPathFillType::kWinding);
2796 pathB.moveTo(0, 290);
2797 pathB.lineTo(-2.64514972e-014f, 146);
2798 pathB.lineTo(30, 146);
2799 pathB.lineTo(30, 290);
2800 pathB.close();
2801 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2802}

◆ skpbenzoteh_ru152()

static void skpbenzoteh_ru152 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2804 of file PathOpsOpTest.cpp.

2804 {
2805 SkPath path;
2806 path.setFillType(SkPathFillType::kEvenOdd);
2807 path.moveTo(883, 23);
2808 path.lineTo(883, 0);
2809 path.lineTo(1122.5f, 0);
2810 path.lineTo(1122.5f, 25.2136822f);
2811 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2812 path.quadTo(1120.07104f, 28, 1118, 28);
2813 path.lineTo(888, 28);
2814 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2815 path.quadTo(883, 25.0710678f, 883, 23);
2816 path.close();
2817 SkPath pathB;
2818 pathB.setFillType(SkPathFillType::kWinding);
2819 pathB.moveTo(883, 0);
2820 pathB.lineTo(1123, 0);
2821 pathB.lineTo(1123, 23);
2822 pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2823 pathB.quadTo(1120.07104f, 28, 1118, 28);
2824 pathB.lineTo(888, 28);
2825 pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2826 pathB.quadTo(883, 25.0710678f, 883, 23);
2827 pathB.close();
2828 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2829}

◆ skpbestred_ru37()

static void skpbestred_ru37 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2831 of file PathOpsOpTest.cpp.

2831 {
2832 SkPath path;
2833 path.setFillType(SkPathFillType::kEvenOdd);
2834 path.moveTo(883, 23);
2835 path.lineTo(883, 0);
2836 path.lineTo(1122.5f, 0);
2837 path.lineTo(1122.5f, 25.2136822f);
2838 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2839 path.quadTo(1120.07104f, 28, 1118, 28);
2840 path.lineTo(888, 28);
2841 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2842 path.quadTo(883, 25.0710678f, 883, 23);
2843 path.close();
2844 SkPath pathB;
2845 pathB.setFillType(SkPathFillType::kWinding);
2846 pathB.moveTo(883, 0);
2847 pathB.lineTo(1123, 0);
2848 pathB.lineTo(1123, 23);
2849 pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2850 pathB.quadTo(1120.07104f, 28, 1118, 28);
2851 pathB.lineTo(888, 28);
2852 pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2853 pathB.quadTo(883, 25.0710678f, 883, 23);
2854 pathB.close();
2855 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2856}

◆ skpbingoentertainment_net189()

static void skpbingoentertainment_net189 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2858 of file PathOpsOpTest.cpp.

2858 {
2859 SkPath path;
2860 path.setFillType(SkPathFillType::kEvenOdd);
2861 path.moveTo(896, 745.38678f);
2862 path.lineTo(896, 873.38678f);
2863 path.lineTo(922.567993f, 876.683716f);
2864 path.lineTo(922.567993f, 748.683716f);
2865 path.lineTo(896, 745.38678f);
2866 path.close();
2867 SkPath pathB;
2868 pathB.setFillType(SkPathFillType::kWinding);
2869 pathB.moveTo(899.200928f, 745.783997f);
2870 pathB.cubicTo(897.119385f, 745.525696f, 895.432007f, 752.031982f, 895.432007f, 760.316284f);
2871 pathB.lineTo(895.432007f, 858.316284f);
2872 pathB.cubicTo(895.432007f, 866.600586f, 897.119385f, 873.525696f, 899.200928f, 873.783997f);
2873 pathB.lineTo(918.799133f, 876.216003f);
2874 pathB.cubicTo(920.880615f, 876.474304f, 922.567993f, 869.968018f, 922.567993f, 861.683716f);
2875 pathB.lineTo(922.567993f, 763.683716f);
2876 pathB.cubicTo(922.567993f, 755.399414f, 920.880615f, 748.474304f, 918.799133f, 748.216003f);
2877 pathB.lineTo(899.200928f, 745.783997f);
2878 pathB.close();
2879 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2880}

◆ skpbyte_com1()

static void skpbyte_com1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1716 of file PathOpsOpTest.cpp.

1716 {
1717 SkPath path;
1718 path.setFillType(SkPathFillType::kEvenOdd);
1719 path.moveTo(968.000000f, 14.0000000f);
1720 path.cubicTo(965.238586f, 14.0000000f, 963.000000f, 16.2385769f, 963.000000f, 19.0000000f);
1721 path.lineTo(963.000000f, 32.0000000f);
1722 path.cubicTo(963.000000f, 34.7614250f, 965.238586f, 37.0000000f, 968.000000f, 37.0000000f);
1723 path.lineTo(1034.00000f, 37.0000000f);
1724 path.cubicTo(1036.76147f, 37.0000000f, 1039.00000f, 34.7614250f, 1039.00000f, 32.0000000f);
1725 path.lineTo(1039.00000f, 19.0000000f);
1726 path.cubicTo(1039.00000f, 16.2385769f, 1036.76147f, 14.0000000f, 1034.00000f, 14.0000000f);
1727 path.lineTo(968.000000f, 14.0000000f);
1728 path.close();
1729 SkPath pathB;
1730 pathB.setFillType(SkPathFillType::kInverseWinding);
1731 pathB.moveTo(968.000000f, 14.0000000f);
1732 pathB.lineTo(1034.00000f, 14.0000000f);
1733 pathB.cubicTo(1036.76147f, 14.0000000f, 1039.00000f, 16.2385750f, 1039.00000f, 19.0000000f);
1734 pathB.lineTo(1039.00000f, 32.0000000f);
1735 pathB.cubicTo(1039.00000f, 34.2091408f, 1036.76147f, 36.0000000f, 1034.00000f, 36.0000000f);
1736 pathB.lineTo(968.000000f, 36.0000000f);
1737 pathB.cubicTo(965.238586f, 36.0000000f, 963.000000f, 34.2091408f, 963.000000f, 32.0000000f);
1738 pathB.lineTo(963.000000f, 19.0000000f);
1739 pathB.cubicTo(963.000000f, 16.2385750f, 965.238586f, 14.0000000f, 968.000000f, 14.0000000f);
1740 pathB.close();
1741 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1742}

◆ skpcaffelavazzait_com_ua21()

static void skpcaffelavazzait_com_ua21 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2905 of file PathOpsOpTest.cpp.

2905 {
2906 SkPath path;
2907 path.setFillType(SkPathFillType::kEvenOdd);
2908 path.moveTo(883, 23);
2909 path.lineTo(883, 0);
2910 path.lineTo(1122.5f, 0);
2911 path.lineTo(1122.5f, 25.2136822f);
2912 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2913 path.quadTo(1120.07104f, 28, 1118, 28);
2914 path.lineTo(888, 28);
2915 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2916 path.quadTo(883, 25.0710678f, 883, 23);
2917 path.close();
2918 SkPath pathB;
2919 pathB.setFillType(SkPathFillType::kWinding);
2920 pathB.moveTo(883, 0);
2921 pathB.lineTo(1123, 0);
2922 pathB.lineTo(1123, 23);
2923 pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2924 pathB.quadTo(1120.07104f, 28, 1118, 28);
2925 pathB.lineTo(888, 28);
2926 pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2927 pathB.quadTo(883, 25.0710678f, 883, 23);
2928 pathB.close();
2929 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2930}

◆ skpcamcorder_kz21()

static void skpcamcorder_kz21 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2932 of file PathOpsOpTest.cpp.

2932 {
2933 SkPath path;
2934 path.setFillType(SkPathFillType::kEvenOdd);
2935 path.moveTo(883, 23);
2936 path.lineTo(883, 0);
2937 path.lineTo(1122.5f, 0);
2938 path.lineTo(1122.5f, 25.2136822f);
2939 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2940 path.quadTo(1120.07104f, 28, 1118, 28);
2941 path.lineTo(888, 28);
2942 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2943 path.quadTo(883, 25.0710678f, 883, 23);
2944 path.close();
2945 SkPath pathB;
2946 pathB.setFillType(SkPathFillType::kWinding);
2947 pathB.moveTo(883, 0);
2948 pathB.lineTo(1123, 0);
2949 pathB.lineTo(1123, 23);
2950 pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2951 pathB.quadTo(1120.07104f, 28, 1118, 28);
2952 pathB.lineTo(888, 28);
2953 pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2954 pathB.quadTo(883, 25.0710678f, 883, 23);
2955 pathB.close();
2956 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2957}

◆ skpcarpetplanet_ru22()

static void skpcarpetplanet_ru22 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2735 of file PathOpsOpTest.cpp.

2735 {
2736 SkPath path;
2737 path.setFillType(SkPathFillType::kEvenOdd);
2738 path.moveTo(195, 785);
2739 path.cubicTo(124.307556f, 785, 67, 841.859863f, 67, 912);
2740 path.lineTo(67, 913);
2741 path.cubicTo(67, 917.388916f, 67.2243805f, 921.725769f, 67.662384f, 926);
2742 path.lineTo(322, 926);
2743 path.lineTo(322, 896.048035f);
2744 path.cubicTo(314.09201f, 833.437622f, 260.247131f, 785, 195, 785);
2745 path.close();
2746 SkPath pathB;
2747 pathB.setFillType(SkPathFillType::kWinding);
2748 pathB.moveTo(195, 785);
2749 pathB.cubicTo(265.140167f, 785, 322, 842.307556f, 322, 913);
2750 pathB.cubicTo(322, 983.692444f, 265.140167f, 1041, 195, 1041);
2751 pathB.lineTo(194, 1041);
2752 pathB.cubicTo(123.85984f, 1041, 67, 983.692444f, 67, 913);
2753 pathB.cubicTo(67, 842.307556f, 123.85984f, 785, 194, 785);
2754 pathB.lineTo(195, 785);
2755 pathB.close();
2756 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2757}

◆ skpcarrefour_ro62()

static void skpcarrefour_ro62 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2882 of file PathOpsOpTest.cpp.

2882 {
2883 SkPath path;
2884 path.setFillType(SkPathFillType::kEvenOdd);
2885 path.moveTo(1104, 453);
2886 path.lineTo(399, 453);
2887 path.lineTo(399, 657);
2888 path.cubicTo(399, 661.970581f, 403.029449f, 666, 408, 666);
2889 path.lineTo(1095, 666);
2890 path.cubicTo(1099.97058f, 666, 1104, 661.970581f, 1104, 657);
2891 path.lineTo(1104, 453);
2892 path.close();
2893 SkPath pathB;
2894 pathB.setFillType(SkPathFillType::kInverseWinding);
2895 pathB.moveTo(400, 453);
2896 pathB.lineTo(1103, 453);
2897 pathB.lineTo(1103, 666);
2898 pathB.lineTo(406, 666);
2899 pathB.cubicTo(402.686279f, 666, 400, 663.313721f, 400, 660);
2900 pathB.lineTo(400, 453);
2901 pathB.close();
2902 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2903}

◆ skpcarrot_is24()

static void skpcarrot_is24 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2759 of file PathOpsOpTest.cpp.

2759 {
2760 SkPath path;
2761 path.setFillType(SkPathFillType::kEvenOdd);
2762 path.moveTo(945, 597);
2763 path.quadTo(913.93396f, 597, 891.96698f, 618.96698f);
2764 path.quadTo(870, 640.93396f, 870, 672);
2765 path.quadTo(870, 703.06604f, 891.96698f, 725.03302f);
2766 path.quadTo(913.93396f, 747, 945, 747);
2767 path.quadTo(976.06604f, 747, 998.03302f, 725.03302f);
2768 path.quadTo(1020, 703.06604f, 1020, 672);
2769 path.quadTo(1020, 640.93396f, 998.03302f, 618.96698f);
2770 path.quadTo(976.06604f, 597, 945, 597);
2771 path.close();
2772 SkPath pathB;
2773 pathB.setFillType(SkPathFillType::kWinding);
2774 pathB.moveTo(945.080994f, 597.161987f);
2775 pathB.cubicTo(903.659973f, 597.161987f, 870.080994f, 630.73999f, 870.080994f, 672.161987f);
2776 pathB.cubicTo(870.080994f, 676.096008f, 870.387024f, 679.957031f, 870.971008f, 683.726013f);
2777 pathB.cubicTo(876.53302f, 719.656006f, 907.593994f, 747.161987f, 945.080994f, 747.161987f);
2778 pathB.cubicTo(982.567993f, 747.161987f, 1013.62903f, 719.656006f, 1019.19104f, 683.726013f);
2779 pathB.cubicTo(1019.77502f, 679.955017f, 1020.08099f, 676.094971f, 1020.08099f, 672.161987f);
2780 pathB.cubicTo(1020.08002f, 630.73999f, 986.502014f, 597.161987f, 945.080994f, 597.161987f);
2781 pathB.close();
2782 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2783}

◆ skpcavablar_net563()

static void skpcavablar_net563 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2959 of file PathOpsOpTest.cpp.

2959 {
2960 SkPath path;
2961 path.setFillType(SkPathFillType::kEvenOdd);
2962 path.moveTo(160.000488f, 918);
2963 path.cubicTo(159.164749f, 917.37207f, 158.125824f, 917, 157, 917);
2964 path.lineTo(94, 917);
2965 path.cubicTo(92.874176f, 917, 91.8352661f, 917.37207f, 90.9995193f, 918);
2966 path.lineTo(160.000488f, 918);
2967 path.close();
2968 SkPath pathB;
2969 pathB.setFillType(SkPathFillType::kWinding);
2970 pathB.moveTo(91, 917);
2971 pathB.lineTo(160, 917);
2972 pathB.lineTo(160, 918);
2973 pathB.lineTo(91, 918);
2974 pathB.close();
2975 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2976}

◆ skpClip1()

static void skpClip1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1580 of file PathOpsOpTest.cpp.

1580 {
1581 SkPath path;
1582 path.setFillType(SkPathFillType::kEvenOdd);
1583 path.moveTo(1126.17114f, 877.171204f);
1584 path.quadTo(1127.34314f, 876.000000f, 1129.00000f, 876.000000f);
1585 path.lineTo(1243.00000f, 876.000000f);
1586 path.quadTo(1244.65686f, 876.000000f, 1245.82886f, 877.171204f);
1587 path.quadTo(1247.00000f, 878.343140f, 1247.00000f, 880.000000f);
1588 path.lineTo(1247.00000f, 907.000000f);
1589 path.lineTo(1246.00000f, 907.000000f);
1590 path.lineTo(1246.00000f, 880.000000f);
1591 path.cubicTo(1246.00000f, 878.343140f, 1244.65686f, 877.000000f, 1243.00000f, 877.000000f);
1592 path.lineTo(1129.00000f, 877.000000f);
1593 path.cubicTo(1127.34314f, 877.000000f, 1126.00000f, 878.343140f, 1126.00000f, 880.000000f);
1594 path.lineTo(1126.00000f, 907.000000f);
1595 path.lineTo(1125.00000f, 907.000000f);
1596 path.lineTo(1125.00000f, 880.000000f);
1597 path.quadTo(1125.00000f, 878.343140f, 1126.17114f, 877.171204f);
1598 path.close();
1599 SkPath pathB;
1600 pathB.setFillType(SkPathFillType::kWinding);
1601 pathB.moveTo(1247.00000f, 876.000000f);
1602 pathB.lineTo(1231.00000f, 892.000000f);
1603 pathB.lineTo(1246.00000f, 907.000000f);
1604 pathB.lineTo(1247.00000f, 907.000000f);
1605 pathB.lineTo(1247.00000f, 876.000000f);
1606 pathB.close();
1607 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1608}

◆ skpClip2()

static void skpClip2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1610 of file PathOpsOpTest.cpp.

1610 {
1611 SkPath path;
1612 path.setFillType(SkPathFillType::kEvenOdd);
1613 path.moveTo(134.000000f, 11414.0000f);
1614 path.cubicTo(131.990234f, 11414.0000f, 130.326660f, 11415.4824f, 130.042755f, 11417.4131f);
1615 path.cubicTo(130.233124f, 11418.3193f, 131.037079f, 11419.0000f, 132.000000f, 11419.0000f);
1616 path.lineTo(806.000000f, 11419.0000f);
1617 path.cubicTo(806.962891f, 11419.0000f, 807.766907f, 11418.3193f, 807.957275f, 11417.4131f);
1618 path.cubicTo(807.673401f, 11415.4824f, 806.009766f, 11414.0000f, 804.000000f, 11414.0000f);
1619 path.lineTo(134.000000f, 11414.0000f);
1620 path.close();
1621 SkPath pathB;
1622 pathB.setFillType(SkPathFillType::kInverseWinding);
1623 pathB.moveTo(132.000000f, 11415.0000f);
1624 pathB.lineTo(806.000000f, 11415.0000f);
1625 pathB.cubicTo(807.104553f, 11415.0000f, 808.000000f, 11415.4473f, 808.000000f, 11416.0000f);
1626 pathB.lineTo(808.000000f, 11417.0000f);
1627 pathB.cubicTo(808.000000f, 11418.1045f, 807.104553f, 11419.0000f, 806.000000f, 11419.0000f);
1628 pathB.lineTo(132.000000f, 11419.0000f);
1629 pathB.cubicTo(130.895432f, 11419.0000f, 130.000000f, 11418.1045f, 130.000000f, 11417.0000f);
1630 pathB.lineTo(130.000000f, 11416.0000f);
1631 pathB.cubicTo(130.000000f, 11415.4473f, 130.895432f, 11415.0000f, 132.000000f, 11415.0000f);
1632 pathB.close();
1633 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1634}

◆ skpeldorado_com_ua1()

static void skpeldorado_com_ua1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1692 of file PathOpsOpTest.cpp.

1692 {
1693 SkPath path;
1694 path.setFillType(SkPathFillType::kEvenOdd);
1695 path.moveTo(286.695129f, 291.000000f);
1696 path.lineTo(229.304855f, 561.000000f);
1697 path.lineTo(979.304871f, 561.000000f);
1698 path.lineTo(1036.69507f, 291.000000f);
1699 path.lineTo(286.695129f, 291.000000f);
1700 path.close();
1701 SkPath pathB;
1702 pathB.setFillType(SkPathFillType::kWinding);
1703 pathB.moveTo(1006.69513f, 291.000000f);
1704 pathB.cubicTo(1023.26367f, 291.000000f, 1033.84021f, 304.431458f, 1030.31836f, 321.000000f);
1705 pathB.lineTo(985.681519f, 531.000000f);
1706 pathB.cubicTo(982.159790f, 547.568542f, 965.873413f, 561.000000f, 949.304871f, 561.000000f);
1707 pathB.lineTo(259.304871f, 561.000000f);
1708 pathB.cubicTo(242.736313f, 561.000000f, 232.159805f, 547.568542f, 235.681549f, 531.000000f);
1709 pathB.lineTo(280.318420f, 321.000000f);
1710 pathB.cubicTo(283.840179f, 304.431458f, 300.126587f, 291.000000f, 316.695129f, 291.000000f);
1711 pathB.lineTo(1006.69513f, 291.000000f);
1712 pathB.close();
1713 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1714}

◆ skphealth_com76()

static void skphealth_com76 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1744 of file PathOpsOpTest.cpp.

1744 {
1745 SkPath path;
1746 path.setFillType(SkPathFillType::kEvenOdd);
1747 path.moveTo(708.099182f, 7.09919119f);
1748 path.lineTo(708.099182f, 7.09920025f);
1749 path.quadTo(704.000000f, 11.2010098f, 704.000000f, 17.0000000f);
1750 path.lineTo(704.000000f, 33.0000000f);
1751 path.lineTo(705.000000f, 33.0000000f);
1752 path.lineTo(705.000000f, 17.0000000f);
1753 path.cubicTo(705.000000f, 13.4101496f, 706.455078f, 10.1601505f, 708.807617f, 7.80761385f);
1754 path.lineTo(708.099182f, 7.09919119f);
1755 path.close();
1756 SkPath pathB;
1757 pathB.setFillType(SkPathFillType::kWinding);
1758 pathB.moveTo(704.000000f, 3.00000000f);
1759 pathB.lineTo(704.000000f, 33.0000000f);
1760 pathB.lineTo(705.000000f, 33.0000000f);
1761 pathB.lineTo(719.500000f, 3.00000000f);
1762 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1763}

◆ skpinsomnia_gr72()

static void skpinsomnia_gr72 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2978 of file PathOpsOpTest.cpp.

2978 {
2979 SkPath path;
2980 path.setFillType(SkPathFillType::kEvenOdd);
2981 path.moveTo(1138, 231);
2982 path.lineTo(1137, 243.625748f);
2983 path.lineTo(1137, 926);
2984 path.lineTo(1139, 926);
2985 path.lineTo(1139, 231);
2986 path.lineTo(1138, 231);
2987 path.close();
2988 SkPath pathB;
2989 pathB.setFillType(SkPathFillType::kWinding);
2990 pathB.moveTo(1139, 231);
2991 pathB.lineTo(1138, 231);
2992 pathB.lineTo(633, 6101);
2993 pathB.lineTo(1139, 6607);
2994 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2995}

◆ skpkkiste_to716()

static void skpkkiste_to716 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 2144 of file PathOpsOpTest.cpp.

2144 {
2145 SkPath path;
2146 path.setFillType(SkPathFillType::kEvenOdd);
2147 path.moveTo(1173, 284);
2148 path.cubicTo(1173, 285.125824f, 1173.37207f, 286.164734f, 1174, 287.000488f);
2149 path.lineTo(1174, 123.999496f);
2150 path.cubicTo(1173.37207f, 124.835243f, 1173, 125.874168f, 1173, 127);
2151 path.lineTo(1173, 284);
2152 path.close();
2153 SkPath pathB;
2154 pathB.setFillType(SkPathFillType::kWinding);
2155 pathB.moveTo(1340, 122);
2156 pathB.cubicTo(1342.76147f, 122, 1345, 124.238579f, 1345, 127);
2157 pathB.lineTo(1345, 284);
2158 pathB.cubicTo(1345, 286.761414f, 1342.76147f, 289, 1340, 289);
2159 pathB.lineTo(1178, 289);
2160 pathB.cubicTo(1175.23853f, 289, 1173, 286.761414f, 1173, 284);
2161 pathB.lineTo(1173, 127);
2162 pathB.cubicTo(1173, 124.238579f, 1175.23853f, 122, 1178, 122);
2163 pathB.lineTo(1340, 122);
2164 pathB.close();
2165 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2166}

◆ skpkkiste_to98()

static void skpkkiste_to98 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 1835 of file PathOpsOpTest.cpp.

1835 {
1836 SkPath path;
1837 path.setFillType(SkPathFillType::kEvenOdd);
1838 path.moveTo(96, 122);
1839 path.cubicTo(94.6192932f, 122, 93.3692932f, 122.559647f, 92.4644699f, 123.46447f);
1840 path.lineTo(94.1715698f, 125.17157f);
1841 path.cubicTo(94.8954315f, 124.447708f, 95.8954315f, 124, 97, 124);
1842 path.lineTo(257, 124);
1843 path.cubicTo(258.104553f, 124, 259.104584f, 124.447708f, 259.82843f, 125.17157f);
1844 path.lineTo(261.535522f, 123.46447f);
1845 path.cubicTo(260.630707f, 122.559647f, 259.380707f, 122, 258, 122);
1846 path.lineTo(96, 122);
1847 path.close();
1848 SkPath pathB;
1849 pathB.setFillType(SkPathFillType::kWinding);
1850 pathB.moveTo(258, 122);
1851 pathB.cubicTo(260.761414f, 122, 263, 124.238579f, 263, 127);
1852 pathB.lineTo(263, 284);
1853 pathB.cubicTo(263, 286.761414f, 260.761414f, 289, 258, 289);
1854 pathB.lineTo(96, 289);
1855 pathB.cubicTo(93.2385788f, 289, 91, 286.761414f, 91, 284);
1856 pathB.lineTo(91, 127);
1857 pathB.cubicTo(91, 124.238579f, 93.2385788f, 122, 96, 122);
1858 pathB.lineTo(258, 122);
1859 pathB.close();
1860 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1861}

◆ testDiff1()

static void testDiff1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 412 of file PathOpsOpTest.cpp.

412 {
413 SkPath one, two;
414 one.addRect(0, 0, 6, 6, SkPathDirection::kCW);
415 two.addRect(3, 3, 9, 9, SkPathDirection::kCW);
416 testPathOp(reporter, one, two, kDifference_SkPathOp, filename);
417}

◆ testDiff2()

static void testDiff2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 440 of file PathOpsOpTest.cpp.

440 {
441 SkPath one, two;
442 one.addRect(0, 0, 6, 6, SkPathDirection::kCW);
443 two.addRect(0, 3, 9, 9, SkPathDirection::kCW);
444 testPathOp(reporter, one, two, kDifference_SkPathOp, filename);
445}

◆ testIntersect1()

static void testIntersect1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 398 of file PathOpsOpTest.cpp.

398 {
399 SkPath one, two;
400 one.addRect(0, 0, 6, 6, SkPathDirection::kCW);
401 two.addRect(3, 3, 9, 9, SkPathDirection::kCW);
402 testPathOp(reporter, one, two, kIntersect_SkPathOp, filename);
403}

◆ testIntersect2()

static void testIntersect2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 426 of file PathOpsOpTest.cpp.

426 {
427 SkPath one, two;
428 one.addRect(0, 0, 6, 6, SkPathDirection::kCW);
429 two.addRect(0, 3, 9, 9, SkPathDirection::kCW);
430 testPathOp(reporter, one, two, kIntersect_SkPathOp, filename);
431}

◆ testOp1d()

static void testOp1d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 454 of file PathOpsOpTest.cpp.

454 {
455 SkPath path, pathB;
456 path.setFillType(SkPathFillType::kWinding);
457 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
458 path.addRect(0, 0, 2, 2, SkPathDirection::kCW);
459 pathB.setFillType(SkPathFillType::kWinding);
460 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
461 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
462 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
463}

◆ testOp1u()

static void testOp1u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 487 of file PathOpsOpTest.cpp.

487 {
488 SkPath path, pathB;
489 path.setFillType(SkPathFillType::kWinding);
490 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
491 path.addRect(0, 0, 3, 3, SkPathDirection::kCW);
492 pathB.setFillType(SkPathFillType::kWinding);
493 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
494 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
495 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
496}

◆ testOp2d()

static void testOp2d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 465 of file PathOpsOpTest.cpp.

465 {
466 SkPath path, pathB;
467 path.setFillType(SkPathFillType::kWinding);
468 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
469 path.addRect(0, 0, 2, 2, SkPathDirection::kCW);
470 pathB.setFillType(SkPathFillType::kEvenOdd);
471 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
472 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
473 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
474}

◆ testOp2u()

static void testOp2u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 542 of file PathOpsOpTest.cpp.

542 {
543 SkPath path, pathB;
544 path.setFillType(SkPathFillType::kEvenOdd);
545 path.addRect(0, 0, 2, 2, SkPathDirection::kCW);
546 path.addRect(0, 0, 2, 2, SkPathDirection::kCW);
547 pathB.setFillType(SkPathFillType::kWinding);
548 pathB.addRect(0, 0, 3, 3, SkPathDirection::kCW);
549 pathB.addRect(1, 1, 2, 2, SkPathDirection::kCW);
550 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
551}

◆ testOp3d()

static void testOp3d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 476 of file PathOpsOpTest.cpp.

476 {
477 SkPath path, pathB;
478 path.setFillType(SkPathFillType::kWinding);
479 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
480 path.addRect(1, 1, 2, 2, SkPathDirection::kCW);
481 pathB.setFillType(SkPathFillType::kWinding);
482 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
483 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
484 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
485}

◆ testOp4d()

static void testOp4d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 498 of file PathOpsOpTest.cpp.

498 {
499 SkPath path, pathB;
500 path.setFillType(SkPathFillType::kWinding);
501 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
502 path.addRect(2, 2, 4, 4, SkPathDirection::kCW);
503 pathB.setFillType(SkPathFillType::kWinding);
504 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
505 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
506 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
507}

◆ testOp5d()

static void testOp5d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 509 of file PathOpsOpTest.cpp.

509 {
510 SkPath path, pathB;
511 path.setFillType(SkPathFillType::kEvenOdd);
512 path.addRect(0, 0, 2, 2, SkPathDirection::kCW);
513 path.addRect(0, 0, 3, 3, SkPathDirection::kCW);
514 pathB.setFillType(SkPathFillType::kEvenOdd);
515 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
516 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
517 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
518}

◆ testOp6d()

static void testOp6d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 520 of file PathOpsOpTest.cpp.

520 {
521 SkPath path, pathB;
522 path.setFillType(SkPathFillType::kEvenOdd);
523 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
524 path.addRect(0, 0, 3, 3, SkPathDirection::kCW);
525 pathB.setFillType(SkPathFillType::kWinding);
526 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
527 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
528 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
529}

◆ testOp7d()

static void testOp7d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 531 of file PathOpsOpTest.cpp.

531 {
532 SkPath path, pathB;
533 path.setFillType(SkPathFillType::kEvenOdd);
534 path.addRect(0, 0, 2, 2, SkPathDirection::kCW);
535 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
536 pathB.setFillType(SkPathFillType::kEvenOdd);
537 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
538 pathB.addRect(0, 0, 1, 1, SkPathDirection::kCW);
539 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
540}

◆ testOp8d()

static void testOp8d ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 553 of file PathOpsOpTest.cpp.

553 {
554 SkPath path, pathB;
555 path.addRect(0, 0, 640, 480);
556 pathB.moveTo(577330, 1971.72f);
557 pathB.cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f);
558 pathB.close();
559 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
560}

◆ testRect1()

static void testRect1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3542 of file PathOpsOpTest.cpp.

3542 {
3543 SkPath path, path2;
3544 path.addRect(0, 0, 60, 60, SkPathDirection::kCCW);
3545 path.addRect(30, 20, 50, 50, SkPathDirection::kCCW);
3546 path.addRect(24, 20, 36, 30, SkPathDirection::kCCW);
3547// path.addRect(32, 24, 36, 41, SkPathDirection::kCCW);
3548 testPathOp(reporter, path, path2, kUnion_SkPathOp, filename);
3549}

◆ testRect1_u()

static void testRect1_u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 5752 of file PathOpsOpTest.cpp.

5752 {
5753 SkPath path, pathB;
5754 path.setFillType(SkPathFillType::kWinding);
5755 path.moveTo(0, 0);
5756 path.lineTo(0, 60);
5757 path.lineTo(60, 60);
5758 path.lineTo(60, 0);
5759 path.close();
5760 path.moveTo(30, 20);
5761 path.lineTo(30, 50);
5762 path.lineTo(50, 50);
5763 path.lineTo(50, 20);
5764 path.close();
5765 path.moveTo(24, 20);
5766 path.lineTo(24, 30);
5767 path.lineTo(36, 30);
5768 path.lineTo(36, 20);
5769 path.close();
5770 pathB.setFillType(SkPathFillType::kWinding);
5771 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
5772}

◆ testRect2()

static void testRect2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3551 of file PathOpsOpTest.cpp.

3551 {
3552 SkPath path, pathB;
3553 path.setFillType(SkPathFillType::kWinding);
3554 path.addRect(0, 0, 1, 1, SkPathDirection::kCW);
3555 path.addRect(4, 4, 5, 5, SkPathDirection::kCW);
3556 pathB.setFillType(SkPathFillType::kEvenOdd);
3557 pathB.addRect(0, 0, 2, 2, SkPathDirection::kCW);
3558 pathB.addRect(0, 0, 6, 6, SkPathDirection::kCW);
3559 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3560}

◆ testUnion1()

static void testUnion1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 405 of file PathOpsOpTest.cpp.

405 {
406 SkPath one, two;
407 one.addRect(0, 0, 6, 6, SkPathDirection::kCW);
408 two.addRect(3, 3, 9, 9, SkPathDirection::kCW);
409 testPathOp(reporter, one, two, kUnion_SkPathOp, filename);
410}

◆ testUnion2()

static void testUnion2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 433 of file PathOpsOpTest.cpp.

433 {
434 SkPath one, two;
435 one.addRect(0, 0, 6, 6, SkPathDirection::kCW);
436 two.addRect(0, 3, 9, 9, SkPathDirection::kCW);
437 testPathOp(reporter, one, two, kUnion_SkPathOp, filename);
438}

◆ testXor1()

static void testXor1 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 419 of file PathOpsOpTest.cpp.

419 {
420 SkPath one, two;
421 one.addRect(0, 0, 6, 6, SkPathDirection::kCW);
422 two.addRect(3, 3, 9, 9, SkPathDirection::kCW);
423 testPathOp(reporter, one, two, kXOR_SkPathOp, filename);
424}

◆ testXor2()

static void testXor2 ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 447 of file PathOpsOpTest.cpp.

447 {
448 SkPath one, two;
449 one.addRect(0, 0, 6, 6, SkPathDirection::kCW);
450 two.addRect(0, 3, 9, 9, SkPathDirection::kCW);
451 testPathOp(reporter, one, two, kXOR_SkPathOp, filename);
452}

◆ xOp1i()

static void xOp1i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3229 of file PathOpsOpTest.cpp.

3229 {
3230 SkPath path, pathB;
3231 path.setFillType(SkPathFillType::kEvenOdd);
3232 path.moveTo(1, 4);
3233 path.cubicTo(1, 5, 6, 0, 5, 1);
3234 path.close();
3235 pathB.setFillType(SkPathFillType::kEvenOdd);
3236 pathB.moveTo(0, 6);
3237 pathB.cubicTo(1, 5, 4, 1, 5, 1);
3238 pathB.close();
3239 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3240}

◆ xOp1u()

static void xOp1u ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3216 of file PathOpsOpTest.cpp.

3216 {
3217 SkPath path, pathB;
3218 path.setFillType(SkPathFillType::kEvenOdd);
3219 path.moveTo(1, 4);
3220 path.cubicTo(4, 5, 3, 2, 6, 3);
3221 path.close();
3222 pathB.setFillType(SkPathFillType::kEvenOdd);
3223 pathB.moveTo(2, 3);
3224 pathB.cubicTo(3, 6, 4, 1, 5, 4);
3225 pathB.close();
3226 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3227}

◆ xOp2i()

static void xOp2i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3242 of file PathOpsOpTest.cpp.

3242 {
3243 SkPath path, pathB;
3244 path.setFillType(SkPathFillType::kEvenOdd);
3245 path.moveTo(1, 5);
3246 path.cubicTo(0, 4, 3, 2, 6, 1);
3247 path.close();
3248 pathB.setFillType(SkPathFillType::kEvenOdd);
3249 pathB.moveTo(2, 3);
3250 pathB.cubicTo(1, 6, 5, 1, 4, 0);
3251 pathB.close();
3252 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3253}

◆ xOp3i()

static void xOp3i ( skiatest::Reporter *  reporter,
const char *  filename 
)
static

Definition at line 3255 of file PathOpsOpTest.cpp.

3255 {
3256 SkPath path, pathB;
3257 path.setFillType(SkPathFillType::kWinding);
3258 path.moveTo(1,4);
3259 path.cubicTo(0,5, 4,1, 3,1);
3260 path.close();
3261 pathB.setFillType(SkPathFillType::kWinding);
3262 pathB.moveTo(1,4);
3263 pathB.cubicTo(1,3, 4,1, 5,0);
3264 pathB.close();
3265 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3266}

Variable Documentation

◆ failTestCount

const size_t failTestCount = std::size(failTests)
static

Definition at line 12539 of file PathOpsOpTest.cpp.

◆ failTests

struct TestDesc failTests[]
static

Definition at line 12451 of file PathOpsOpTest.cpp.

12451 {
12452 TEST(fuzz767834),
12453 TEST(fuzz754434_1),
12454 TEST(fuzz754434_2),
12455 TEST(fuzz754434_3),
12456 TEST(fuzz754434_4),
12457 TEST(fuzzhang_3),
12458 TEST(fuzzhang_2),
12459 TEST(release_13),
12460 TEST(fuzzhang_1),
12461 TEST(fuzz763_57),
12462 TEST(fuzz763_56),
12463 TEST(fuzz763_55),
12464 TEST(fuzz763_54),
12465 TEST(fuzz763_53),
12466 TEST(fuzz763_52),
12467 TEST(fuzz763_51),
12468 TEST(fuzz763_50),
12469 TEST(fuzz763_49),
12470 TEST(fuzz763_48),
12471 TEST(fuzz763_47),
12472 TEST(fuzz763_46),
12473 TEST(fuzz763_45),
12474 TEST(fuzz763_44),
12475 TEST(fuzz763_43),
12476 TEST(fuzz763_42),
12477 TEST(fuzz763_41),
12478 TEST(fuzz763_40),
12479 TEST(fuzz763_39),
12480 TEST(fuzz763_38),
12481 TEST(fuzz763_37),
12482 TEST(fuzz763_36),
12483 TEST(fuzz763_35),
12484 TEST(fuzz763_34),
12485 TEST(fuzz763_33),
12486 TEST(fuzz763_32),
12487 TEST(fuzz763_31),
12488 TEST(fuzz763_30),
12489 TEST(fuzz763_29),
12490 TEST(fuzz763_28),
12491 TEST(fuzz763_27),
12492 TEST(fuzz763_26),
12493 TEST(fuzz763_25),
12494 TEST(fuzz763_24),
12495 TEST(fuzz763_23),
12496 TEST(fuzz763_22),
12497 TEST(fuzz763_21),
12498 TEST(fuzz763_20),
12499 TEST(fuzz763_19),
12500 TEST(fuzz763_18),
12501 TEST(fuzz763_17),
12502 TEST(fuzz763_16),
12503 TEST(fuzz763_15),
12504 TEST(fuzz763_14),
12505 TEST(fuzz763_13),
12506 TEST(fuzz763_12),
12507 TEST(fuzz763_11),
12508 TEST(fuzz763_10),
12509 TEST(kfuzz2),
12510 TEST(fuzz763_7),
12511 TEST(fuzz763_6),
12512 TEST(fuzz763_2c),
12513 TEST(fuzz763_2b),
12514 TEST(fuzz763_2a),
12515 TEST(fuzz763_5a),
12516 TEST(fuzz763_3a),
12517 TEST(fuzz763_1a),
12518 TEST(fuzz763_1b),
12519 TEST(fuzz763_1c),
12520 TEST(fuzz763_2),
12521 TEST(fuzz763_5),
12522 TEST(fuzz763_3),
12523 TEST(fuzz763_4),
12524 TEST(fuzz763_9),
12525 TEST(fuzz1450_1),
12526 TEST(fuzz1450_0),
12527 TEST(bug597926_0),
12528 TEST(fuzz535151),
12529 TEST(fuzz753_91),
12530 TEST(fuzz714),
12531 TEST(fuzz487a),
12532 TEST(fuzz433),
12533 TEST(fuzz1),
12534 TEST(fuzz487b),
12535 TEST(fuzz433b),
12536 TEST(bufferOverflow),
12537};
bufferOverflow
static void bufferOverflow(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9634
fuzz763_48
static void fuzz763_48(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11845
fuzz754434_4
static void fuzz754434_4(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:12427
fuzz535151
static void fuzz535151(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9623
fuzz763_17
static void fuzz763_17(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10694
fuzz763_5
static void fuzz763_5(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10017
fuzz763_9
static void fuzz763_9(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9921
fuzz763_11
static void fuzz763_11(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10444
fuzz763_2a
static void fuzz763_2a(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10196
fuzzhang_2
static void fuzzhang_2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:12273
fuzz763_34
static void fuzz763_34(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11355
fuzz487a
static void fuzz487a(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9685
fuzz763_22
static void fuzz763_22(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10948
fuzz763_4
static void fuzz763_4(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9949
fuzz763_51
static void fuzz763_51(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11937
fuzz1
static void fuzz1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9803
fuzz1450_1
static void fuzz1450_1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9892
fuzz763_16
static void fuzz763_16(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10639
fuzz763_42
static void fuzz763_42(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11683
release_13
static void release_13(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:12197
fuzz487b
static void fuzz487b(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9731
fuzz763_3
static void fuzz763_3(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9982
fuzz763_47
static void fuzz763_47(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11820
fuzz763_37
static void fuzz763_37(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11476
TEST
#define TEST(name)
Definition PathOpsOpTest.cpp:9123
fuzz754434_3
static void fuzz754434_3(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:12407
fuzz763_2b
static void fuzz763_2b(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10216
fuzz763_30
static void fuzz763_30(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11233
fuzz763_7
static void fuzz763_7(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10314
fuzz763_26
static void fuzz763_26(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11089
fuzz763_45
static void fuzz763_45(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11770
fuzz763_53
static void fuzz763_53(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11982
fuzz763_43
static void fuzz763_43(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11714
fuzz433
static void fuzz433(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9643
fuzz763_56
static void fuzz763_56(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:12085
fuzz763_12
static void fuzz763_12(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10495
fuzz763_1c
static void fuzz763_1c(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10082
fuzz763_39
static void fuzz763_39(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11659
fuzz763_14
static void fuzz763_14(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10569
fuzz763_57
static void fuzz763_57(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:12122
fuzz763_44
static void fuzz763_44(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11749
fuzz763_1b
static void fuzz763_1b(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10100
fuzz763_27
static void fuzz763_27(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11185
fuzz763_40
static void fuzz763_40(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11632
fuzz763_50
static void fuzz763_50(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11916
fuzz763_38
static void fuzz763_38(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11530
fuzz754434_1
static void fuzz754434_1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:12363
fuzz763_25
static void fuzz763_25(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11064
fuzz714
static void fuzz714(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9777
fuzz763_29
static void fuzz763_29(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11201
fuzz763_19
static void fuzz763_19(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10797
fuzz767834
static void fuzz767834(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9517
fuzz763_33
static void fuzz763_33(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11288
fuzz754434_2
static void fuzz754434_2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:12383
bug597926_0
static void bug597926_0(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9850
fuzz763_10
static void fuzz763_10(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10401
fuzz763_24
static void fuzz763_24(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11015
fuzzhang_3
static void fuzzhang_3(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:12311
fuzz763_15
static void fuzz763_15(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10584
fuzz763_32
static void fuzz763_32(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11335
fuzz763_55
static void fuzz763_55(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:12055
fuzz763_1a
static void fuzz763_1a(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10123
fuzz1450_0
static void fuzz1450_0(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9873
fuzz763_23
static void fuzz763_23(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10974
fuzz763_35
static void fuzz763_35(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11437
fuzz763_36
static void fuzz763_36(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11383
fuzzhang_1
static void fuzzhang_1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:12171
fuzz763_13
static void fuzz763_13(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10533
fuzz763_49
static void fuzz763_49(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11883
fuzz763_52
static void fuzz763_52(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11953
fuzz763_2
static void fuzz763_2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10042
fuzz763_20
static void fuzz763_20(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10847
fuzz763_28
static void fuzz763_28(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11147
fuzz763_31
static void fuzz763_31(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11263
fuzz433b
static void fuzz433b(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9662
fuzz753_91
static void fuzz753_91(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9826
fuzz763_18
static void fuzz763_18(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10746
fuzz763_41
static void fuzz763_41(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11593
fuzz763_21
static void fuzz763_21(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10905
fuzz763_2c
static void fuzz763_2c(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10263
fuzz763_3a
static void fuzz763_3a(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10151
fuzz763_54
static void fuzz763_54(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:12012
fuzz763_6
static void fuzz763_6(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10288
kfuzz2
static void kfuzz2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10368
fuzz763_46
static void fuzz763_46(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:11805
fuzz763_5a
static void fuzz763_5a(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:10172

◆ firstSubTest

void(* firstSubTest) (skiatest::Reporter *, const char *filename) ( skiatest::Reporter *  ,
const char *  filename 
) = nullptr
static

Definition at line 9501 of file PathOpsOpTest.cpp.

◆ firstTest

void(* firstTest) (skiatest::Reporter *, const char *filename) ( skiatest::Reporter *  ,
const char *  filename 
) = nullptr
static

Definition at line 9120 of file PathOpsOpTest.cpp.

◆ ops

SkPathOp ops[]
Initial value:
= {
kUnion_SkPathOp,
kXOR_SkPathOp,
kReverseDifference_SkPathOp,
kXOR_SkPathOp,
kReverseDifference_SkPathOp,
}

Definition at line 1181 of file PathOpsOpTest.cpp.

1181 {
1182 kUnion_SkPathOp,
1183 kXOR_SkPathOp,
1184 kReverseDifference_SkPathOp,
1185 kXOR_SkPathOp,
1186 kReverseDifference_SkPathOp,
1187};

◆ repTests

struct TestDesc repTests[]
static
Initial value:
= {
TEST(fuzz763_5a),
}

Definition at line 12545 of file PathOpsOpTest.cpp.

12545 {
12546 TEST(fuzz763_5a),
12547};

◆ runReverse

bool runReverse = false
static

Definition at line 9505 of file PathOpsOpTest.cpp.

◆ runSubTests

bool runSubTests = false
static

Definition at line 9503 of file PathOpsOpTest.cpp.

◆ runSubTestsFirst

bool runSubTestsFirst = true
static

Definition at line 9504 of file PathOpsOpTest.cpp.

◆ skipTest

void(* skipTest) (skiatest::Reporter *, const char *filename) ( skiatest::Reporter *  ,
const char *  filename 
) = nullptr
static

Definition at line 9119 of file PathOpsOpTest.cpp.

◆ stopTest

void(* stopTest) (skiatest::Reporter *, const char *filename) ( skiatest::Reporter *  ,
const char *  filename 
) = nullptr
static

Definition at line 9121 of file PathOpsOpTest.cpp.

◆ subTestCount

const size_t subTestCount = std::size(subTests)
static

Definition at line 9499 of file PathOpsOpTest.cpp.

◆ subTests

struct TestDesc subTests[]
static
Initial value:
= {
TEST(loops47i),
TEST(loops61i),
TEST(loops62i),
TEST(issue3517),
}
loops47i
static void loops47i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4890
loops62i
static void loops62i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5123
loops61i
void loops61i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5110
issue3517
static void issue3517(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3676

Definition at line 9492 of file PathOpsOpTest.cpp.

9492 {
9493 TEST(loops47i),
9494 TEST(loops61i),
9495 TEST(loops62i),
9496 TEST(issue3517),
9497};

◆ testCount

const size_t testCount = std::size(tests)
static

Definition at line 9490 of file PathOpsOpTest.cpp.

◆ tests

struct TestDesc tests[]
static

Definition at line 9125 of file PathOpsOpTest.cpp.

9125 {
9126 TEST(bug8380),
9127 TEST(crbug_526025),
9128 TEST(bug8228),
9129 TEST(op_4),
9130 TEST(op_1),
9131 TEST(op_2),
9132 TEST(op_3),
9133 TEST(grshapearcs1),
9134 TEST(filinmangust14),
9135 TEST(testRect1_u),
9136 TEST(halbug),
9137 TEST(seanbug),
9138 TEST(android1),
9139 TEST(bug5240),
9140 TEST(circlesOp4),
9141 TEST(loop17),
9142 TEST(cubicOp158),
9143 TEST(loops_i1),
9144 TEST(loops_i2),
9145 TEST(loops_i3),
9146 TEST(loops_i4),
9147 TEST(loops_i5),
9148 TEST(loops_i6),
9149 TEST(cubics_d3),
9150 TEST(cubics_o),
9151 TEST(cubics_d2),
9152 TEST(cubics_d),
9153 TEST(dean2),
9154 TEST(fuzzX_392),
9155 TEST(fuzz38),
9156 TEST(cubics44d),
9157 TEST(cubics45u),
9158 TEST(loops61i),
9159 TEST(loops62i),
9160 TEST(loops63i),
9161 TEST(loops58iAsQuads),
9162 TEST(cubics41d),
9163 TEST(loops59iasQuads),
9164 TEST(loops59i),
9165 TEST(loops44i),
9166 TEST(loops45i),
9167 TEST(loops46i),
9168 TEST(loops47i),
9169 TEST(loops48i),
9170 TEST(loops49i),
9171 TEST(loops50i),
9172 TEST(loops51i),
9173 TEST(loops52i),
9174 TEST(loops53i),
9175 TEST(loops54i),
9176 TEST(loops55i),
9177 TEST(loops56i),
9178 TEST(loops57i),
9179 TEST(loops58i),
9180 TEST(loops33iMod),
9181 TEST(loops33iAsQuads),
9182 TEST(loops33i),
9183 TEST(loops40i),
9184 TEST(loops40iAsQuads),
9185 TEST(loops39i),
9186 TEST(loops38i),
9187 TEST(loops37i),
9188 TEST(loops36i),
9189 TEST(loops35i),
9190 TEST(loops34i),
9191 TEST(loops32i),
9192 TEST(loops31i),
9193 TEST(loops30i),
9194 TEST(loops29i),
9195 TEST(loops28i),
9196 TEST(loops27i),
9197 TEST(loops26i),
9198 TEST(loops25i),
9199 TEST(loops24i),
9200 TEST(loops23i),
9201 TEST(loops22i),
9202 TEST(loops21i),
9203 TEST(loops20i),
9204 TEST(cubics20d),
9205 TEST(cubics6d),
9206 TEST(cubics7d),
9207 TEST(cubics8d),
9208 TEST(cubics9d),
9209 TEST(cubics10u),
9210 TEST(cubics11i),
9211 TEST(cubics12d),
9212 TEST(cubics13d),
9213 TEST(cubics14d),
9214 TEST(cubics15d),
9215 TEST(cubics16i),
9216 TEST(cubics17d),
9217 TEST(cubics18d),
9218 TEST(cubics19d),
9219 TEST(cubicOp157),
9220 TEST(cubicOp142),
9221 TEST(loops4i),
9222 TEST(quadRect1),
9223 TEST(quadRect2),
9224 TEST(quadRect3),
9225 TEST(quadRect4),
9226 TEST(quadRect5),
9227 TEST(quadRect6),
9228 TEST(cubicOp141),
9229 TEST(cubicOp58d),
9230 TEST(loops5i),
9231 TEST(cubicOp140),
9232 TEST(cubicOp139),
9233 TEST(cubics138),
9234 TEST(cubics137),
9235 TEST(cubicOp136a),
9236 TEST(cubicOp136),
9237 TEST(cubicOp135),
9238 TEST(cubicOp134),
9239 TEST(cubicOp133),
9240 TEST(loop12),
9241 TEST(cubicOp132),
9242 TEST(loop11),
9243 TEST(loop10),
9244 TEST(circlesOp3),
9245 TEST(loop9),
9246 TEST(loop8),
9247 TEST(rects5),
9248 TEST(loop7),
9249 TEST(cubicOp130a),
9250 TEST(rRect1x),
9251 TEST(circlesOp2),
9252 TEST(circlesOp1),
9253 TEST(cubicOp131),
9254 TEST(cubicOp130),
9255 TEST(cubicOp129),
9256 TEST(cubicOp128),
9257 TEST(cubicOp127),
9258 TEST(cubicOp126),
9259 TEST(cubicOp125),
9260 TEST(cubicOp124),
9261 TEST(loop6),
9262 TEST(loop5),
9263 TEST(cubicOp123),
9264 TEST(cubicOp122),
9265 TEST(cubicOp121),
9266 TEST(cubicOp120),
9267 TEST(cubicOp119),
9268 TEST(loop4),
9269 TEST(loop3),
9270 TEST(loop2),
9271 TEST(loop1asQuad),
9272 TEST(loop1),
9273 TEST(issue3517),
9274 TEST(cubicOp118),
9275 TEST(cubicOp117),
9276 TEST(cubicOp116),
9277 TEST(testRect2),
9278 TEST(testRect1),
9279 TEST(cubicOp115),
9280 TEST(issue2753),
9281 TEST(cubicOp114),
9282 TEST(issue2808),
9283 TEST(cubicOp114asQuad),
9284 TEST(rects4),
9285 TEST(rects3),
9286 TEST(rects2),
9287 TEST(rects1),
9288 TEST(issue2540),
9289 TEST(issue2504),
9290 TEST(kari1),
9291 TEST(quadOp10i),
9292 TEST(cubicOp113),
9293 TEST(skpcarrot_is24),
9294 TEST(issue1417),
9295 TEST(cubicOp112),
9296 TEST(skpadspert_net23),
9297 TEST(skpadspert_de11),
9298 TEST(findFirst1),
9299 TEST(xOp2i),
9300 TEST(xOp3i),
9301 TEST(xOp1u),
9302 TEST(xOp1i),
9303 TEST(cubicOp111),
9304 TEST(cubicOp110),
9305 TEST(cubicOp109),
9306 TEST(cubicOp108),
9307 TEST(cubicOp107),
9308 TEST(cubicOp106),
9309 TEST(cubicOp105),
9310 TEST(cubicOp104),
9311 TEST(cubicOp103),
9312 TEST(cubicOp102),
9313 TEST(cubicOp101),
9314 TEST(cubicOp100),
9315 TEST(cubicOp99),
9316 TEST(issue1435),
9317 TEST(cubicOp98x),
9318 TEST(cubicOp97x),
9319 TEST(skpcarpetplanet_ru22),
9320 TEST(cubicOp96d),
9321 TEST(cubicOp95u),
9322 TEST(skpadbox_lt15),
9323 TEST(skpagentxsites_com55),
9324 TEST(skpadventistmission_org572),
9325 TEST(skpadoption_org196),
9326 TEST(skpbambootheme_com12),
9327 TEST(skpbakosoft_com10),
9328 TEST(skpakmmos_ru100),
9329 TEST(skpbangalorenest_com4),
9330 TEST(skpbingoentertainment_net189),
9331 TEST(skpbestred_ru37),
9332 TEST(skpbenzoteh_ru152),
9333 TEST(skpcamcorder_kz21),
9334 TEST(skpcaffelavazzait_com_ua21),
9335 TEST(skpcarrefour_ro62),
9336 TEST(skpcavablar_net563),
9337 TEST(skpinsomnia_gr72),
9338 TEST(skpadbox_lt8),
9339 TEST(skpact_com43),
9340 TEST(skpacesoftech_com47),
9341 TEST(skpabcspark_ca103),
9342 TEST(cubicOp94u),
9343 TEST(cubicOp93d),
9344 TEST(cubicOp92i),
9345 TEST(skpadithya_putr4_blogspot_com551),
9346 TEST(skpadindex_de4),
9347 TEST(skpaiaigames_com870),
9348 TEST(skpaaalgarve_org53),
9349 TEST(skpkkiste_to716),
9350 TEST(cubicOp91u),
9351 TEST(cubicOp90u),
9352 TEST(cubicOp89u),
9353 TEST(cubicOp88u),
9354 TEST(cubicOp87u),
9355 TEST(cubicOp86i),
9356 TEST(loopEdge2),
9357 TEST(loopEdge1),
9358 TEST(rectOp3x),
9359 TEST(rectOp2i),
9360 TEST(rectOp1i),
9361 TEST(issue1418b),
9362 TEST(cubicOp85i),
9363 TEST(issue1418),
9364 TEST(skpkkiste_to98),
9365 TEST(skpahrefs_com29),
9366 TEST(cubicOp85d),
9367 TEST(skpahrefs_com88),
9368 TEST(skphealth_com76),
9369 TEST(skpancestry_com1),
9370 TEST(skpbyte_com1),
9371 TEST(skpeldorado_com_ua1),
9372 TEST(skp96prezzi1),
9373 TEST(skpClip2),
9374 TEST(skpClip1),
9375 TEST(cubicOp84d),
9376 TEST(cubicOp83i),
9377 TEST(cubicOp82i),
9378 TEST(cubicOp81d),
9379 TEST(cubicOp80i),
9380 TEST(cubicOp79u),
9381 TEST(cubicOp78u),
9382 TEST(cubicOp77i),
9383 TEST(cubicOp76u),
9384 TEST(cubicOp75d),
9385 TEST(cubicOp74d),
9386 TEST(cubicOp73d),
9387 TEST(cubicOp72i),
9388 TEST(cubicOp71d),
9389 TEST(skp5),
9390 TEST(skp4),
9391 TEST(skp3),
9392 TEST(skp2),
9393 TEST(skp1),
9394 TEST(rRect1),
9395 TEST(cubicOp70d),
9396 TEST(cubicOp69d),
9397 TEST(cubicOp68u),
9398 TEST(cubicOp67u),
9399 TEST(cubicOp66u),
9400 TEST(rectOp1d),
9401 TEST(cubicOp65d),
9402 TEST(cubicOp64d),
9403 TEST(cubicOp63d),
9404 TEST(cubicOp62d),
9405 TEST(cubicOp61d),
9406 TEST(cubicOp60d),
9407 TEST(cubicOp59d),
9408 TEST(cubicOp57d),
9409 TEST(cubicOp56d),
9410 TEST(cubicOp55d),
9411 TEST(cubicOp54d),
9412 TEST(cubicOp53d),
9413 TEST(cubicOp52d),
9414 TEST(cubicOp51d),
9415 TEST(cubicOp50d),
9416 TEST(cubicOp49d),
9417 TEST(cubicOp48d),
9418 TEST(cubicOp47d),
9419 TEST(cubicOp46d),
9420 TEST(cubicOp45d),
9421 TEST(cubicOp44d),
9422 TEST(cubicOp43d),
9423 TEST(cubicOp42d),
9424 TEST(cubicOp41i),
9425 TEST(cubicOp40d),
9426 TEST(cubicOp39d),
9427 TEST(cubicOp38d),
9428 TEST(cubicOp37d),
9429 TEST(cubicOp36u),
9430 TEST(cubicOp35d),
9431 TEST(cubicOp34d),
9432 TEST(cubicOp33i),
9433 TEST(cubicOp32d),
9434 TEST(cubicOp31d),
9435 TEST(cubicOp31x),
9436 TEST(cubicOp31u),
9437 TEST(cubicOp30d),
9438 TEST(cubicOp29d),
9439 TEST(cubicOp28u),
9440 TEST(cubicOp27d),
9441 TEST(cubicOp26d),
9442 TEST(cubicOp25i),
9443 TEST(testOp8d),
9444 TEST(testDiff1),
9445 TEST(testIntersect1),
9446 TEST(testUnion1),
9447 TEST(testXor1),
9448 TEST(testDiff2),
9449 TEST(testIntersect2),
9450 TEST(testUnion2),
9451 TEST(testXor2),
9452 TEST(testOp1d),
9453 TEST(testOp2d),
9454 TEST(testOp3d),
9455 TEST(testOp1u),
9456 TEST(testOp4d),
9457 TEST(testOp5d),
9458 TEST(testOp6d),
9459 TEST(testOp7d),
9460 TEST(testOp2u),
9461
9462 TEST(cubicOp24d),
9463 TEST(cubicOp23d),
9464 TEST(cubicOp22d),
9465 TEST(cubicOp21d),
9466 TEST(cubicOp20d),
9467 TEST(cubicOp19i),
9468 TEST(cubicOp18d),
9469 TEST(cubicOp17d),
9470 TEST(cubicOp16d),
9471 TEST(cubicOp15d),
9472 TEST(cubicOp14d),
9473 TEST(cubicOp13d),
9474 TEST(cubicOp12d),
9475 TEST(cubicOp11d),
9476 TEST(cubicOp10d),
9477 TEST(cubicOp1i),
9478 TEST(cubicOp9d),
9479 TEST(quadOp9d),
9480 TEST(lineOp9d),
9481 TEST(cubicOp8d),
9482 TEST(cubicOp7d),
9483 TEST(cubicOp6d),
9484 TEST(cubicOp5d),
9485 TEST(cubicOp3d),
9486 TEST(cubicOp2d),
9487 TEST(cubicOp1d),
9488};
testRect1
static void testRect1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3542
cubicOp114
static void cubicOp114(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3305
skpeldorado_com_ua1
static void skpeldorado_com_ua1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1692
cubicOp10d
static void cubicOp10d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:203
cubicOp58d
static void cubicOp58d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1016
loops39i
static void loops39i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4807
cubicOp32d
static void cubicOp32d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:678
cubicOp17d
static void cubicOp17d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:294
cubicOp26d
static void cubicOp26d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:574
rectOp1d
static void rectOp1d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1120
skpadithya_putr4_blogspot_com551
static void skpadithya_putr4_blogspot_com551(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2429
cubicOp47d
static void cubicOp47d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:873
dean2
static void dean2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5237
cubicOp52d
static void cubicOp52d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:938
loops25i
static void loops25i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4575
cubicOp112
static void cubicOp112(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3281
loops29i
static void loops29i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4627
cubicOp24d
static void cubicOp24d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:385
cubicOp94u
static void cubicOp94u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2530
op_4
static void op_4(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9033
android1
static void android1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5432
skpkkiste_to716
static void skpkkiste_to716(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2144
issue1435
static void issue1435(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2093
testXor1
static void testXor1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:419
cubicOp85i
static void cubicOp85i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2001
bug8228
static void bug8228(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9056
testOp5d
static void testOp5d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:509
cubicOp81d
static void cubicOp81d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1524
seanbug
static void seanbug(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5449
cubicOp113
static void cubicOp113(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3294
cubicOp140
static void cubicOp140(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4177
cubicOp134
static void cubicOp134(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4085
cubicOp93d
static void cubicOp93d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2517
cubicOp131
static void cubicOp131(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3898
lineOp9d
static void lineOp9d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:171
cubicOp33i
static void cubicOp33i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:691
cubicOp136
static void cubicOp136(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4111
loops50i
static void loops50i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4929
cubicOp8d
static void cubicOp8d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:130
rectOp1i
static void rectOp1i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2044
cubicOp27d
static void cubicOp27d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:587
loops_i4
static void loops_i4(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5323
cubicOp74d
static void cubicOp74d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1423
skpClip2
static void skpClip2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1610
op_1
static void op_1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:8966
loop1
static void loop1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3601
cubics_d
static void cubics_d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5258
cubicOp122
static void cubicOp122(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3727
issue2753
static void issue2753(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3480
cubicOp83i
static void cubicOp83i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1552
cubicOp53d
static void cubicOp53d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:951
cubicOp23d
static void cubicOp23d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:372
cubicOp73d
static void cubicOp73d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1408
skpact_com43
static void skpact_com43(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2361
cubicOp86i
static void cubicOp86i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2212
skp2
static void skp2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1259
cubicOp43d
static void cubicOp43d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:821
cubicOp18d
static void cubicOp18d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:307
circlesOp4
static void circlesOp4(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5412
cubicOp31d
static void cubicOp31d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:639
loops32i
static void loops32i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4666
cubicOp1d
static void cubicOp1d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:52
loop11
static void loop11(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4037
cubics_d2
static void cubics_d2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5271
skpadindex_de4
static void skpadindex_de4(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2410
cubicOp108
static void cubicOp108(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3166
loops63i
static void loops63i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5136
loops33iMod
static void loops33iMod(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4692
testRect1_u
static void testRect1_u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5752
crbug_526025
static void crbug_526025(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5189
loops36i
static void loops36i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4768
cubicOp103
static void cubicOp103(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3101
loops45i
static void loops45i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4862
cubicOp101
static void cubicOp101(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3075
loops38i
static void loops38i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4794
cubicOp67u
static void cubicOp67u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1146
cubicOp29d
static void cubicOp29d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:613
xOp1u
static void xOp1u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3216
quadRect6
static void quadRect6(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4253
cubicOp14d
static void cubicOp14d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:255
op_3
static void op_3(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9009
testDiff1
static void testDiff1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:412
loop10
static void loop10(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4026
cubicOp2d
static void cubicOp2d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:65
cubics18d
static void cubics18d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4458
loops_i3
static void loops_i3(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5310
loops48i
static void loops48i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4903
testOp8d
static void testOp8d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:553
quadRect1
static void quadRect1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4203
loops58i
static void loops58i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5033
cubicOp130
static void cubicOp130(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3853
cubicOp15d
static void cubicOp15d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:268
cubicOp109
static void cubicOp109(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3179
cubicOp142
static void cubicOp142(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4289
skpcarrot_is24
static void skpcarrot_is24(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2759
cubicOp107
static void cubicOp107(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3153
skpakmmos_ru100
static void skpakmmos_ru100(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2716
loop1asQuad
static void loop1asQuad(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3612
loopEdge1
static void loopEdge1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2168
cubicOp35d
static void cubicOp35d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:717
skpadventistmission_org572
static void skpadventistmission_org572(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2619
cubicOp96d
static void cubicOp96d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3010
rects3
static void rects3(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3458
cubicOp88u
static void cubicOp88u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2239
skpadspert_net23
static void skpadspert_net23(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2592
cubicOp39d
static void cubicOp39d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:769
cubicOp126
static void cubicOp126(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3801
rects4
static void rects4(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3469
cubicOp60d
static void cubicOp60d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1042
bug8380
static void bug8380(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:9095
testRect2
static void testRect2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3551
cubics10u
static void cubics10u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4354
cubicOp133
static void cubicOp133(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4072
cubics7d
static void cubics7d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4315
loops35i
static void loops35i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4755
quadOp10i
static void quadOp10i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3334
issue1418
static void issue1418(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1975
cubicOp80i
static void cubicOp80i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1509
cubicOp115
static void cubicOp115(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3528
cubicOp124
static void cubicOp124(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3775
testDiff2
static void testDiff2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:440
cubicOp78u
static void cubicOp78u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1481
skpbakosoft_com10
static void skpbakosoft_com10(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2666
skp96prezzi1
static void skp96prezzi1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1636
loops51i
static void loops51i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4942
rects2
static void rects2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3431
quadRect3
static void quadRect3(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4223
loops4i
static void loops4i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4263
skpadbox_lt15
static void skpadbox_lt15(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2543
skpaiaigames_com870
static void skpaiaigames_com870(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2474
skp3
static void skp3(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1279
cubics_d3
static void cubics_d3(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5362
loop7
static void loop7(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3973
cubicOp38d
static void cubicOp38d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:756
testXor2
static void testXor2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:447
rects1
static void rects1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3404
loops28i
static void loops28i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4614
cubicOp46d
static void cubicOp46d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:860
skphealth_com76
static void skphealth_com76(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1744
loops55i
static void loops55i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4994
cubicOp77i
static void cubicOp77i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1466
cubicOp31u
static void cubicOp31u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:652
testOp2d
static void testOp2d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:465
circlesOp3
static void circlesOp3(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4017
circlesOp1
static void circlesOp1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3911
cubicOp19i
static void cubicOp19i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:320
cubics9d
static void cubics9d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4341
cubicOp114asQuad
static void cubicOp114asQuad(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3318
cubicOp36u
static void cubicOp36u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:730
loops44i
static void loops44i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4849
rectOp3x
static void rectOp3x(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2066
cubicOp75d
static void cubicOp75d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1438
kari1
static void kari1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3346
cubicOp104
static void cubicOp104(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3114
skpcarrefour_ro62
static void skpcarrefour_ro62(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2882
cubics41d
static void cubics41d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5097
cubicOp59d
static void cubicOp59d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1029
quadRect4
static void quadRect4(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4233
loopEdge2
static void loopEdge2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2190
cubicOp34d
static void cubicOp34d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:704
loops27i
static void loops27i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4601
loops59iasQuads
static void loops59iasQuads(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5078
loops26i
static void loops26i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4588
testUnion1
static void testUnion1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:405
loops23i
static void loops23i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4549
xOp3i
static void xOp3i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3255
cubicOp91u
static void cubicOp91u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2278
cubics45u
static void cubics45u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5162
skpClip1
static void skpClip1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1580
loops52i
static void loops52i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4955
skpinsomnia_gr72
static void skpinsomnia_gr72(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2978
cubicOp132
static void cubicOp132(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4048
loops49i
static void loops49i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4916
cubicOp135
static void cubicOp135(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4098
loops5i
static void loops5i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4276
cubicOp92i
static void cubicOp92i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2504
cubicOp7d
static void cubicOp7d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:117
cubicOp87u
static void cubicOp87u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2225
issue2504
static void issue2504(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3365
cubicOp9d
static void cubicOp9d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:143
testOp7d
static void testOp7d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:531
cubicOp48d
static void cubicOp48d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:886
cubics44d
static void cubics44d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5149
cubicOp123
static void cubicOp123(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3740
fuzzX_392
static void fuzzX_392(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5217
issue1417
static void issue1417(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1863
cubicOp130a
static void cubicOp130a(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3883
cubics137
static void cubics137(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4137
skpabcspark_ca103
static void skpabcspark_ca103(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2312
cubics15d
static void cubics15d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4419
cubicOp102
static void cubicOp102(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3088
cubicOp63d
static void cubicOp63d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1081
skpbambootheme_com12
static void skpbambootheme_com12(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2692
cubicOp95u
static void cubicOp95u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2997
testOp6d
static void testOp6d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:520
loops46i
static void loops46i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4875
loops57i
static void loops57i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5020
cubicOp55d
static void cubicOp55d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:977
cubicOp69d
static void cubicOp69d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1170
loops22i
static void loops22i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4536
cubicOp16d
static void cubicOp16d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:281
cubicOp6d
static void cubicOp6d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:104
cubicOp128
static void cubicOp128(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3827
rectOp2i
static void rectOp2i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2055
cubicOp111
static void cubicOp111(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3203
cubicOp97x
static void cubicOp97x(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3023
cubicOp71d
static void cubicOp71d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1382
cubicOp62d
static void cubicOp62d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1068
loops_i2
static void loops_i2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5297
cubicOp54d
static void cubicOp54d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:964
rects5
static void rects5(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3984
loops40iAsQuads
static void loops40iAsQuads(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4833
cubicOp28u
static void cubicOp28u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:600
skpbyte_com1
static void skpbyte_com1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1716
skp1
static void skp1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1225
skpadoption_org196
static void skpadoption_org196(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2567
cubicOp30d
static void cubicOp30d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:626
loops_i6
static void loops_i6(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5349
cubicOp51d
static void cubicOp51d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:925
skpadbox_lt8
static void skpadbox_lt8(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2386
cubicOp25i
static void cubicOp25i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:561
cubicOp118
static void cubicOp118(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3588
cubics138
static void cubics138(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4150
cubicOp11d
static void cubicOp11d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:216
cubicOp64d
static void cubicOp64d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1094
loop8
static void loop8(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3995
cubicOp136a
static void cubicOp136a(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4124
cubics16i
static void cubics16i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4432
loop6
static void loop6(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3764
cubicOp57d
static void cubicOp57d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1003
loops59i
static void loops59i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5065
cubicOp72i
static void cubicOp72i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1395
cubicOp110
static void cubicOp110(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3192
quadRect5
static void quadRect5(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4243
cubicOp40d
static void cubicOp40d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:782
loops_i5
static void loops_i5(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5336
cubicOp42d
static void cubicOp42d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:808
bug5240
static void bug5240(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5421
loops54i
static void loops54i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4981
skp4
static void skp4(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1311
xOp2i
static void xOp2i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3242
cubicOp41i
static void cubicOp41i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:795
cubics6d
static void cubics6d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4302
cubicOp105
static void cubicOp105(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3127
cubicOp76u
static void cubicOp76u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1453
loops_i1
static void loops_i1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5284
quadRect2
static void quadRect2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4213
skpbestred_ru37
static void skpbestred_ru37(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2831
cubicOp84d
static void cubicOp84d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1567
cubicOp3d
static void cubicOp3d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:78
quadOp9d
static void quadOp9d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:156
skp5
static void skp5(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1343
cubicOp21d
static void cubicOp21d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:346
testOp1d
static void testOp1d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:454
cubics14d
static void cubics14d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4406
loop12
static void loop12(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4061
skpkkiste_to98
static void skpkkiste_to98(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1835
fuzz38
static void fuzz38(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5175
cubicOp85d
static void cubicOp85d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1821
findFirst1
static void findFirst1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3268
skpancestry_com1
static void skpancestry_com1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1666
cubicOp129
static void cubicOp129(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3840
cubics11i
static void cubics11i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4367
cubicOp99
static void cubicOp99(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3049
grshapearcs1
static void grshapearcs1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5819
cubicOp1i
static void cubicOp1i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:190
loops37i
static void loops37i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4781
loop2
static void loop2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3643
testIntersect2
static void testIntersect2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:426
cubics13d
static void cubics13d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4393
cubicOp139
static void cubicOp139(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4164
skpcarpetplanet_ru22
static void skpcarpetplanet_ru22(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2735
op_2
static void op_2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:8985
loops53i
static void loops53i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4968
circlesOp2
static void circlesOp2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3920
halbug
static void halbug(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5743
issue2540
static void issue2540(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3384
xOp1i
static void xOp1i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3229
cubicOp106
static void cubicOp106(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3140
cubicOp120
static void cubicOp120(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3700
skpcaffelavazzait_com_ua21
static void skpcaffelavazzait_com_ua21(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2905
loop17
static void loop17(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5401
cubicOp125
static void cubicOp125(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3788
loops56i
static void loops56i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5007
skpcamcorder_kz21
static void skpcamcorder_kz21(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2932
cubics8d
static void cubics8d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4328
skpagentxsites_com55
static void skpagentxsites_com55(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2638
testOp1u
static void testOp1u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:487
cubicOp49d
static void cubicOp49d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:899
cubicOp45d
static void cubicOp45d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:847
cubicOp90u
static void cubicOp90u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2265
loops20i
static void loops20i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4510
cubicOp70d
static void cubicOp70d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1369
cubics19d
static void cubics19d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4471
cubicOp20d
static void cubicOp20d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:333
loop4
static void loop4(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3665
loops33i
static void loops33i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4679
testOp3d
static void testOp3d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:476
cubics17d
static void cubics17d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4445
skpacesoftech_com47
static void skpacesoftech_com47(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2335
cubicOp50d
static void cubicOp50d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:912
issue1418b
static void issue1418b(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2014
loop3
static void loop3(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3654
loop9
static void loop9(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4006
testUnion2
static void testUnion2(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:433
cubicOp68u
static void cubicOp68u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1159
cubicOp79u
static void cubicOp79u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1496
cubicOp65d
static void cubicOp65d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1107
loops34i
static void loops34i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4742
cubicOp117
static void cubicOp117(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3575
cubicOp13d
static void cubicOp13d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:242
testOp2u
static void testOp2u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:542
skpahrefs_com88
static void skpahrefs_com88(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1765
loops33iAsQuads
static void loops33iAsQuads(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4726
cubicOp119
static void cubicOp119(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3687
loops24i
static void loops24i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4562
skpbingoentertainment_net189
static void skpbingoentertainment_net189(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2858
skpaaalgarve_org53
static void skpaaalgarve_org53(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2291
cubics20d
static void cubics20d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4497
cubicOp56d
static void cubicOp56d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:990
cubicOp116
static void cubicOp116(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3562
rRect1
static void rRect1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1189
cubicOp82i
static void cubicOp82i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1537
skpcavablar_net563
static void skpcavablar_net563(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2959
cubicOp5d
static void cubicOp5d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:91
cubicOp66u
static void cubicOp66u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1133
loops31i
static void loops31i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4653
cubicOp157
static void cubicOp157(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4484
testIntersect1
static void testIntersect1(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:398
cubicOp12d
static void cubicOp12d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:229
cubicOp31x
static void cubicOp31x(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:665
loops40i
static void loops40i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4820
testOp4d
static void testOp4d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:498
cubicOp121
static void cubicOp121(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3713
cubicOp89u
static void cubicOp89u(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2252
cubics12d
static void cubics12d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4380
skpadspert_de11
static void skpadspert_de11(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2453
rRect1x
static void rRect1x(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3929
skpbenzoteh_ru152
static void skpbenzoteh_ru152(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2804
cubicOp22d
static void cubicOp22d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:359
loop5
static void loop5(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3753
cubicOp61d
static void cubicOp61d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1055
loops30i
static void loops30i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4640
loops21i
static void loops21i(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4523
cubicOp98x
static void cubicOp98x(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3036
cubicOp44d
static void cubicOp44d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:834
skpbangalorenest_com4
static void skpbangalorenest_com4(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:2785
cubicOp100
static void cubicOp100(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3062
filinmangust14
static void filinmangust14(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5774
cubics_o
static void cubics_o(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5375
loops58iAsQuads
static void loops58iAsQuads(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5046
cubicOp158
static void cubicOp158(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:5388
cubicOp37d
static void cubicOp37d(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:743
issue2808
static void issue2808(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3500
cubicOp141
static void cubicOp141(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:4190
skpahrefs_com29
static void skpahrefs_com29(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:1791
cubicOp127
static void cubicOp127(skiatest::Reporter *reporter, const char *filename)
Definition PathOpsOpTest.cpp:3814
Generated on Fri Apr 26 2024 06:18:59 for Flutter Engine by doxygen 1.9.8