diff --git a/GCryptLib/include/GCrypt/Util.h b/GCryptLib/include/GCrypt/Util.h
index e900644..34f3e28 100644
--- a/GCryptLib/include/GCrypt/Util.h
+++ b/GCryptLib/include/GCrypt/Util.h
@@ -45,231 +45,47 @@ namespace Leonetienne::GCrypt {
     }
 
     //! Will pad a string to a set length with a certain character
-    inline std::string PadStringToLength(const std::string& str, const std::size_t len, const char pad, const bool padLeft = true) {
-        // Fast-reject: Already above padded length
-        if (str.length() >= len) {
-            return str;
-        }
-
-        std::stringstream ss;
-
-        // Pad left:
-        if (padLeft) {
-            for (std::size_t i = 0; i < len - str.size(); i++) {
-                ss << pad;
-            }
-            ss << str;
-        }
-        // Pad right:
-        else {
-            ss << str;
-            for (std::size_t i = 0; i < len - str.size(); i++) {
-                ss << pad;
-            }
-        }
-
-        return ss.str();
-    }
+    std::string PadStringToLength(const std::string& str, const std::size_t len, const char pad, const bool padLeft = true);
 
     //! Will convert a string to a fixed-size data block
     //! @s: The string to pad
     //! padLeft: should padding be added to the left? If not, to the right.
-    inline Block StringToBitblock(const std::string& s, bool padLeft = true) {
-        std::stringstream ss;
-
-        for (std::size_t i = 0; i < s.size(); i++) {
-            ss << std::bitset<8>(s[i]);
-        }
-
-        // Pad rest with zeores
-        return Block(PadStringToLength(ss.str(), BLOCK_SIZE, '0', padLeft));
-    }
+    Block StringToBitblock(const std::string& s, bool padLeft = true);
 
     //! Will convert a string to a flexible data block
-    inline Flexblock StringToBits(const std::string& s) {
-        std::stringstream ss;
-
-        for (std::size_t i = 0; i < s.size(); i++) {
-            ss << std::bitset<8>(s[i]);
-        }
-
-        return Flexblock(ss.str());
-    }
+    Flexblock StringToBits(const std::string& s);
 
     //! Will convert a fixed-size data block to a bytestring
-    inline std::string BitblockToBytes(const Block& bits) {
-        std::stringstream ss;
-
-        const std::string bitstring = bits.to_string();
-
-        for (std::size_t i = 0; i < BLOCK_SIZE; i += 8) {
-            ss << (char)std::bitset<8>(bitstring.substr(i, 8)).to_ulong();
-        }
-
-        return ss.str();
-    }
+    std::string BitblockToBytes(const Block& bits);
 
     //! Will convert a fixed-size data block to a string
     //! The difference to BitblockToBytes() is, that it strips excess nullbytes
-    inline std::string BitblockToString(const Block& bits) {
-        // Decode to bytes
-        std::string text = BitblockToBytes(bits);
-
-        // Dümp excess nullbytes
-        text.resize(strlen(text.data()));
-
-        return text;
-    }
+    std::string BitblockToString(const Block& bits);
 
     //! Will convert a flexible data block to a bytestring
-    inline std::string BitsToBytes(const Flexblock& bits) {
-        std::stringstream ss;
-
-        const std::string bitstring = bits;
-
-        for (std::size_t i = 0; i < bits.size(); i += 8) {
-            ss << (char)std::bitset<8>(bitstring.substr(i, 8)).to_ulong();
-        }
-
-        return ss.str();
-    }
+    std::string BitsToBytes(const Flexblock& bits);
 
     //! Will convert a flexible data block to a string
     //! The difference to BitsToBytes() is, that it strips excess nullbytes
-    inline std::string BitsToString(const Flexblock& bits) {
-        // Decode to bytes
-        std::string text = BitsToBytes(bits);
-
-        // Dümp excess nullbytes
-        text.resize(strlen(text.data()));
-
-        return text;
-    }
+    std::string BitsToString(const Flexblock& bits);
 
     //! Turns a fixed-size data block into a hex-string
-    inline std::string BitblockToHexstring(const Block& b) {
-        std::stringstream ss;
-        const std::string charset = "0123456789abcdef";
-        const std::string bstr = b.to_string();
-
-        for (std::size_t i = 0; i < bstr.size(); i += 4) {
-            ss << charset[std::bitset<4>(bstr.substr(i, 4)).to_ulong()];
-        }
-
-        return ss.str();
-    }
+    std::string BitblockToHexstring(const Block& b);
 
     //! Turns a flexible data block into a hex-string
-    inline std::string BitsToHexstring(const Flexblock& b) {
-        std::stringstream ss;
-        const std::string charset = "0123456789abcdef";
-        const std::string bstr = b;
-
-        for (std::size_t i = 0; i < bstr.size(); i += 4) {
-            ss << charset[std::bitset<4>(bstr.substr(i, 4)).to_ulong()];
-        }
-
-        return ss.str();
-    }
-
+    std::string BitsToHexstring(const Flexblock& b);
 
     //! Turns a hex string into a fixed-size data block
-    inline Block HexstringToBitblock(const std::string& hexstring) {
-        std::stringstream ss;
-
-        for (std::size_t i = 0; i < hexstring.size(); i++) {
-            const char c = hexstring[i];
-
-            // Get value
-            std::size_t value;
-            if ((c >= '0') && (c <= '9')) {
-                // Is it a number?
-                value = ((std::size_t)c - '0') + 0;
-            }
-            else if ((c >= 'a') && (c <= 'f')) {
-                // Else, it is a lowercase letter
-                value = ((std::size_t)c - 'a') + 10;
-            }
-            else {
-                throw std::logic_error("non-hex string detected in HexstringToBits()");
-            }
-
-            // Append to our bits
-            ss << std::bitset<4>(value);
-        }
-
-        return Block(ss.str());
-    }
+    Block HexstringToBitblock(const std::string& hexstring);
 
     //! Turns a hex string into a flexible data block
-    inline Flexblock HexstringToBits(const std::string& hexstring) {
-        std::stringstream ss;
-
-        for (std::size_t i = 0; i < hexstring.size(); i++) {
-            const char c = hexstring[i];
-
-            // Get value
-            std::size_t value;
-            if ((c >= '0') && (c <= '9')) {
-                // Is it a number?
-                value = ((std::size_t)c - '0') + 0;
-            }
-            else if ((c >= 'a') && (c <= 'f')) {
-                // Else, it is a lowercase letter
-                value = ((std::size_t)c - 'a') + 10;
-            }
-            else {
-                throw std::logic_error("non-hex string detected in HexstringToBits()");
-            }
-
-            // Append to our bits
-            ss << std::bitset<4>(value);
-        }
-
-        return ss.str();
-    }
+    Flexblock HexstringToBits(const std::string& hexstring);
 
     //! Will read a file into a flexblock
-    inline Flexblock ReadFileToBits(const std::string& filepath) {
-        // Read file
-        std::ifstream ifs(filepath, std::ios::binary);
-
-        if (!ifs.good()) {
-            throw std::runtime_error("Unable to open ifilestream!");
-        }
-
-        std::stringstream ss;
-        std::copy(
-            std::istreambuf_iterator<char>(ifs),
-            std::istreambuf_iterator<char>(),
-            std::ostreambuf_iterator<char>(ss)
-        );
-
-        ifs.close();
-
-        const std::string bytes = ss.str();
-
-        // Convert bytes to bits
-        return StringToBits(bytes);
-    }
+    Flexblock ReadFileToBits(const std::string& filepath);
 
     //! Will save bits to a binary file
-    inline void WriteBitsToFile(const std::string& filepath, const Flexblock& bits) {
-        // Convert bits to bytes
-        const std::string bytes = BitsToBytes(bits);
-
-        // Write bits to file
-        std::ofstream ofs(filepath, std::ios::binary);
-
-        if (!ofs.good()) {
-            throw std::runtime_error("Unable to open ofilestream!");
-        }
-
-        ofs.write(bytes.data(), bytes.length());
-        ofs.close();
-
-        return;
-    }
+    void WriteBitsToFile(const std::string& filepath, const Flexblock& bits);
 }
 
 #endif
diff --git a/GCryptLib/src/Util.cpp b/GCryptLib/src/Util.cpp
index 96e3293..21a98e0 100644
--- a/GCryptLib/src/Util.cpp
+++ b/GCryptLib/src/Util.cpp
@@ -2,5 +2,214 @@
 #include "GCrypt/GHash.h"
 
 namespace Leonetienne::GCrypt {
+
+  std::string PadStringToLength(const std::string& str, const std::size_t len, const char pad, const bool padLeft) {
+    // Fast-reject: Already above padded length
+    if (str.length() >= len) {
+      return str;
+    }
+
+    std::stringstream ss;
+
+    // Pad left:
+    if (padLeft) {
+      for (std::size_t i = 0; i < len - str.size(); i++) {
+        ss << pad;
+      }
+      ss << str;
+    }
+    // Pad right:
+    else {
+      ss << str;
+      for (std::size_t i = 0; i < len - str.size(); i++) {
+        ss << pad;
+      }
+    }
+
+    return ss.str();
+  }
+
+  Block StringToBitblock(const std::string& s, bool padLeft) {
+    std::stringstream ss;
+
+    for (std::size_t i = 0; i < s.size(); i++) {
+      ss << std::bitset<8>(s[i]);
+    }
+
+    // Pad rest with zeores
+    return Block(PadStringToLength(ss.str(), BLOCK_SIZE, '0', padLeft));
+  }
+
+  Flexblock StringToBits(const std::string& s) {
+    std::stringstream ss;
+
+    for (std::size_t i = 0; i < s.size(); i++) {
+      ss << std::bitset<8>(s[i]);
+    }
+
+    return Flexblock(ss.str());
+  }
+
+  std::string BitblockToBytes(const Block& bits) {
+    std::stringstream ss;
+
+    const std::string bitstring = bits.to_string();
+
+    for (std::size_t i = 0; i < BLOCK_SIZE; i += 8) {
+      ss << (char)std::bitset<8>(bitstring.substr(i, 8)).to_ulong();
+    }
+
+    return ss.str();
+  }
+
+  std::string BitblockToString(const Block& bits) {
+    // Decode to bytes
+    std::string text = BitblockToBytes(bits);
+
+    // Dümp excess nullbytes
+    text.resize(strlen(text.data()));
+
+    return text;
+  }
+
+  std::string BitsToBytes(const Flexblock& bits) {
+    std::stringstream ss;
+
+    const std::string bitstring = bits;
+
+    for (std::size_t i = 0; i < bits.size(); i += 8) {
+      ss << (char)std::bitset<8>(bitstring.substr(i, 8)).to_ulong();
+    }
+
+    return ss.str();
+  }
+
+  std::string BitsToString(const Flexblock& bits) {
+    // Decode to bytes
+    std::string text = BitsToBytes(bits);
+
+    // Dümp excess nullbytes
+    text.resize(strlen(text.data()));
+
+    return text;
+  }
+
+  std::string BitblockToHexstring(const Block& b) {
+    std::stringstream ss;
+    const std::string charset = "0123456789abcdef";
+    const std::string bstr = b.to_string();
+
+    for (std::size_t i = 0; i < bstr.size(); i += 4) {
+      ss << charset[std::bitset<4>(bstr.substr(i, 4)).to_ulong()];
+    }
+
+    return ss.str();
+  }
+
+  std::string BitsToHexstring(const Flexblock& b) {
+    std::stringstream ss;
+    const std::string charset = "0123456789abcdef";
+    const std::string bstr = b;
+
+    for (std::size_t i = 0; i < bstr.size(); i += 4) {
+      ss << charset[std::bitset<4>(bstr.substr(i, 4)).to_ulong()];
+    }
+
+    return ss.str();
+  }
+
+  Block HexstringToBitblock(const std::string& hexstring) {
+    std::stringstream ss;
+
+    for (std::size_t i = 0; i < hexstring.size(); i++) {
+      const char c = hexstring[i];
+
+      // Get value
+      std::size_t value;
+      if ((c >= '0') && (c <= '9')) {
+        // Is it a number?
+        value = ((std::size_t)c - '0') + 0;
+      }
+      else if ((c >= 'a') && (c <= 'f')) {
+        // Else, it is a lowercase letter
+        value = ((std::size_t)c - 'a') + 10;
+      }
+      else {
+        throw std::logic_error("non-hex string detected in HexstringToBits()");
+      }
+
+      // Append to our bits
+      ss << std::bitset<4>(value);
+    }
+
+    return Block(ss.str());
+  }
+
+  Flexblock HexstringToBits(const std::string& hexstring) {
+    std::stringstream ss;
+
+    for (std::size_t i = 0; i < hexstring.size(); i++) {
+      const char c = hexstring[i];
+
+      // Get value
+      std::size_t value;
+      if ((c >= '0') && (c <= '9')) {
+        // Is it a number?
+        value = ((std::size_t)c - '0') + 0;
+      }
+      else if ((c >= 'a') && (c <= 'f')) {
+        // Else, it is a lowercase letter
+        value = ((std::size_t)c - 'a') + 10;
+      }
+      else {
+        throw std::logic_error("non-hex string detected in HexstringToBits()");
+      }
+
+      // Append to our bits
+      ss << std::bitset<4>(value);
+    }
+
+    return ss.str();
+  }
+
+  Flexblock ReadFileToBits(const std::string& filepath) {
+    // Read file
+    std::ifstream ifs(filepath, std::ios::binary);
+
+    if (!ifs.good()) {
+      throw std::runtime_error("Unable to open ifilestream!");
+    }
+
+    std::stringstream ss;
+    std::copy(
+        std::istreambuf_iterator<char>(ifs),
+        std::istreambuf_iterator<char>(),
+        std::ostreambuf_iterator<char>(ss)
+        );
+
+    ifs.close();
+
+    const std::string bytes = ss.str();
+
+    // Convert bytes to bits
+    return StringToBits(bytes);
+  }
+
+  void WriteBitsToFile(const std::string& filepath, const Flexblock& bits) {
+    // Convert bits to bytes
+    const std::string bytes = BitsToBytes(bits);
+
+    // Write bits to file
+    std::ofstream ofs(filepath, std::ios::binary);
+
+    if (!ofs.good()) {
+      throw std::runtime_error("Unable to open ofilestream!");
+    }
+
+    ofs.write(bytes.data(), bytes.length());
+    ofs.close();
+
+    return;
+  }
 }