diff --git a/src/libs/3rdparty/botan/botan.cpp b/src/libs/3rdparty/botan/botan.cpp
index be1dd73393c..c865a4db84e 100644
--- a/src/libs/3rdparty/botan/botan.cpp
+++ b/src/libs/3rdparty/botan/botan.cpp
@@ -2556,78 +2556,32 @@ inline word word_add(word x, word y, word* carry)
 */
 inline word word8_add2(word x[8], const word y[8], word carry)
    {
-   __asm {
-      mov edx,[x]
-      mov esi,[y]
-      xor eax,eax
-      sub eax,[carry] //force CF=1 iff *carry==1
-      mov eax,[esi]
-      adc [edx],eax
-      mov eax,[esi+4]
-      adc [edx+4],eax
-      mov eax,[esi+8]
-      adc [edx+8],eax
-      mov eax,[esi+12]
-      adc [edx+12],eax
-      mov eax,[esi+16]
-      adc [edx+16],eax
-      mov eax,[esi+20]
-      adc [edx+20],eax
-      mov eax,[esi+24]
-      adc [edx+24],eax
-      mov eax,[esi+28]
-      adc [edx+28],eax
-      sbb eax,eax
-      neg eax
-      }
+   x[0] = word_add(x[0], y[0], &carry);
+   x[1] = word_add(x[1], y[1], &carry);
+   x[2] = word_add(x[2], y[2], &carry);
+   x[3] = word_add(x[3], y[3], &carry);
+   x[4] = word_add(x[4], y[4], &carry);
+   x[5] = word_add(x[5], y[5], &carry);
+   x[6] = word_add(x[6], y[6], &carry);
+   x[7] = word_add(x[7], y[7], &carry);
+   return carry;
    }
 
 /*
 * Eight Word Block Addition, Three Argument
 */
-inline word word8_add3(word z[8], const word x[8], const word y[8], word carry)
+inline word word8_add3(word z[8], const word x[8],
+                       const word y[8], word carry)
    {
-    __asm {
-      mov edi,[x]
-      mov esi,[y]
-      mov ebx,[z]
-      xor eax,eax
-      sub eax,[carry] //force CF=1 iff *carry==1
-      mov eax,[edi]
-      adc eax,[esi]
-      mov [ebx],eax
-
-      mov eax,[edi+4]
-      adc eax,[esi+4]
-      mov [ebx+4],eax
-
-      mov eax,[edi+8]
-      adc eax,[esi+8]
-      mov [ebx+8],eax
-
-      mov eax,[edi+12]
-      adc eax,[esi+12]
-      mov [ebx+12],eax
-
-      mov eax,[edi+16]
-      adc eax,[esi+16]
-      mov [ebx+16],eax
-
-      mov eax,[edi+20]
-      adc eax,[esi+20]
-      mov [ebx+20],eax
-
-      mov eax,[edi+24]
-      adc eax,[esi+24]
-      mov [ebx+24],eax
-
-      mov eax,[edi+28]
-      adc eax,[esi+28]
-      mov [ebx+28],eax
-
-      sbb eax,eax
-      neg eax
-      }
+   z[0] = word_add(x[0], y[0], &carry);
+   z[1] = word_add(x[1], y[1], &carry);
+   z[2] = word_add(x[2], y[2], &carry);
+   z[3] = word_add(x[3], y[3], &carry);
+   z[4] = word_add(x[4], y[4], &carry);
+   z[5] = word_add(x[5], y[5], &carry);
+   z[6] = word_add(x[6], y[6], &carry);
+   z[7] = word_add(x[7], y[7], &carry);
+   return carry;
    }
 
 /*
@@ -2647,38 +2601,15 @@ inline word word_sub(word x, word y, word* carry)
 */
 inline word word8_sub2(word x[8], const word y[8], word carry)
    {
-    __asm {
-      mov edi,[x]
-      mov esi,[y]
-      xor eax,eax
-      sub eax,[carry] //force CF=1 iff *carry==1
-      mov eax,[edi]
-      sbb eax,[esi]
-      mov [edi],eax
-      mov eax,[edi+4]
-      sbb eax,[esi+4]
-      mov [edi+4],eax
-      mov eax,[edi+8]
-      sbb eax,[esi+8]
-      mov [edi+8],eax
-      mov eax,[edi+12]
-      sbb eax,[esi+12]
-      mov [edi+12],eax
-      mov eax,[edi+16]
-      sbb eax,[esi+16]
-      mov [edi+16],eax
-      mov eax,[edi+20]
-      sbb eax,[esi+20]
-      mov [edi+20],eax
-      mov eax,[edi+24]
-      sbb eax,[esi+24]
-      mov [edi+24],eax
-      mov eax,[edi+28]
-      sbb eax,[esi+28]
-      mov [edi+28],eax
-      sbb eax,eax
-      neg eax
-      }
+   x[0] = word_sub(x[0], y[0], &carry);
+   x[1] = word_sub(x[1], y[1], &carry);
+   x[2] = word_sub(x[2], y[2], &carry);
+   x[3] = word_sub(x[3], y[3], &carry);
+   x[4] = word_sub(x[4], y[4], &carry);
+   x[5] = word_sub(x[5], y[5], &carry);
+   x[6] = word_sub(x[6], y[6], &carry);
+   x[7] = word_sub(x[7], y[7], &carry);
+   return carry;
    }
 
 /*
@@ -2697,46 +2628,21 @@ inline word word8_sub2_rev(word x[8], const word y[8], word carry)
    return carry;
    }
 
-
 /*
 * Eight Word Block Subtraction, Three Argument
 */
 inline word word8_sub3(word z[8], const word x[8],
                        const word y[8], word carry)
    {
-    __asm {
-      mov edi,[x]
-      mov esi,[y]
-      xor eax,eax
-      sub eax,[carry] //force CF=1 iff *carry==1
-      mov ebx,[z]
-      mov eax,[edi]
-      sbb eax,[esi]
-      mov [ebx],eax
-      mov eax,[edi+4]
-      sbb eax,[esi+4]
-      mov [ebx+4],eax
-      mov eax,[edi+8]
-      sbb eax,[esi+8]
-      mov [ebx+8],eax
-      mov eax,[edi+12]
-      sbb eax,[esi+12]
-      mov [ebx+12],eax
-      mov eax,[edi+16]
-      sbb eax,[esi+16]
-      mov [ebx+16],eax
-      mov eax,[edi+20]
-      sbb eax,[esi+20]
-      mov [ebx+20],eax
-      mov eax,[edi+24]
-      sbb eax,[esi+24]
-      mov [ebx+24],eax
-      mov eax,[edi+28]
-      sbb eax,[esi+28]
-      mov [ebx+28],eax
-      sbb eax,eax
-      neg eax
-      }
+   z[0] = word_sub(x[0], y[0], &carry);
+   z[1] = word_sub(x[1], y[1], &carry);
+   z[2] = word_sub(x[2], y[2], &carry);
+   z[3] = word_sub(x[3], y[3], &carry);
+   z[4] = word_sub(x[4], y[4], &carry);
+   z[5] = word_sub(x[5], y[5], &carry);
+   z[6] = word_sub(x[6], y[6], &carry);
+   z[7] = word_sub(x[7], y[7], &carry);
+   return carry;
    }
 
 /*
@@ -2744,272 +2650,31 @@ inline word word8_sub3(word z[8], const word x[8],
 */
 inline word word8_linmul2(word x[8], word y, word carry)
    {
-   __asm {
-      mov esi,[x]
-      mov eax,[esi]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,[carry]      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov ecx,edx      //store carry
-      mov [esi],eax        //load a
-
-      mov eax,[esi+4]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,ecx      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov ecx,edx      //store carry
-      mov [esi+4],eax        //load a
-
-      mov eax,[esi+8]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,ecx      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov ecx,edx      //store carry
-      mov [esi+8],eax        //load a
-
-      mov eax,[esi+12]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,ecx      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov ecx,edx      //store carry
-      mov [esi+12],eax        //load a
-
-      mov eax,[esi+16]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,ecx      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov ecx,edx      //store carry
-      mov [esi+16],eax        //load a
-
-      mov eax,[esi+20]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,ecx      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov ecx,edx      //store carry
-      mov [esi+20],eax        //load a
-
-      mov eax,[esi+24]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,ecx      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov ecx,edx      //store carry
-      mov [esi+24],eax        //load a
-
-      mov eax,[esi+28]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,ecx      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov [esi+28],eax        //load a
-
-      mov eax,edx      //store carry
-      }
+   x[0] = word_madd2(x[0], y, &carry);
+   x[1] = word_madd2(x[1], y, &carry);
+   x[2] = word_madd2(x[2], y, &carry);
+   x[3] = word_madd2(x[3], y, &carry);
+   x[4] = word_madd2(x[4], y, &carry);
+   x[5] = word_madd2(x[5], y, &carry);
+   x[6] = word_madd2(x[6], y, &carry);
+   x[7] = word_madd2(x[7], y, &carry);
+   return carry;
    }
 
 /*
 * Eight Word Block Linear Multiplication
 */
-inline word word8_muladd(word z[8], const word x[8],
-                         word y, word carry)
+inline word word8_linmul3(word z[8], const word x[8], word y, word carry)
    {
-   __asm {
-      mov esi,[x]
-      mov ebx,[y]
-      mov edi,[z]
-      mov eax,[esi]     //load a
-      mul ebx           //edx(hi):eax(lo)=a*b
-      add eax,[carry]   //sum lo carry
-      adc edx,0         //sum hi carry
-      add eax,[edi]     //sum lo z
-      adc edx,0         //sum hi z
-      mov ecx,edx       //carry for next block = hi z
-      mov [edi],eax     //save lo z
-
-      mov eax,[esi+4]
-      mul ebx
-      add eax,ecx
-      adc edx,0
-      add eax,[edi+4]
-      adc edx,0
-      mov ecx,edx
-      mov [edi+4],eax
-
-      mov eax,[esi+8]
-      mul ebx
-      add eax,ecx
-      adc edx,0
-      add eax,[edi+8]
-      adc edx,0
-      mov ecx,edx
-      mov [edi+8],eax
-
-      mov eax,[esi+12]
-      mul ebx
-      add eax,ecx
-      adc edx,0
-      add eax,[edi+12]
-      adc edx,0
-      mov ecx,edx
-      mov [edi+12],eax
-
-      mov eax,[esi+16]
-      mul ebx
-      add eax,ecx
-      adc edx,0
-      add eax,[edi+16]
-      adc edx,0
-      mov ecx,edx
-      mov [edi+16],eax
-
-      mov eax,[esi+20]
-      mul ebx
-      add eax,ecx
-      adc edx,0
-      add eax,[edi+20]
-      adc edx,0
-      mov ecx,edx
-      mov [edi+20],eax
-
-      mov eax,[esi+24]
-      mul ebx
-      add eax,ecx
-      adc edx,0
-      add eax,[edi+24]
-      adc edx,0
-      mov ecx,edx
-      mov [edi+24],eax
-
-      mov eax,[esi+28]
-      mul ebx
-      add eax,ecx
-      adc edx,0
-      add eax,[edi+28]
-      adc edx,0
-      mov [edi+28],eax
-      mov eax,edx
-      }
-   }
-
-inline word word8_linmul3(word z[4], const word x[4], word y, word carry)
-   {
-   __asm {
-#if 0
-      //it's slower!!!
-      mov edx,[z]
-      mov eax,[x]
-      movd mm7,[y]
-
-      movd mm0,[eax]
-      movd mm1,[eax+4]
-      movd mm2,[eax+8]
-      pmuludq mm0,mm7
-      pmuludq mm1,mm7
-      pmuludq mm2,mm7
-
-      movd mm6,[carry]
-      paddq mm0,mm6
-      movd [edx],mm0
-
-      psrlq mm0,32
-      paddq mm1,mm0
-      movd [edx+4],mm1
-
-      movd mm3,[eax+12]
-      psrlq mm1,32
-      paddq mm2,mm1
-      movd [edx+8],mm2
-
-      pmuludq mm3,mm7
-      movd mm4,[eax+16]
-      psrlq mm2,32
-      paddq mm3,mm2
-      movd [edx+12],mm3
-
-      pmuludq mm4,mm7
-      movd mm5,[eax+20]
-      psrlq mm3,32
-      paddq mm4,mm3
-      movd [edx+16],mm4
-
-      pmuludq mm5,mm7
-      movd mm0,[eax+24]
-      psrlq mm4,32
-      paddq mm5,mm4
-      movd [edx+20],mm5
-
-      pmuludq mm0,mm7
-      movd mm1,[eax+28]
-      psrlq mm5,32
-      paddq mm0,mm5
-      movd [edx+24],mm0
-
-      pmuludq mm1,mm7
-      psrlq mm0,32
-      paddq mm1,mm0
-      movd [edx+28],mm1
-      psrlq mm1,32
-
-      movd eax,mm1
-      emms
-#else
-      mov edi,[z]
-      mov esi,[x]
-      mov eax,[esi]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,[carry]    //sum lo carry
-      adc edx,0          //sum hi carry
-      mov ecx,edx      //store carry
-      mov [edi],eax        //load a
-
-      mov eax,[esi+4]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,ecx      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov ecx,edx      //store carry
-      mov [edi+4],eax        //load a
-
-      mov eax,[esi+8]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,ecx      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov ecx,edx      //store carry
-      mov [edi+8],eax        //load a
-
-      mov eax,[esi+12]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,ecx      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov ecx,edx      //store carry
-      mov [edi+12],eax        //load a
-
-      mov eax,[esi+16]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,ecx      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov ecx,edx      //store carry
-      mov [edi+16],eax        //load a
-
-      mov eax,[esi+20]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,ecx      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov ecx,edx      //store carry
-      mov [edi+20],eax        //load a
-
-      mov eax,[esi+24]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,ecx      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov ecx,edx      //store carry
-      mov [edi+24],eax        //load a
-
-      mov eax,[esi+28]        //load a
-      mul [y]           //edx(hi):eax(lo)=a*b
-      add eax,ecx      //sum lo carry
-      adc edx,0          //sum hi carry
-      mov [edi+28],eax        //load a
-      mov eax,edx      //store carry
-#endif
-      }
+   z[0] = word_madd2(x[0], y, &carry);
+   z[1] = word_madd2(x[1], y, &carry);
+   z[2] = word_madd2(x[2], y, &carry);
+   z[3] = word_madd2(x[3], y, &carry);
+   z[4] = word_madd2(x[4], y, &carry);
+   z[5] = word_madd2(x[5], y, &carry);
+   z[6] = word_madd2(x[6], y, &carry);
+   z[7] = word_madd2(x[7], y, &carry);
+   return carry;
    }
 
 /*
@@ -3058,6 +2723,7 @@ inline void word3_muladd_2(word* w2, word* w1, word* w0, word a, word b)
    *w1 = word_add(*w1, b, &carry);
    *w2 = word_add(*w2, top, &carry);
    }
+
 #endif
 
 }
@@ -4105,8 +3771,7 @@ AlgorithmIdentifier::AlgorithmIdentifier(const OID& alg_id,
 
    if(option == USE_NULL_PARAM)
       {
-      parameters += std::make_pair<const byte*, size_t>(
-         DER_NULL, sizeof(DER_NULL));
+      parameters += std::pair<const byte*, size_t>(DER_NULL, sizeof(DER_NULL));
       }
    }
 
@@ -4122,8 +3787,7 @@ AlgorithmIdentifier::AlgorithmIdentifier(const std::string& alg_id,
 
    if(option == USE_NULL_PARAM)
       {
-      parameters += std::make_pair<const byte*, size_t>(
-         DER_NULL, sizeof(DER_NULL));
+      parameters += std::pair<const byte*, size_t>(DER_NULL, sizeof(DER_NULL));
       }
    }
 
diff --git a/src/libs/3rdparty/botan/botan.h b/src/libs/3rdparty/botan/botan.h
index 9f855500c6e..51e411dc333 100644
--- a/src/libs/3rdparty/botan/botan.h
+++ b/src/libs/3rdparty/botan/botan.h
@@ -66,7 +66,6 @@
   #define BOTAN_GCC_VERSION 0
 #endif
 
-#define BOTAN_TARGET_ARCH_IS_X86_32
 #define BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN
 #define BOTAN_TARGET_CPU_IS_X86_FAMILY
 #define BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK 1
@@ -10616,12 +10615,6 @@ inline u32bit reverse_bytes(u32bit val)
 
    return val;
 
-#elif defined(_MSC_VER) && defined(BOTAN_TARGET_ARCH_IS_X86_32)
-
-   // Visual C++ inline asm for 32-bit x86, by Yves Jerschow
-   __asm mov eax, val;
-   __asm bswap eax;
-
 #else
 
    // Generic implementation