diff --git a/fuzz/FuzzCommon.cpp b/fuzz/FuzzCommon.cpp
index 51e2d18..8176d7f 100644
--- a/fuzz/FuzzCommon.cpp
+++ b/fuzz/FuzzCommon.cpp
@@ -10,17 +10,24 @@
 
 // allows some float values for path points
 void FuzzPath(Fuzz* fuzz, SkPath* path, int maxOps) {
-    if (maxOps < 2) {
-        maxOps = 2;
+    if (maxOps <= 0) {
+        return;
     }
     uint8_t fillType;
     fuzz->nextRange(&fillType, 0, (uint8_t)SkPath::kInverseEvenOdd_FillType);
     path->setFillType((SkPath::FillType)fillType);
     uint8_t numOps;
-    fuzz->nextRange(&numOps, 2, maxOps);
+    fuzz->nextRange(&numOps, 0, maxOps);
     for (uint8_t i = 0; i < numOps; ++i) {
         uint8_t op;
-        fuzz->nextRange(&op, 0, 6);
+        fuzz->nextRange(&op, 0, 32);
+        bool test;
+        SkPath p;
+        SkMatrix m;
+        SkRRect rr;
+        SkRect r;
+        SkPath::Direction dir;
+        unsigned int ui;
         SkScalar a, b, c, d, e, f;
         switch (op) {
             case 0:
@@ -29,27 +36,140 @@
                 break;
             case 1:
                 fuzz_nice_float(fuzz, &a, &b);
-                path->lineTo(a, b);
+                path->rMoveTo(a, b);
                 break;
             case 2:
+                fuzz_nice_float(fuzz, &a, &b);
+                path->lineTo(a, b);
+                break;
+            case 3:
+                fuzz_nice_float(fuzz, &a, &b);
+                path->rLineTo(a, b);
+                break;
+            case 4:
                 fuzz_nice_float(fuzz, &a, &b, &c, &d);
                 path->quadTo(a, b, c, d);
                 break;
-            case 3:
+            case 5:
+                fuzz_nice_float(fuzz, &a, &b, &c, &d);
+                path->rQuadTo(a, b, c, d);
+                break;
+            case 6:
                 fuzz_nice_float(fuzz, &a, &b, &c, &d, &e);
                 path->conicTo(a, b, c, d, e);
                 break;
-            case 4:
+            case 7:
+                fuzz_nice_float(fuzz, &a, &b, &c, &d, &e);
+                path->rConicTo(a, b, c, d, e);
+                break;
+            case 8:
                 fuzz_nice_float(fuzz, &a, &b, &c, &d, &e, &f);
                 path->cubicTo(a, b, c, d, e, f);
                 break;
-            case 5:
+            case 9:
+                fuzz_nice_float(fuzz, &a, &b, &c, &d, &e, &f);
+                path->rCubicTo(a, b, c, d, e, f);
+                break;
+            case 10:
                 fuzz_nice_float(fuzz, &a, &b, &c, &d, &e);
                 path->arcTo(a, b, c, d, e);
                 break;
-            case 6:
+            case 11:
+                fuzz_nice_float(fuzz, &a, &b);
+                fuzz->next(&r, &test);
+                path->arcTo(r, a, b, test);
+                break;
+            case 12:
                 path->close();
                 break;
+            case 13:
+                fuzz->next(&r, &dir);
+                path->addRect(r, dir);
+                break;
+            case 14:
+                fuzz->next(&r, &dir, &ui);
+                path->addRect(r, dir, ui);
+                break;
+            case 15:
+                fuzz->next(&r, &dir);
+                path->addOval(r, dir);
+                break;
+            case 16:
+                fuzz->next(&r, &dir, &ui);
+                path->addOval(r, dir, ui);
+                break;
+            case 17:
+                fuzz_nice_float(fuzz, &a, &b, &c);
+                fuzz->next(&dir);
+                path->addCircle(a, b, c, dir);
+                break;
+            case 18:
+                fuzz->next(&r);
+                fuzz_nice_float(fuzz, &a, &b);
+                path->addArc(r, a, b);
+                break;
+            case 19:
+                fuzz_nice_float(fuzz, &a, &b);
+                fuzz->next(&r, &dir);
+                path->addRoundRect(r, a, b, dir);
+                break;
+            case 20:
+                fuzz->next(&rr, &dir);
+                path->addRRect(rr, dir);
+                break;
+            case 21:
+                fuzz->next(&rr, &dir, &ui);
+                path->addRRect(rr, dir, ui);
+                break;
+            case 22: {
+                SkPath::AddPathMode mode;
+                fuzz->next(&m, &mode);
+                FuzzPath(fuzz, &p, maxOps-1);
+                path->addPath(p, m, mode);
+                break;
+            }
+            case 23: {
+                SkPath::AddPathMode mode;
+                fuzz->next(&m, &mode);
+                path->addPath(*path, m, mode);
+                break;
+            }
+            case 24:
+                FuzzPath(fuzz, &p, maxOps-1);
+                path->reverseAddPath(p);
+                break;
+            case 25:
+                path->addPath(*path);
+                break;
+            case 26:
+                path->reverseAddPath(*path);
+                break;
+            case 27:
+                fuzz_nice_float(fuzz, &a, &b);
+                path->offset(a, b, path);
+                break;
+            case 28:
+                FuzzPath(fuzz, &p, maxOps-1);
+                fuzz_nice_float(fuzz, &a, &b);
+                p.offset(a, b, path);
+                break;
+            case 29:
+                fuzz->next(&m);
+                path->transform(m, path);
+                break;
+            case 30:
+                FuzzPath(fuzz, &p, maxOps-1);
+                fuzz->next(&m);
+                p.transform(m, path);
+                break;
+            case 31:
+                fuzz_nice_float(fuzz, &a, &b);
+                path->setLastPt(a, b);
+                break;
+            case 32:
+                path->shrinkToFit();
+                break;
+
             default:
                 SkASSERT(false);
                 break;