diff --git a/src/gpu/ops/GrTextureOp.cpp b/src/gpu/ops/GrTextureOp.cpp
index a4b79ac..f2efb95 100644
--- a/src/gpu/ops/GrTextureOp.cpp
+++ b/src/gpu/ops/GrTextureOp.cpp
@@ -285,6 +285,49 @@
     typedef GrGeometryProcessor INHERITED;
 };
 
+// This computes the four edge equations for a quad, then outsets them and computes a new quad
+// as the intersection points of the outset edges. 'x' and 'y' contain the original points as input
+// and the outset points as output. 'a', 'b', and 'c' are the edge equation coefficients on output.
+static void compute_quad_edges_and_outset_vertices(Sk4f* x, Sk4f* y, Sk4f* a, Sk4f* b, Sk4f* c) {
+    static constexpr auto fma = SkNx_fma<4, float>;
+    // These rotate the points/edge values either clockwise or counterclockwise assuming tri strip
+    // order.
+    auto nextCW  = [](const Sk4f& v) { return SkNx_shuffle<2, 0, 3, 1>(v); };
+    auto nextCCW = [](const Sk4f& v) { return SkNx_shuffle<1, 3, 0, 2>(v); };
+
+    auto xnext = nextCCW(*x);
+    auto ynext = nextCCW(*y);
+    *a = ynext - *y;
+    *b = *x - xnext;
+    *c = fma(xnext, *y,  -ynext * *x);
+    Sk4f invNormLengths = (*a * *a + *b * *b).rsqrt();
+    // Make sure the edge equations have their normals facing into the quad in device space.
+    auto test = fma(*a, nextCW(*x), fma(*b, nextCW(*y), *c));
+    if ((test < Sk4f(0)).anyTrue()) {
+        invNormLengths = -invNormLengths;
+    }
+    *a *= invNormLengths;
+    *b *= invNormLengths;
+    *c *= invNormLengths;
+
+    // Here is the outset. This makes our edge equations compute coverage without requiring a
+    // half pixel offset and is also used to compute the bloated quad that will cover all
+    // pixels.
+    *c += Sk4f(0.5f);
+
+    // Reverse the process to compute the points of the bloated quad from the edge equations.
+    // This time the inputs don't have 1s as their third coord and we want to homogenize rather
+    // than normalize.
+    auto anext = nextCW(*a);
+    auto bnext = nextCW(*b);
+    auto cnext = nextCW(*c);
+    *x = fma(bnext, *c, -*b * cnext);
+    *y = fma(*a, cnext, -anext * *c);
+    auto ic = (fma(anext, *b, -bnext * *a)).invert();
+    *x *= ic;
+    *y *= ic;
+}
+
 namespace {
 // This is a class soley so it can be partially specialized (functions cannot be).
 template<GrAA, typename Vertex> class VertexAAHandler;
@@ -308,59 +351,18 @@
 public:
     static void AssignPositionsAndTexCoords(Vertex* vertices, const GrQuad& quad,
                                             const SkRect& texRect) {
-        // We compute the four edge equations for quad, then outset them and compute a new quad
-        // as the intersection points of the outset edges.
-
-        // GrQuad is in tristip order but we want the points to be in a fan order, so swap 2 and 3.
-        Sk4f xs = SkNx_shuffle<0, 1, 3, 2>(quad.x4f());
-        Sk4f ys = SkNx_shuffle<0, 1, 3, 2>(quad.y4f());
-        Sk4f xsrot = SkNx_shuffle<1, 2, 3, 0>(xs);
-        Sk4f ysrot = SkNx_shuffle<1, 2, 3, 0>(ys);
-        Sk4f normXs = ysrot - ys;
-        Sk4f normYs = xs - xsrot;
-        Sk4f ds = xsrot * ys - ysrot * xs;
-        Sk4f invNormLengths = (normXs * normXs + normYs * normYs).rsqrt();
-        float test = normXs[0] * xs[2] + normYs[0] * ys[2] + ds[0];
-        // Make sure the edge equations have their normals facing into the quad in device space
-        if (test < 0) {
-            invNormLengths = -invNormLengths;
-        }
-        normXs *= invNormLengths;
-        normYs *= invNormLengths;
-        ds *= invNormLengths;
-
-        // Here is the bloat. This makes our edge equations compute coverage without requiring a
-        // half pixel offset and is also used to compute the bloated quad that will cover all
-        // pixels.
-        ds += Sk4f(0.5f);
+        auto x = quad.x4f();
+        auto y = quad.y4f();
+        Sk4f a, b, c;
+        compute_quad_edges_and_outset_vertices(&x, &y, &a, &b, &c);
 
         for (int i = 0; i < 4; ++i) {
+            vertices[i].fPosition = {x[i], y[i]};
             for (int j = 0; j < 4; ++j) {
-                vertices[j].fEdges[i].fX = normXs[i];
-                vertices[j].fEdges[i].fY = normYs[i];
-                vertices[j].fEdges[i].fZ = ds[i];
+                vertices[i].fEdges[j]  = {a[j], b[j], c[j]};
             }
         }
 
-        // Reverse the process to compute the points of the bloated quad from the edge equations.
-        // This time the inputs don't have 1s as their third coord and we want to homogenize rather
-        // than normalize the output since we need a GrQuad with 2D points.
-        xsrot = SkNx_shuffle<3, 0, 1, 2>(normXs);
-        ysrot = SkNx_shuffle<3, 0, 1, 2>(normYs);
-        Sk4f dsrot = SkNx_shuffle<3, 0, 1, 2>(ds);
-        xs = ysrot * ds - normYs * dsrot;
-        ys = normXs * dsrot - xsrot * ds;
-        ds = xsrot * normYs - ysrot * normXs;
-        ds = ds.invert();
-        xs *= ds;
-        ys *= ds;
-
-        // Go back to tri strip order when writing out the bloated quad to vertex positions.
-        vertices[0].fPosition = {xs[0], ys[0]};
-        vertices[1].fPosition = {xs[1], ys[1]};
-        vertices[3].fPosition = {xs[2], ys[2]};
-        vertices[2].fPosition = {xs[3], ys[3]};
-
         AssignTexCoords(vertices, quad, texRect);
     }