diff --git a/src/libsodium/Makefile.am b/src/libsodium/Makefile.am
index 22f9af74..b8368340 100644
--- a/src/libsodium/Makefile.am
+++ b/src/libsodium/Makefile.am
@@ -169,7 +169,6 @@ libsodium_la_SOURCES += \
 	crypto_stream/aes128ctr/nacl/int128.h \
 	crypto_stream/aes128ctr/nacl/int128_aes128ctr.c \
 	crypto_stream/aes128ctr/nacl/stream_aes128ctr_nacl.c \
-	crypto_stream/aes128ctr/nacl/types.h \
 	crypto_stream/aes128ctr/nacl/xor_afternm_aes128ctr.c \
 	crypto_stream/aes128ctr/stream_aes128ctr.c \
 	crypto_stream/salsa2012/ref/stream_salsa2012_ref.c \
diff --git a/src/libsodium/crypto_stream/aes128ctr/nacl/afternm_aes128ctr.c b/src/libsodium/crypto_stream/aes128ctr/nacl/afternm_aes128ctr.c
index 87d061b4..16910039 100644
--- a/src/libsodium/crypto_stream/aes128ctr/nacl/afternm_aes128ctr.c
+++ b/src/libsodium/crypto_stream/aes128ctr/nacl/afternm_aes128ctr.c
@@ -13,31 +13,29 @@ crypto_stream_aes128ctr_afternm(unsigned char *out, unsigned long long len,
                                 const unsigned char *nonce,
                                 const unsigned char *c)
 {
-    aes_uint128_t xmm0;
-    aes_uint128_t xmm1;
-    aes_uint128_t xmm2;
-    aes_uint128_t xmm3;
-    aes_uint128_t xmm4;
-    aes_uint128_t xmm5;
-    aes_uint128_t xmm6;
-    aes_uint128_t xmm7;
-    aes_uint128_t xmm8;
-    aes_uint128_t xmm9;
-    aes_uint128_t xmm10;
-    aes_uint128_t xmm11;
-    aes_uint128_t xmm12;
-    aes_uint128_t xmm13;
-    aes_uint128_t xmm14;
-    aes_uint128_t xmm15;
-
+    aes_uint128_t      xmm0;
+    aes_uint128_t      xmm1;
+    aes_uint128_t      xmm2;
+    aes_uint128_t      xmm3;
+    aes_uint128_t      xmm4;
+    aes_uint128_t      xmm5;
+    aes_uint128_t      xmm6;
+    aes_uint128_t      xmm7;
+    aes_uint128_t      xmm8;
+    aes_uint128_t      xmm9;
+    aes_uint128_t      xmm10;
+    aes_uint128_t      xmm11;
+    aes_uint128_t      xmm12;
+    aes_uint128_t      xmm13;
+    aes_uint128_t      xmm14;
+    aes_uint128_t      xmm15;
     aes_uint128_t      nonce_stack;
     unsigned long long lensav;
     unsigned char      bl[128];
     unsigned char *    blp;
     unsigned char *    np;
     unsigned char      b;
-
-    uint32_t tmp;
+    uint32_t           tmp;
 
     /* Copy nonce on the stack */
     copy2(&nonce_stack, (const aes_uint128_t *) (nonce + 0));
@@ -72,43 +70,37 @@ enc_block:
     shufb(&xmm6, M0SWAP);
     shufb(&xmm7, M0SWAP);
 
-    bitslice(xmm7, xmm6, xmm5, xmm4, xmm3, xmm2, xmm1, xmm0, xmm8)
+    bitslice(xmm7, xmm6, xmm5, xmm4, xmm3, xmm2, xmm1, xmm0, xmm8);
 
-        aesround(1, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
-                 xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,
-                 c) aesround(2, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14,
-                             xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6,
-                             xmm7, c)
-            aesround(3, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8,
-                     xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,
-                     c) aesround(4, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13,
-                                 xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4,
-                                 xmm5, xmm6, xmm7, c)
-                aesround(5, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,
-                         xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,
-                         c) aesround(6, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13,
-                                     xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4,
-                                     xmm5, xmm6, xmm7, c)
-                    aesround(7, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,
-                             xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14,
-                             xmm15, c)
-                        aesround(8, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13,
-                                 xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4,
-                                 xmm5, xmm6, xmm7, c)
-                            aesround(9, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5,
-                                     xmm6, xmm7, xmm8, xmm9, xmm10, xmm11,
-                                     xmm12, xmm13, xmm14, xmm15, c)
-                                lastround(xmm8, xmm9, xmm10, xmm11, xmm12,
-                                          xmm13, xmm14, xmm15, xmm0, xmm1, xmm2,
-                                          xmm3, xmm4, xmm5, xmm6, xmm7, c)
+    aesround(1, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    aesround(2, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0,
+             xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
+    aesround(3, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    aesround(4, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0,
+             xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
+    aesround(5, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    aesround(6, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0,
+             xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
+    aesround(7, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    aesround(8, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0,
+             xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
+    aesround(9, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    lastround(xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1,
+              xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
 
-                                    bitslice(xmm13, xmm10, xmm15, xmm11, xmm14,
-                                             xmm12, xmm9, xmm8, xmm0)
+    bitslice(xmm13, xmm10, xmm15, xmm11, xmm14, xmm12, xmm9, xmm8, xmm0);
 
-                                        if (len < 128) goto partial;
-    if (len == 128)
+    if (len < 128) {
+        goto partial;
+    }
+    if (len == 128) {
         goto full;
-
+    }
     tmp = LOAD32_BE(np + 12);
     tmp += 8;
     STORE32_BE(np + 12, tmp);
@@ -136,7 +128,8 @@ partial:
     tmp += len;
     STORE32_BE(np + 12, tmp);
 
-    blp                            = bl;
+    blp = bl;
+
     *(aes_uint128_t *) (blp + 0)   = xmm8;
     *(aes_uint128_t *) (blp + 16)  = xmm9;
     *(aes_uint128_t *) (blp + 32)  = xmm12;
@@ -148,10 +141,11 @@ partial:
 
 bytes:
 
-    if (lensav == 0)
+    if (lensav == 0) {
         goto end;
+    }
+    b = blp[0]; /* clang false positive */
 
-    b                            = blp[0]; /* clang false positive */
     *(unsigned char *) (out + 0) = b;
 
     blp += 1;
diff --git a/src/libsodium/crypto_stream/aes128ctr/nacl/beforenm_aes128ctr.c b/src/libsodium/crypto_stream/aes128ctr/nacl/beforenm_aes128ctr.c
index 577b250a..9fa5bbd9 100644
--- a/src/libsodium/crypto_stream/aes128ctr/nacl/beforenm_aes128ctr.c
+++ b/src/libsodium/crypto_stream/aes128ctr/nacl/beforenm_aes128ctr.c
@@ -29,45 +29,38 @@ crypto_stream_aes128ctr_beforenm(unsigned char *c, const unsigned char *k)
     aes_uint128_t xmm15;
     aes_uint128_t t;
 
-    bitslicekey0(k, c)
+    bitslicekey0(k, c);
 
-        keyexpbs1(xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
-                  xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,
-                  c) keyexpbs(xmm0, xmm1, xmm4, xmm6, xmm3, xmm7, xmm2, xmm5,
-                              xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14,
-                              xmm15, xor_rcon(&xmm1);
-                              , 2, c)
-            keyexpbs(xmm0, xmm1, xmm3, xmm2, xmm6, xmm5, xmm4, xmm7, xmm8, xmm9,
-                     xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xor_rcon(&xmm6);
-                     , 3, c) keyexpbs(xmm0, xmm1, xmm6, xmm4, xmm2, xmm7, xmm3,
-                                      xmm5, xmm8, xmm9, xmm10, xmm11, xmm12,
-                                      xmm13, xmm14, xmm15, xor_rcon(&xmm3);
-                                      , 4, c)
+    keyexpbs1(xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10,
+              xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    keyexpbs(xmm0, xmm1, xmm4, xmm6, xmm3, xmm7, xmm2, xmm5, xmm8, xmm9, xmm10,
+             xmm11, xmm12, xmm13, xmm14, xmm15, xor_rcon(&xmm1);
+             , 2, c);
+    keyexpbs(xmm0, xmm1, xmm3, xmm2, xmm6, xmm5, xmm4, xmm7, xmm8, xmm9, xmm10,
+             xmm11, xmm12, xmm13, xmm14, xmm15, xor_rcon(&xmm6);
+             , 3, c);
+    keyexpbs(xmm0, xmm1, xmm6, xmm4, xmm2, xmm7, xmm3, xmm5, xmm8, xmm9, xmm10,
+             xmm11, xmm12, xmm13, xmm14, xmm15, xor_rcon(&xmm3);
+             , 4, c);
 
-                keyexpbs(
-                    xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
-                    xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xor_rcon(&xmm3);
-                    , 5, c) keyexpbs(xmm0, xmm1, xmm4, xmm6, xmm3, xmm7, xmm2,
-                                     xmm5, xmm8, xmm9, xmm10, xmm11, xmm12,
-                                     xmm13, xmm14, xmm15, xor_rcon(&xmm5);
-                                     , 6, c)
-                    keyexpbs(xmm0, xmm1, xmm3, xmm2, xmm6, xmm5, xmm4, xmm7,
-                             xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14,
-                             xmm15, xor_rcon(&xmm3);
-                             , 7, c)
-                        keyexpbs(xmm0, xmm1, xmm6, xmm4, xmm2, xmm7, xmm3, xmm5,
-                                 xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14,
-                                 xmm15, xor_rcon(&xmm7);
-                                 , 8, c)
+    keyexpbs(xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10,
+             xmm11, xmm12, xmm13, xmm14, xmm15, xor_rcon(&xmm3);
+             , 5, c);
+    keyexpbs(xmm0, xmm1, xmm4, xmm6, xmm3, xmm7, xmm2, xmm5, xmm8, xmm9, xmm10,
+             xmm11, xmm12, xmm13, xmm14, xmm15, xor_rcon(&xmm5);
+             , 6, c);
+    keyexpbs(xmm0, xmm1, xmm3, xmm2, xmm6, xmm5, xmm4, xmm7, xmm8, xmm9, xmm10,
+             xmm11, xmm12, xmm13, xmm14, xmm15, xor_rcon(&xmm3);
+             , 7, c);
+    keyexpbs(xmm0, xmm1, xmm6, xmm4, xmm2, xmm7, xmm3, xmm5, xmm8, xmm9, xmm10,
+             xmm11, xmm12, xmm13, xmm14, xmm15, xor_rcon(&xmm7);
+             , 8, c);
 
-                            keyexpbs(xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6,
-                                     xmm7, xmm8, xmm9, xmm10, xmm11, xmm12,
-                                     xmm13, xmm14, xmm15, xor_rcon(&xmm0);
-                                     xor_rcon(&xmm1); xor_rcon(&xmm6);
-                                     xor_rcon(&xmm3);, 9, c)
-                                keyexpbs10(xmm0, xmm1, xmm4, xmm6, xmm3, xmm7,
-                                           xmm2, xmm5, xmm8, xmm9, xmm10, xmm11,
-                                           xmm12, xmm13, xmm14, xmm15, c)
+    keyexpbs(xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10,
+             xmm11, xmm12, xmm13, xmm14, xmm15, xor_rcon(&xmm0);
+             xor_rcon(&xmm1); xor_rcon(&xmm6); xor_rcon(&xmm3);, 9, c);
+    keyexpbs10(xmm0, xmm1, xmm4, xmm6, xmm3, xmm7, xmm2, xmm5, xmm8, xmm9,
+               xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
 
-                                    return 0;
+    return 0;
 }
diff --git a/src/libsodium/crypto_stream/aes128ctr/nacl/common.h b/src/libsodium/crypto_stream/aes128ctr/nacl/common.h
index 30c522de..c1e6394b 100644
--- a/src/libsodium/crypto_stream/aes128ctr/nacl/common.h
+++ b/src/libsodium/crypto_stream/aes128ctr/nacl/common.h
@@ -2,11 +2,10 @@
  Käsper
  Date: 2009-03-19
  Public domain */
-#ifndef COMMON_H
-#define COMMON_H
+#ifndef aes128ctr_nacl_common_H
+#define aes128ctr_nacl_common_H
 
 #include "private/common.h"
-#include "types.h"
 
 /* Macros required only for key expansion */
 
@@ -20,9 +19,9 @@
     rotbyte(&b5);                                                             \
     rotbyte(&b6);                                                             \
     rotbyte(&b7);                                                             \
-    ;                                                                         \
+                                                                              \
     sbox(b0, b1, b2, b3, b4, b5, b6, b7, t0, t1, t2, t3, t4, t5, t6, t7);     \
-    ;                                                                         \
+                                                                              \
     xor_rcon(&b0);                                                            \
     shufb(&b0, EXPB0);                                                        \
     shufb(&b1, EXPB0);                                                        \
@@ -33,7 +32,7 @@
     shufb(&b2, EXPB0);                                                        \
     shufb(&b5, EXPB0);                                                        \
     shufb(&b0, EXPB0);                                                        \
-    ;                                                                         \
+                                                                              \
     t0 = *(aes_uint128_t *) (bskey + 0);                                      \
     t1 = *(aes_uint128_t *) (bskey + 16);                                     \
     t2 = *(aes_uint128_t *) (bskey + 32);                                     \
@@ -42,7 +41,7 @@
     t5 = *(aes_uint128_t *) (bskey + 80);                                     \
     t6 = *(aes_uint128_t *) (bskey + 96);                                     \
     t7 = *(aes_uint128_t *) (bskey + 112);                                    \
-    ;                                                                         \
+                                                                              \
     xor2(&b0, &t0);                                                           \
     xor2(&b1, &t1);                                                           \
     xor2(&b4, &t2);                                                           \
@@ -51,7 +50,7 @@
     xor2(&b7, &t5);                                                           \
     xor2(&b2, &t6);                                                           \
     xor2(&b5, &t7);                                                           \
-    ;                                                                         \
+                                                                              \
     rshift32_littleendian(&t0, 8);                                            \
     rshift32_littleendian(&t1, 8);                                            \
     rshift32_littleendian(&t2, 8);                                            \
@@ -60,7 +59,7 @@
     rshift32_littleendian(&t5, 8);                                            \
     rshift32_littleendian(&t6, 8);                                            \
     rshift32_littleendian(&t7, 8);                                            \
-    ;                                                                         \
+                                                                              \
     xor2(&b0, &t0);                                                           \
     xor2(&b1, &t1);                                                           \
     xor2(&b4, &t2);                                                           \
@@ -69,7 +68,7 @@
     xor2(&b7, &t5);                                                           \
     xor2(&b2, &t6);                                                           \
     xor2(&b5, &t7);                                                           \
-    ;                                                                         \
+                                                                              \
     rshift32_littleendian(&t0, 8);                                            \
     rshift32_littleendian(&t1, 8);                                            \
     rshift32_littleendian(&t2, 8);                                            \
@@ -78,7 +77,7 @@
     rshift32_littleendian(&t5, 8);                                            \
     rshift32_littleendian(&t6, 8);                                            \
     rshift32_littleendian(&t7, 8);                                            \
-    ;                                                                         \
+                                                                              \
     xor2(&b0, &t0);                                                           \
     xor2(&b1, &t1);                                                           \
     xor2(&b4, &t2);                                                           \
@@ -87,7 +86,7 @@
     xor2(&b7, &t5);                                                           \
     xor2(&b2, &t6);                                                           \
     xor2(&b5, &t7);                                                           \
-    ;                                                                         \
+                                                                              \
     rshift32_littleendian(&t0, 8);                                            \
     rshift32_littleendian(&t1, 8);                                            \
     rshift32_littleendian(&t2, 8);                                            \
@@ -96,7 +95,7 @@
     rshift32_littleendian(&t5, 8);                                            \
     rshift32_littleendian(&t6, 8);                                            \
     rshift32_littleendian(&t7, 8);                                            \
-    ;                                                                         \
+                                                                              \
     xor2(&b0, &t0);                                                           \
     xor2(&b1, &t1);                                                           \
     xor2(&b4, &t2);                                                           \
@@ -105,7 +104,7 @@
     xor2(&b7, &t5);                                                           \
     xor2(&b2, &t6);                                                           \
     xor2(&b5, &t7);                                                           \
-    ;                                                                         \
+                                                                              \
     *(aes_uint128_t *) (bskey + 128) = b0;                                    \
     *(aes_uint128_t *) (bskey + 144) = b1;                                    \
     *(aes_uint128_t *) (bskey + 160) = b4;                                    \
@@ -113,11 +112,10 @@
     *(aes_uint128_t *) (bskey + 192) = b3;                                    \
     *(aes_uint128_t *) (bskey + 208) = b7;                                    \
     *(aes_uint128_t *) (bskey + 224) = b2;                                    \
-    *(aes_uint128_t *) (bskey + 240) = b5;
+    *(aes_uint128_t *) (bskey + 240) = b5
 
 #define keyexpbs10(b0, b1, b2, b3, b4, b5, b6, b7, t0, t1, t2, t3, t4, t5, t6, \
                    t7, bskey)                                                  \
-    ;                                                                          \
     toggle(&b0);                                                               \
     toggle(&b1);                                                               \
     toggle(&b5);                                                               \
@@ -130,9 +128,9 @@
     rotbyte(&b5);                                                              \
     rotbyte(&b6);                                                              \
     rotbyte(&b7);                                                              \
-    ;                                                                          \
+                                                                               \
     sbox(b0, b1, b2, b3, b4, b5, b6, b7, t0, t1, t2, t3, t4, t5, t6, t7);      \
-    ;                                                                          \
+                                                                               \
     xor_rcon(&b1);                                                             \
     xor_rcon(&b4);                                                             \
     xor_rcon(&b3);                                                             \
@@ -145,7 +143,7 @@
     shufb(&b7, EXPB0);                                                         \
     shufb(&b2, EXPB0);                                                         \
     shufb(&b5, EXPB0);                                                         \
-    ;                                                                          \
+                                                                               \
     t0 = *(aes_uint128_t *) (bskey + 9 * 128 + 0);                             \
     t1 = *(aes_uint128_t *) (bskey + 9 * 128 + 16);                            \
     t2 = *(aes_uint128_t *) (bskey + 9 * 128 + 32);                            \
@@ -154,12 +152,12 @@
     t5 = *(aes_uint128_t *) (bskey + 9 * 128 + 80);                            \
     t6 = *(aes_uint128_t *) (bskey + 9 * 128 + 96);                            \
     t7 = *(aes_uint128_t *) (bskey + 9 * 128 + 112);                           \
-    ;                                                                          \
+                                                                               \
     toggle(&t0);                                                               \
     toggle(&t1);                                                               \
     toggle(&t5);                                                               \
     toggle(&t6);                                                               \
-    ;                                                                          \
+                                                                               \
     xor2(&b0, &t0);                                                            \
     xor2(&b1, &t1);                                                            \
     xor2(&b4, &t2);                                                            \
@@ -168,7 +166,7 @@
     xor2(&b7, &t5);                                                            \
     xor2(&b2, &t6);                                                            \
     xor2(&b5, &t7);                                                            \
-    ;                                                                          \
+                                                                               \
     rshift32_littleendian(&t0, 8);                                             \
     rshift32_littleendian(&t1, 8);                                             \
     rshift32_littleendian(&t2, 8);                                             \
@@ -177,7 +175,7 @@
     rshift32_littleendian(&t5, 8);                                             \
     rshift32_littleendian(&t6, 8);                                             \
     rshift32_littleendian(&t7, 8);                                             \
-    ;                                                                          \
+                                                                               \
     xor2(&b0, &t0);                                                            \
     xor2(&b1, &t1);                                                            \
     xor2(&b4, &t2);                                                            \
@@ -186,7 +184,7 @@
     xor2(&b7, &t5);                                                            \
     xor2(&b2, &t6);                                                            \
     xor2(&b5, &t7);                                                            \
-    ;                                                                          \
+                                                                               \
     rshift32_littleendian(&t0, 8);                                             \
     rshift32_littleendian(&t1, 8);                                             \
     rshift32_littleendian(&t2, 8);                                             \
@@ -195,7 +193,7 @@
     rshift32_littleendian(&t5, 8);                                             \
     rshift32_littleendian(&t6, 8);                                             \
     rshift32_littleendian(&t7, 8);                                             \
-    ;                                                                          \
+                                                                               \
     xor2(&b0, &t0);                                                            \
     xor2(&b1, &t1);                                                            \
     xor2(&b4, &t2);                                                            \
@@ -204,7 +202,7 @@
     xor2(&b7, &t5);                                                            \
     xor2(&b2, &t6);                                                            \
     xor2(&b5, &t7);                                                            \
-    ;                                                                          \
+                                                                               \
     rshift32_littleendian(&t0, 8);                                             \
     rshift32_littleendian(&t1, 8);                                             \
     rshift32_littleendian(&t2, 8);                                             \
@@ -213,7 +211,7 @@
     rshift32_littleendian(&t5, 8);                                             \
     rshift32_littleendian(&t6, 8);                                             \
     rshift32_littleendian(&t7, 8);                                             \
-    ;                                                                          \
+                                                                               \
     xor2(&b0, &t0);                                                            \
     xor2(&b1, &t1);                                                            \
     xor2(&b4, &t2);                                                            \
@@ -222,7 +220,7 @@
     xor2(&b7, &t5);                                                            \
     xor2(&b2, &t6);                                                            \
     xor2(&b5, &t7);                                                            \
-    ;                                                                          \
+                                                                               \
     shufb(&b0, M0);                                                            \
     shufb(&b1, M0);                                                            \
     shufb(&b2, M0);                                                            \
@@ -231,7 +229,7 @@
     shufb(&b5, M0);                                                            \
     shufb(&b6, M0);                                                            \
     shufb(&b7, M0);                                                            \
-    ;                                                                          \
+                                                                               \
     *(aes_uint128_t *) (bskey + 1280) = b0;                                    \
     *(aes_uint128_t *) (bskey + 1296) = b1;                                    \
     *(aes_uint128_t *) (bskey + 1312) = b4;                                    \
@@ -239,7 +237,7 @@
     *(aes_uint128_t *) (bskey + 1344) = b3;                                    \
     *(aes_uint128_t *) (bskey + 1360) = b7;                                    \
     *(aes_uint128_t *) (bskey + 1376) = b2;                                    \
-    *(aes_uint128_t *) (bskey + 1392) = b5;
+    *(aes_uint128_t *) (bskey + 1392) = b5
 
 #define keyexpbs(b0, b1, b2, b3, b4, b5, b6, b7, t0, t1, t2, t3, t4, t5, t6, \
                  t7, rcon, i, bskey)                                         \
@@ -255,9 +253,9 @@
     rotbyte(&b5);                                                            \
     rotbyte(&b6);                                                            \
     rotbyte(&b7);                                                            \
-    ;                                                                        \
+                                                                             \
     sbox(b0, b1, b2, b3, b4, b5, b6, b7, t0, t1, t2, t3, t4, t5, t6, t7);    \
-    ;                                                                        \
+                                                                             \
     rcon;                                                                    \
     shufb(&b0, EXPB0);                                                       \
     shufb(&b1, EXPB0);                                                       \
@@ -267,7 +265,7 @@
     shufb(&b7, EXPB0);                                                       \
     shufb(&b2, EXPB0);                                                       \
     shufb(&b5, EXPB0);                                                       \
-    ;                                                                        \
+                                                                             \
     t0 = *(aes_uint128_t *) (bskey + (i - 1) * 128 + 0);                     \
     t1 = *(aes_uint128_t *) (bskey + (i - 1) * 128 + 16);                    \
     t2 = *(aes_uint128_t *) (bskey + (i - 1) * 128 + 32);                    \
@@ -276,12 +274,12 @@
     t5 = *(aes_uint128_t *) (bskey + (i - 1) * 128 + 80);                    \
     t6 = *(aes_uint128_t *) (bskey + (i - 1) * 128 + 96);                    \
     t7 = *(aes_uint128_t *) (bskey + (i - 1) * 128 + 112);                   \
-    ;                                                                        \
+                                                                             \
     toggle(&t0);                                                             \
     toggle(&t1);                                                             \
     toggle(&t5);                                                             \
     toggle(&t6);                                                             \
-    ;                                                                        \
+                                                                             \
     xor2(&b0, &t0);                                                          \
     xor2(&b1, &t1);                                                          \
     xor2(&b4, &t2);                                                          \
@@ -290,7 +288,7 @@
     xor2(&b7, &t5);                                                          \
     xor2(&b2, &t6);                                                          \
     xor2(&b5, &t7);                                                          \
-    ;                                                                        \
+                                                                             \
     rshift32_littleendian(&t0, 8);                                           \
     rshift32_littleendian(&t1, 8);                                           \
     rshift32_littleendian(&t2, 8);                                           \
@@ -299,7 +297,7 @@
     rshift32_littleendian(&t5, 8);                                           \
     rshift32_littleendian(&t6, 8);                                           \
     rshift32_littleendian(&t7, 8);                                           \
-    ;                                                                        \
+                                                                             \
     xor2(&b0, &t0);                                                          \
     xor2(&b1, &t1);                                                          \
     xor2(&b4, &t2);                                                          \
@@ -308,7 +306,7 @@
     xor2(&b7, &t5);                                                          \
     xor2(&b2, &t6);                                                          \
     xor2(&b5, &t7);                                                          \
-    ;                                                                        \
+                                                                             \
     rshift32_littleendian(&t0, 8);                                           \
     rshift32_littleendian(&t1, 8);                                           \
     rshift32_littleendian(&t2, 8);                                           \
@@ -317,7 +315,7 @@
     rshift32_littleendian(&t5, 8);                                           \
     rshift32_littleendian(&t6, 8);                                           \
     rshift32_littleendian(&t7, 8);                                           \
-    ;                                                                        \
+                                                                             \
     xor2(&b0, &t0);                                                          \
     xor2(&b1, &t1);                                                          \
     xor2(&b4, &t2);                                                          \
@@ -326,7 +324,7 @@
     xor2(&b7, &t5);                                                          \
     xor2(&b2, &t6);                                                          \
     xor2(&b5, &t7);                                                          \
-    ;                                                                        \
+                                                                             \
     rshift32_littleendian(&t0, 8);                                           \
     rshift32_littleendian(&t1, 8);                                           \
     rshift32_littleendian(&t2, 8);                                           \
@@ -335,7 +333,7 @@
     rshift32_littleendian(&t5, 8);                                           \
     rshift32_littleendian(&t6, 8);                                           \
     rshift32_littleendian(&t7, 8);                                           \
-    ;                                                                        \
+                                                                             \
     xor2(&b0, &t0);                                                          \
     xor2(&b1, &t1);                                                          \
     xor2(&b4, &t2);                                                          \
@@ -344,7 +342,7 @@
     xor2(&b7, &t5);                                                          \
     xor2(&b2, &t6);                                                          \
     xor2(&b5, &t7);                                                          \
-    ;                                                                        \
+                                                                             \
     *(aes_uint128_t *) (bskey + i * 128 + 0)   = b0;                         \
     *(aes_uint128_t *) (bskey + i * 128 + 16)  = b1;                         \
     *(aes_uint128_t *) (bskey + i * 128 + 32)  = b4;                         \
@@ -352,7 +350,7 @@
     *(aes_uint128_t *) (bskey + i * 128 + 64)  = b3;                         \
     *(aes_uint128_t *) (bskey + i * 128 + 80)  = b7;                         \
     *(aes_uint128_t *) (bskey + i * 128 + 96)  = b2;                         \
-    *(aes_uint128_t *) (bskey + i * 128 + 112) = b5;
+    *(aes_uint128_t *) (bskey + i * 128 + 112) = b5
 
 /* Macros used in multiple contexts */
 
@@ -366,9 +364,9 @@
     copy2(&xmm5, &xmm0);                                         \
     copy2(&xmm6, &xmm0);                                         \
     copy2(&xmm7, &xmm0);                                         \
-    ;                                                            \
+                                                                 \
     bitslice(xmm7, xmm6, xmm5, xmm4, xmm3, xmm2, xmm1, xmm0, t); \
-    ;                                                            \
+                                                                 \
     *(aes_uint128_t *) (bskey + 0)   = xmm0;                     \
     *(aes_uint128_t *) (bskey + 16)  = xmm1;                     \
     *(aes_uint128_t *) (bskey + 32)  = xmm2;                     \
@@ -376,7 +374,7 @@
     *(aes_uint128_t *) (bskey + 64)  = xmm4;                     \
     *(aes_uint128_t *) (bskey + 80)  = xmm5;                     \
     *(aes_uint128_t *) (bskey + 96)  = xmm6;                     \
-    *(aes_uint128_t *) (bskey + 112) = xmm7;
+    *(aes_uint128_t *) (bskey + 112) = xmm7
 
 #define bitslicekey10(key, bskey)                                \
     xmm0 = *(aes_uint128_t *) (key + 0);                         \
@@ -387,14 +385,14 @@
     copy2(xmm5, xmm0);                                           \
     copy2(xmm6, xmm0);                                           \
     copy2(xmm7, xmm0);                                           \
-    ;                                                            \
+                                                                 \
     bitslice(xmm7, xmm6, xmm5, xmm4, xmm3, xmm2, xmm1, xmm0, t); \
-    ;                                                            \
+                                                                 \
     toggle(&xmm6);                                               \
     toggle(&xmm5);                                               \
     toggle(&xmm1);                                               \
     toggle(&xmm0);                                               \
-    ;                                                            \
+                                                                 \
     *(aes_uint128_t *) (bskey + 0 + 1280)   = xmm0;              \
     *(aes_uint128_t *) (bskey + 16 + 1280)  = xmm1;              \
     *(aes_uint128_t *) (bskey + 32 + 1280)  = xmm2;              \
@@ -402,7 +400,7 @@
     *(aes_uint128_t *) (bskey + 64 + 1280)  = xmm4;              \
     *(aes_uint128_t *) (bskey + 80 + 1280)  = xmm5;              \
     *(aes_uint128_t *) (bskey + 96 + 1280)  = xmm6;              \
-    *(aes_uint128_t *) (bskey + 112 + 1280) = xmm7;
+    *(aes_uint128_t *) (bskey + 112 + 1280) = xmm7
 
 #define bitslicekey(i, key, bskey)                               \
     xmm0 = *(aes_uint128_t *) (key + 0);                         \
@@ -414,14 +412,14 @@
     copy2(&xmm5, &xmm0);                                         \
     copy2(&xmm6, &xmm0);                                         \
     copy2(&xmm7, &xmm0);                                         \
-    ;                                                            \
+                                                                 \
     bitslice(xmm7, xmm6, xmm5, xmm4, xmm3, xmm2, xmm1, xmm0, t); \
-    ;                                                            \
+                                                                 \
     toggle(&xmm6);                                               \
     toggle(&xmm5);                                               \
     toggle(&xmm1);                                               \
     toggle(&xmm0);                                               \
-    ;                                                            \
+                                                                 \
     *(aes_uint128_t *) (bskey + 0 + 128 * i)   = xmm0;           \
     *(aes_uint128_t *) (bskey + 16 + 128 * i)  = xmm1;           \
     *(aes_uint128_t *) (bskey + 32 + 128 * i)  = xmm2;           \
@@ -429,23 +427,23 @@
     *(aes_uint128_t *) (bskey + 64 + 128 * i)  = xmm4;           \
     *(aes_uint128_t *) (bskey + 80 + 128 * i)  = xmm5;           \
     *(aes_uint128_t *) (bskey + 96 + 128 * i)  = xmm6;           \
-    *(aes_uint128_t *) (bskey + 112 + 128 * i) = xmm7;
+    *(aes_uint128_t *) (bskey + 112 + 128 * i) = xmm7
 
 #define bitslice(x0, x1, x2, x3, x4, x5, x6, x7, t) \
     swapmove(x0, x1, 1, BS0, t);                    \
     swapmove(x2, x3, 1, BS0, t);                    \
     swapmove(x4, x5, 1, BS0, t);                    \
     swapmove(x6, x7, 1, BS0, t);                    \
-    ;                                               \
+                                                    \
     swapmove(x0, x2, 2, BS1, t);                    \
     swapmove(x1, x3, 2, BS1, t);                    \
     swapmove(x4, x6, 2, BS1, t);                    \
     swapmove(x5, x7, 2, BS1, t);                    \
-    ;                                               \
+                                                    \
     swapmove(x0, x4, 4, BS2, t);                    \
     swapmove(x1, x5, 4, BS2, t);                    \
     swapmove(x2, x6, 4, BS2, t);                    \
-    swapmove(x3, x7, 4, BS2, t);
+    swapmove(x3, x7, 4, BS2, t)
 
 #define swapmove(a, b, n, m, t)   \
     copy2(&t, &b);                \
@@ -454,7 +452,7 @@
     and2(&t, &m);                 \
     xor2(&a, &t);                 \
     lshift64_littleendian(&t, n); \
-    xor2(&b, &t);
+    xor2(&b, &t)
 
 #define rotbyte(x) shufb(x, ROTB) /* TODO: Make faster */
 
@@ -476,7 +474,7 @@
     xor2(&x6, (const aes_uint128_t *) (bskey + 128 * (i - 1) + 96));  \
     shufb(&x6, M);                                                    \
     xor2(&x7, (const aes_uint128_t *) (bskey + 128 * (i - 1) + 112)); \
-    shufb(&x7, M);
+    shufb(&x7, M)
 
 #define mixcolumns(x0, x1, x2, x3, x4, x5, x6, x7, t0, t1, t2, t3, t4, t5, t6, \
                    t7)                                                         \
@@ -488,7 +486,7 @@
     shufd(&t5, &x5, 0x93);                                                     \
     shufd(&t6, &x6, 0x93);                                                     \
     shufd(&t7, &x7, 0x93);                                                     \
-    ;                                                                          \
+                                                                               \
     xor2(&x0, &t0);                                                            \
     xor2(&x1, &t1);                                                            \
     xor2(&x2, &t2);                                                            \
@@ -497,7 +495,7 @@
     xor2(&x5, &t5);                                                            \
     xor2(&x6, &t6);                                                            \
     xor2(&x7, &t7);                                                            \
-    ;                                                                          \
+                                                                               \
     xor2(&t0, &x7);                                                            \
     xor2(&t1, &x0);                                                            \
     xor2(&t2, &x1);                                                            \
@@ -509,7 +507,7 @@
     xor2(&t6, &x5);                                                            \
     xor2(&t7, &x6);                                                            \
     xor2(&t4, &x7);                                                            \
-    ;                                                                          \
+                                                                               \
     shufd(&x0, &x0, 0x4e);                                                     \
     shufd(&x1, &x1, 0x4e);                                                     \
     shufd(&x2, &x2, 0x4e);                                                     \
@@ -518,7 +516,7 @@
     shufd(&x5, &x5, 0x4e);                                                     \
     shufd(&x6, &x6, 0x4e);                                                     \
     shufd(&x7, &x7, 0x4e);                                                     \
-    ;                                                                          \
+                                                                               \
     xor2(&t0, &x0);                                                            \
     xor2(&t1, &x1);                                                            \
     xor2(&t2, &x2);                                                            \
@@ -526,13 +524,13 @@
     xor2(&t4, &x4);                                                            \
     xor2(&t5, &x5);                                                            \
     xor2(&t6, &x6);                                                            \
-    xor2(&t7, &x7);
+    xor2(&t7, &x7)
 
 #define aesround(i, b0, b1, b2, b3, b4, b5, b6, b7, t0, t1, t2, t3, t4, t5, \
                  t6, t7, bskey)                                             \
     shiftrows(b0, b1, b2, b3, b4, b5, b6, b7, i, SR, bskey);                \
     sbox(b0, b1, b2, b3, b4, b5, b6, b7, t0, t1, t2, t3, t4, t5, t6, t7);   \
-    mixcolumns(b0, b1, b4, b6, b3, b7, b2, b5, t0, t1, t2, t3, t4, t5, t6, t7);
+    mixcolumns(b0, b1, b4, b6, b3, b7, b2, b5, t0, t1, t2, t3, t4, t5, t6, t7)
 
 #define lastround(b0, b1, b2, b3, b4, b5, b6, b7, t0, t1, t2, t3, t4, t5, t6, \
                   t7, bskey)                                                  \
@@ -545,12 +543,12 @@
     xor2(&b3, (const aes_uint128_t *) (bskey + 128 * 10 + 64));               \
     xor2(&b7, (const aes_uint128_t *) (bskey + 128 * 10 + 80));               \
     xor2(&b2, (const aes_uint128_t *) (bskey + 128 * 10 + 96));               \
-    xor2(&b5, (const aes_uint128_t *) (bskey + 128 * 10 + 112));
+    xor2(&b5, (const aes_uint128_t *) (bskey + 128 * 10 + 112))
 
 #define sbox(b0, b1, b2, b3, b4, b5, b6, b7, t0, t1, t2, t3, s0, s1, s2, s3)   \
     InBasisChange(b0, b1, b2, b3, b4, b5, b6, b7);                             \
     Inv_GF256(b6, b5, b0, b3, b7, b1, b4, b2, t0, t1, t2, t3, s0, s1, s2, s3); \
-    OutBasisChange(b7, b1, b4, b2, b6, b5, b0, b3);
+    OutBasisChange(b7, b1, b4, b2, b6, b5, b0, b3)
 
 #define InBasisChange(b0, b1, b2, b3, b4, b5, b6, b7) \
     xor2(&b5, &b6);                                   \
@@ -558,16 +556,16 @@
     xor2(&b5, &b0);                                   \
     xor2(&b6, &b2);                                   \
     xor2(&b3, &b0);                                   \
-    ;                                                 \
+                                                      \
     xor2(&b6, &b3);                                   \
     xor2(&b3, &b7);                                   \
     xor2(&b3, &b4);                                   \
     xor2(&b7, &b5);                                   \
     xor2(&b3, &b1);                                   \
-    ;                                                 \
+                                                      \
     xor2(&b4, &b5);                                   \
     xor2(&b2, &b7);                                   \
-    xor2(&b1, &b5);
+    xor2(&b1, &b5)
 
 #define OutBasisChange(b0, b1, b2, b3, b4, b5, b6, b7) \
     xor2(&b0, &b6);                                    \
@@ -575,14 +573,14 @@
     xor2(&b2, &b0);                                    \
     xor2(&b4, &b6);                                    \
     xor2(&b6, &b1);                                    \
-    ;                                                  \
+                                                       \
     xor2(&b1, &b5);                                    \
     xor2(&b5, &b3);                                    \
     xor2(&b2, &b5);                                    \
     xor2(&b3, &b7);                                    \
     xor2(&b7, &b5);                                    \
-    ;                                                  \
-    xor2(&b4, &b7);
+                                                       \
+    xor2(&b4, &b7)
 
 #define Mul_GF4(x0, x1, y0, y1, t0) \
     copy2(&t0, &y0);                \
@@ -592,7 +590,7 @@
     and2(&x0, &y1);                 \
     and2(&x1, &y0);                 \
     xor2(&x0, &x1);                 \
-    xor2(&x1, &t0);
+    xor2(&x1, &t0)
 
 #define Mul_GF4_N(x0, x1, y0, y1, t0) \
     copy2(&t0, &y0);                  \
@@ -602,7 +600,7 @@
     and2(&x0, &y1);                   \
     and2(&x1, &y0);                   \
     xor2(&x1, &x0);                   \
-    xor2(&x0, &t0);
+    xor2(&x0, &t0)
 
 #define Mul_GF4_2(x0, x1, x2, x3, y0, y1, t0, t1) \
     copy2(&t0, = y0);                             \
@@ -619,7 +617,7 @@
     xor2(&x0, &x1);                               \
     xor2(&x2, &x3);                               \
     xor2(&x1, &t0);                               \
-    xor2(&x3, &t1);
+    xor2(&x3, &t1)
 
 #define Mul_GF16(x0, x1, x2, x3, y0, y1, y2, y3, t0, t1, t2, t3) \
     copy2(&t0, &x0);                                             \
@@ -631,11 +629,11 @@
     xor2(&y1, &y3);                                              \
     Mul_GF4_N(t0, t1, y0, y1, t2);                               \
     Mul_GF4(x2, x3, y2, y3, t3);                                 \
-    ;                                                            \
+                                                                 \
     xor2(&x0, &t0);                                              \
     xor2(&x2, &t0);                                              \
     xor2(&x1, &t1);                                              \
-    xor2(&x3, &t1);
+    xor2(&x3, &t1)
 
 #define Mul_GF16_2(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, t0, t1, t2, \
                    t3)                                                         \
@@ -648,12 +646,12 @@
     xor2(&y1, &y3);                                                            \
     Mul_GF4_N(t0, t1, y0, y1, t3);                                             \
     Mul_GF4(x2, x3, y2, y3, t2);                                               \
-    ;                                                                          \
+                                                                               \
     xor2(&x0, &t0);                                                            \
     xor2(&x2, &t0);                                                            \
     xor2(&x1, &t1);                                                            \
     xor2(&x3, &t1);                                                            \
-    ;                                                                          \
+                                                                               \
     copy2(&t0, &x4);                                                           \
     copy2(&t1, &x5);                                                           \
     xor2(&t0, &x6);                                                            \
@@ -663,11 +661,11 @@
     xor2(&y0, &y2);                                                            \
     xor2(&y1, &y3);                                                            \
     Mul_GF4(x4, x5, y0, y1, t3);                                               \
-    ;                                                                          \
+                                                                               \
     xor2(&x4, &t0);                                                            \
     xor2(&x6, &t0);                                                            \
     xor2(&x5, &t1);                                                            \
-    xor2(&x7, &t1);
+    xor2(&x7, &t1)
 
 #define Inv_GF16(x0, x1, x2, x3, t0, t1, t2, t3) \
     copy2(&t0, &x1);                             \
@@ -679,11 +677,11 @@
     or2(&t2, &x2);                               \
     or2(&t3, &x3);                               \
     xor2(&t2, &t3);                              \
-    ;                                            \
+                                                 \
     xor2(&t0, &t2);                              \
     xor2(&t1, &t2);                              \
-    ;                                            \
-    Mul_GF4_2(x0, x1, x2, x3, t1, t0, t2, t3);
+                                                 \
+    Mul_GF4_2(x0, x1, x2, x3, t1, t0, t2, t3)
 
 #define Inv_GF256(x0, x1, x2, x3, x4, x5, x6, x7, t0, t1, t2, t3, s0, s1, s2, \
                   s3)                                                         \
@@ -692,17 +690,17 @@
     copy2(&t1, &x1);                                                          \
     copy2(&s1, &x7);                                                          \
     copy2(&s0, &x0);                                                          \
-    ;                                                                         \
+                                                                              \
     xor2(&t3, &x6);                                                           \
     xor2(&t2, &x7);                                                           \
     xor2(&t1, &x3);                                                           \
     xor2(&s1, &x6);                                                           \
     xor2(&s0, &x2);                                                           \
-    ;                                                                         \
+                                                                              \
     copy2(&s2, &t3);                                                          \
     copy2(&t0, &t2);                                                          \
     copy2(&s3, &t3);                                                          \
-    ;                                                                         \
+                                                                              \
     or2(&t2, &t1);                                                            \
     or2(&t3, &s0);                                                            \
     xor2(&s3, &t0);                                                           \
@@ -740,7 +738,7 @@
     xor2(&t2, &s1);                                                           \
     xor2(&t1, &s2);                                                           \
     xor2(&t0, &s3);                                                           \
-    ;                                                                         \
+                                                                              \
     copy2(&s0, &t3);                                                          \
     xor2(&s0, &t2);                                                           \
     and2(&t3, &t1);                                                           \
@@ -762,7 +760,7 @@
     xor2(&s2, &t2);                                                           \
     and2(&s2, &s3);                                                           \
     xor2(&s2, &s0);                                                           \
-    ;                                                                         \
-    Mul_GF16_2(x0, x1, x2, x3, x4, x5, x6, x7, s3, s2, s1, t1, s0, t0, t2, t3);
+                                                                              \
+    Mul_GF16_2(x0, x1, x2, x3, x4, x5, x6, x7, s3, s2, s1, t1, s0, t0, t2, t3)
 
 #endif
diff --git a/src/libsodium/crypto_stream/aes128ctr/nacl/consts.h b/src/libsodium/crypto_stream/aes128ctr/nacl/consts.h
index 4be7261b..d736f0d3 100644
--- a/src/libsodium/crypto_stream/aes128ctr/nacl/consts.h
+++ b/src/libsodium/crypto_stream/aes128ctr/nacl/consts.h
@@ -1,5 +1,5 @@
-#ifndef CONSTS_H
-#define CONSTS_H
+#ifndef aes128ctr_nacl_consts_H
+#define aes128ctr_nacl_consts_H
 
 #include "int128.h"
 
diff --git a/src/libsodium/crypto_stream/aes128ctr/nacl/int128.h b/src/libsodium/crypto_stream/aes128ctr/nacl/int128.h
index 1b4161ce..93954c07 100644
--- a/src/libsodium/crypto_stream/aes128ctr/nacl/int128.h
+++ b/src/libsodium/crypto_stream/aes128ctr/nacl/int128.h
@@ -1,16 +1,10 @@
-#ifndef INT128_H
-#define INT128_H
+#ifndef aes128ctr_nacl_int128_H
+#define aes128ctr_nacl_int128_H
 
 #include <stdint.h>
 
 #include "common.h"
 
-#ifdef __cplusplus
-#ifdef __GNUC__
-#pragma GCC diagnostic ignored "-Wlong-long"
-#endif
-#endif
-
 typedef union {
     uint64_t u64[2];
     uint32_t u32[4];
diff --git a/src/libsodium/crypto_stream/aes128ctr/nacl/int128_aes128ctr.c b/src/libsodium/crypto_stream/aes128ctr/nacl/int128_aes128ctr.c
index c3503645..b74eef2d 100644
--- a/src/libsodium/crypto_stream/aes128ctr/nacl/int128_aes128ctr.c
+++ b/src/libsodium/crypto_stream/aes128ctr/nacl/int128_aes128ctr.c
@@ -1,3 +1,4 @@
+#include <stdint.h>
 
 #include "common.h"
 #include "int128.h"
@@ -94,7 +95,7 @@ void
 rshift64_littleendian(aes_uint128_t *r, const unsigned int n)
 {
     unsigned char *rp = (unsigned char *) r;
-    uint64         t;
+    uint64_t       t;
 
     t = LOAD64_LE(rp);
     t >>= n;
@@ -108,7 +109,7 @@ void
 lshift64_littleendian(aes_uint128_t *r, const unsigned int n)
 {
     unsigned char *rp = (unsigned char *) r;
-    uint64         t;
+    uint64_t       t;
 
     t = LOAD64_LE(rp);
     t <<= n;
diff --git a/src/libsodium/crypto_stream/aes128ctr/nacl/types.h b/src/libsodium/crypto_stream/aes128ctr/nacl/types.h
deleted file mode 100644
index 1427271f..00000000
--- a/src/libsodium/crypto_stream/aes128ctr/nacl/types.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef TYPES_H
-#define TYPES_H
-
-#include <stdint.h>
-#include <stdlib.h>
-
-typedef uint32_t uint32;
-typedef uint64_t uint64;
-
-#endif
diff --git a/src/libsodium/crypto_stream/aes128ctr/nacl/xor_afternm_aes128ctr.c b/src/libsodium/crypto_stream/aes128ctr/nacl/xor_afternm_aes128ctr.c
index 1b82e57f..07396c94 100644
--- a/src/libsodium/crypto_stream/aes128ctr/nacl/xor_afternm_aes128ctr.c
+++ b/src/libsodium/crypto_stream/aes128ctr/nacl/xor_afternm_aes128ctr.c
@@ -14,31 +14,29 @@ crypto_stream_aes128ctr_xor_afternm(unsigned char *out, const unsigned char *in,
                                     const unsigned char *nonce,
                                     const unsigned char *c)
 {
-    aes_uint128_t xmm0;
-    aes_uint128_t xmm1;
-    aes_uint128_t xmm2;
-    aes_uint128_t xmm3;
-    aes_uint128_t xmm4;
-    aes_uint128_t xmm5;
-    aes_uint128_t xmm6;
-    aes_uint128_t xmm7;
-    aes_uint128_t xmm8;
-    aes_uint128_t xmm9;
-    aes_uint128_t xmm10;
-    aes_uint128_t xmm11;
-    aes_uint128_t xmm12;
-    aes_uint128_t xmm13;
-    aes_uint128_t xmm14;
-    aes_uint128_t xmm15;
-
+    aes_uint128_t      xmm0;
+    aes_uint128_t      xmm1;
+    aes_uint128_t      xmm2;
+    aes_uint128_t      xmm3;
+    aes_uint128_t      xmm4;
+    aes_uint128_t      xmm5;
+    aes_uint128_t      xmm6;
+    aes_uint128_t      xmm7;
+    aes_uint128_t      xmm8;
+    aes_uint128_t      xmm9;
+    aes_uint128_t      xmm10;
+    aes_uint128_t      xmm11;
+    aes_uint128_t      xmm12;
+    aes_uint128_t      xmm13;
+    aes_uint128_t      xmm14;
+    aes_uint128_t      xmm15;
     aes_uint128_t      nonce_stack;
     unsigned long long lensav;
     unsigned char      bl[128];
     unsigned char *    blp;
     unsigned char *    np;
     unsigned char      b;
-
-    uint32_t tmp;
+    uint32_t           tmp;
 
     /* Copy nonce on the stack */
     copy2(&nonce_stack, (const aes_uint128_t *) (nonce + 0));
@@ -73,43 +71,37 @@ enc_block:
     shufb(&xmm6, M0SWAP);
     shufb(&xmm7, M0SWAP);
 
-    bitslice(xmm7, xmm6, xmm5, xmm4, xmm3, xmm2, xmm1, xmm0, xmm8)
+    bitslice(xmm7, xmm6, xmm5, xmm4, xmm3, xmm2, xmm1, xmm0, xmm8);
 
-        aesround(1, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
-                 xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,
-                 c) aesround(2, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14,
-                             xmm15, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6,
-                             xmm7, c)
-            aesround(3, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8,
-                     xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,
-                     c) aesround(4, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13,
-                                 xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4,
-                                 xmm5, xmm6, xmm7, c)
-                aesround(5, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,
-                         xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,
-                         c) aesround(6, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13,
-                                     xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4,
-                                     xmm5, xmm6, xmm7, c)
-                    aesround(7, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,
-                             xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14,
-                             xmm15, c)
-                        aesround(8, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13,
-                                 xmm14, xmm15, xmm0, xmm1, xmm2, xmm3, xmm4,
-                                 xmm5, xmm6, xmm7, c)
-                            aesround(9, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5,
-                                     xmm6, xmm7, xmm8, xmm9, xmm10, xmm11,
-                                     xmm12, xmm13, xmm14, xmm15, c)
-                                lastround(xmm8, xmm9, xmm10, xmm11, xmm12,
-                                          xmm13, xmm14, xmm15, xmm0, xmm1, xmm2,
-                                          xmm3, xmm4, xmm5, xmm6, xmm7, c)
+    aesround(1, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    aesround(2, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0,
+             xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
+    aesround(3, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    aesround(4, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0,
+             xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
+    aesround(5, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    aesround(6, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0,
+             xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
+    aesround(7, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    aesround(8, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0,
+             xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
+    aesround(9, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    lastround(xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1,
+              xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
 
-                                    bitslice(xmm13, xmm10, xmm15, xmm11, xmm14,
-                                             xmm12, xmm9, xmm8, xmm0)
+    bitslice(xmm13, xmm10, xmm15, xmm11, xmm14, xmm12, xmm9, xmm8, xmm0);
 
-                                        if (len < 128) goto partial;
-    if (len == 128)
+    if (len < 128) {
+        goto partial;
+    }
+    if (len == 128) {
         goto full;
-
+    }
     tmp = LOAD32_BE(np + 12);
     tmp += 8;
     STORE32_BE(np + 12, tmp);
@@ -147,7 +139,8 @@ partial:
     tmp += len;
     STORE32_BE(np + 12, tmp);
 
-    blp                            = bl;
+    blp = bl;
+
     *(aes_uint128_t *) (blp + 0)   = xmm8;
     *(aes_uint128_t *) (blp + 16)  = xmm9;
     *(aes_uint128_t *) (blp + 32)  = xmm12;
@@ -159,9 +152,9 @@ partial:
 
 bytes:
 
-    if (lensav == 0)
+    if (lensav == 0) {
         goto end;
-
+    }
     b = blp[0]; /* clang false positive */
     b ^= *(const unsigned char *) (in + 0);
     *(unsigned char *) (out + 0) = b;