diff --git a/storm/Big.cpp b/storm/Big.cpp
index 0c31ad2..2930de2 100644
--- a/storm/Big.cpp
+++ b/storm/Big.cpp
@@ -40,6 +40,15 @@ void SBigFromUnsigned(BigData* num, uint32_t val) {
     FromUnsigned(num->Primary(), val);
 }
 
+void SBigMod(BigData* a, BigData* b, BigData* c) {
+    uint32_t allocCount = 0;
+    auto& scratch = a->Stack().Alloc(&allocCount);
+
+    Div(scratch, a->Primary(), b->Primary(), c->Primary(), a->Stack());
+
+    a->Stack().Free(allocCount);
+}
+
 void SBigNew(BigData** num) {
     auto m = SMemAlloc(sizeof(BigData), __FILE__, __LINE__, 0x0);
     *num = new (m) BigData();
diff --git a/storm/Big.hpp b/storm/Big.hpp
index 514ae34..2346dfd 100644
--- a/storm/Big.hpp
+++ b/storm/Big.hpp
@@ -16,6 +16,8 @@ void SBigFromBinary(BigData* num, const void* data, uint32_t bytes);
 
 void SBigFromUnsigned(BigData* num, uint32_t val);
 
+void SBigMod(BigData* a, BigData* b, BigData* c);
+
 void SBigMul(BigData* a, BigData* b, BigData* c);
 
 void SBigNew(BigData** num);
diff --git a/test/Big.cpp b/test/Big.cpp
index 539622f..e1f5807 100644
--- a/test/Big.cpp
+++ b/test/Big.cpp
@@ -882,6 +882,98 @@ TEST_CASE("SBigFromUnsigned", "[big]") {
     }
 }
 
+TEST_CASE("SBigMod", "[big]") {
+    SECTION("mods 7 by 4") {
+        BigData* a;
+        SBigNew(&a);
+
+        BigData* b;
+        SBigNew(&b);
+        SBigFromUnsigned(b, 7);
+
+        BigData* c;
+        SBigNew(&c);
+        SBigFromUnsigned(c, 4);
+
+        SBigMod(a, b, c);
+
+        a->Primary().Trim();
+
+        CHECK(a->Primary().Count() == 1);
+        CHECK(a->Primary()[0] == 3);
+
+        SBigDel(a);
+        SBigDel(b);
+        SBigDel(c);
+    }
+
+    SECTION("mods 7 by 4 then mods 9 by 5") {
+        BigData* a;
+        SBigNew(&a);
+
+        BigData* b1;
+        SBigNew(&b1);
+        SBigFromUnsigned(b1, 7);
+
+        BigData* c1;
+        SBigNew(&c1);
+        SBigFromUnsigned(c1, 4);
+
+        BigData* b2;
+        SBigNew(&b2);
+        SBigFromUnsigned(b2, 9);
+
+        BigData* c2;
+        SBigNew(&c2);
+        SBigFromUnsigned(c2, 5);
+
+        SBigMod(a, b1, c1);
+
+        a->Primary().Trim();
+
+        CHECK(a->Primary().Count() == 1);
+        CHECK(a->Primary()[0] == 3);
+
+        SBigMod(a, b2, c2);
+
+        a->Primary().Trim();
+
+        CHECK(a->Primary().Count() == 1);
+        CHECK(a->Primary()[0] == 4);
+
+        SBigDel(a);
+        SBigDel(b1);
+        SBigDel(c1);
+        SBigDel(b2);
+        SBigDel(c2);
+    }
+
+    SECTION("mods 0x9999444488885555 by 0xFFFFFFFF") {
+        BigData* a;
+        SBigNew(&a);
+
+        BigData* b;
+        SBigNew(&b);
+        uint64_t b_ = 0x9999444488885555;
+        SBigFromBinary(b, reinterpret_cast<uint8_t*>(&b_), sizeof(b_));
+
+        BigData* c;
+        SBigNew(&c);
+        SBigFromUnsigned(c, 0xFFFFFFFF);
+
+        SBigMod(a, b, c);
+
+        a->Primary().Trim();
+
+        CHECK(a->Primary().Count() == 1);
+        CHECK(a->Primary()[0] == 0x2221999A);
+
+        SBigDel(a);
+        SBigDel(b);
+        SBigDel(c);
+    }
+}
+
 TEST_CASE("SBigMul", "[big]") {
     SECTION("multiplies 0 and 1") {
         BigData* a;