0x00 — 0

f(A, B, C) = 0

const __m128i c0 = _mm_setzero_si128();
return c0;

f(A, B, C) = 0

const __m256i c0 = _mm256_setzero_si256();
return c0;

f(A, B, C) = 0

const __m512i c0 = _mm512_setzero_si512();
return c0;

f(A, B, C) = 0

const uint64_t c0 = 0;
return c0;

f(A, B, C) = 0

const uint32_t c0 = 0;
return c0;

f(A, B, C) = 0

const __m128i c0 = _mm_setzero_si128();
return c0;

f(A, B, C) = 0

const int32x4_t c0 = vdupq_n_s32(0);
return c0;

0x01 — (A nor (B or C))

f(A, B, C) = ((A or (B or C)) xor 1)

const __m128i t0 = _mm_or_si128(B, C);
const __m128i t1 = _mm_or_si128(A, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = ((A or (B or C)) xor 1)

const __m256i t0 = _mm256_or_si256(B, C);
const __m256i t1 = _mm256_or_si256(A, t0);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t2 = _mm256_xor_si256(t1, c1);
return t2;

f(A, B, C) = ((A or (B or C)) xor 1)

const __m512i t0 = _mm512_or_si512(B, C);
const __m512i t1 = _mm512_or_si512(A, t0);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t2 = _mm512_xor_si512(t1, c1);
return t2;

f(A, B, C) = not ((A or (B or C)))

const uint64_t t0 = B | C;
const uint64_t t1 = A | t0;
const uint64_t t2 = ~t1;
return t2;

f(A, B, C) = not ((A or (B or C)))

const uint32_t t0 = B | C;
const uint32_t t1 = A | t0;
const uint32_t t2 = ~t1;
return t2;

f(A, B, C) = ((A or (B or C)) xor 1)

const __m128i t0 = _mm_or_si128(B, C);
const __m128i t1 = _mm_or_si128(A, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = not ((A or (B or C)))

const int32x4_t t0 = vorrq_s32(B, C);
const int32x4_t t1 = vorrq_s32(A, t0);
const int32x4_t t2 = vmvnq_s32(t1);
return t2;

0x02 — (C and (B nor A))

f(A, B, C) = ((B or A) notand C)

const __m128i t0 = _mm_or_si128(B, A);
const __m128i t1 = _mm_andnot_si128(t0, C);
return t1;

f(A, B, C) = ((B or A) notand C)

const __m256i t0 = _mm256_or_si256(B, A);
const __m256i t1 = _mm256_andnot_si256(t0, C);
return t1;

f(A, B, C) = ((B or A) notand C)

const __m512i t0 = _mm512_or_si512(B, A);
const __m512i t1 = _mm512_andnot_si512(t0, C);
return t1;

f(A, B, C) = (C and not ((B or A)))

const uint64_t t0 = B | A;
const uint64_t t1 = ~t0;
const uint64_t t2 = C & t1;
return t2;

f(A, B, C) = (C and not ((B or A)))

const uint32_t t0 = B | A;
const uint32_t t1 = ~t0;
const uint32_t t2 = C & t1;
return t2;

f(A, B, C) = ((B or A) notand C)

const __m128i t0 = _mm_or_si128(B, A);
const __m128i t1 = _mm_andnot_si128(t0, C);
return t1;

f(A, B, C) = ((B or A) notand C)

const int32x4_t t0 = vorrq_s32(B, A);
const int32x4_t t1 = vbicq_s32(C, t0);
return t1;

0x03 — (B nor A)

f(A, B, C) = ((B or A) xor 1)

const __m128i t0 = _mm_or_si128(B, A);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(t0, c1);
return t1;

f(A, B, C) = ((B or A) xor 1)

const __m256i t0 = _mm256_or_si256(B, A);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(t0, c1);
return t1;

f(A, B, C) = ((B or A) xor 1)

const __m512i t0 = _mm512_or_si512(B, A);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(t0, c1);
return t1;

f(A, B, C) = not ((B or A))

const uint64_t t0 = B | A;
const uint64_t t1 = ~t0;
return t1;

f(A, B, C) = not ((B or A))

const uint32_t t0 = B | A;
const uint32_t t1 = ~t0;
return t1;

f(A, B, C) = ((B or A) xor 1)

const __m128i t0 = _mm_or_si128(B, A);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(t0, c1);
return t1;

f(A, B, C) = not ((B or A))

const int32x4_t t0 = vorrq_s32(B, A);
const int32x4_t t1 = vmvnq_s32(t0);
return t1;

0x04 — (B and (A nor C))

f(A, B, C) = ((A or C) notand B)

const __m128i t0 = _mm_or_si128(A, C);
const __m128i t1 = _mm_andnot_si128(t0, B);
return t1;

f(A, B, C) = ((A or C) notand B)

const __m256i t0 = _mm256_or_si256(A, C);
const __m256i t1 = _mm256_andnot_si256(t0, B);
return t1;

f(A, B, C) = ((A or C) notand B)

const __m512i t0 = _mm512_or_si512(A, C);
const __m512i t1 = _mm512_andnot_si512(t0, B);
return t1;

f(A, B, C) = (B and not ((A or C)))

const uint64_t t0 = A | C;
const uint64_t t1 = ~t0;
const uint64_t t2 = B & t1;
return t2;

f(A, B, C) = (B and not ((A or C)))

const uint32_t t0 = A | C;
const uint32_t t1 = ~t0;
const uint32_t t2 = B & t1;
return t2;

f(A, B, C) = ((A or C) notand B)

const __m128i t0 = _mm_or_si128(A, C);
const __m128i t1 = _mm_andnot_si128(t0, B);
return t1;

f(A, B, C) = ((A or C) notand B)

const int32x4_t t0 = vorrq_s32(A, C);
const int32x4_t t1 = vbicq_s32(B, t0);
return t1;

0x05 — (C nor A)

f(A, B, C) = ((C or A) xor 1)

const __m128i t0 = _mm_or_si128(C, A);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(t0, c1);
return t1;

f(A, B, C) = ((C or A) xor 1)

const __m256i t0 = _mm256_or_si256(C, A);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(t0, c1);
return t1;

f(A, B, C) = ((C or A) xor 1)

const __m512i t0 = _mm512_or_si512(C, A);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(t0, c1);
return t1;

f(A, B, C) = not ((C or A))

const uint64_t t0 = C | A;
const uint64_t t1 = ~t0;
return t1;

f(A, B, C) = not ((C or A))

const uint32_t t0 = C | A;
const uint32_t t1 = ~t0;
return t1;

f(A, B, C) = ((C or A) xor 1)

const __m128i t0 = _mm_or_si128(C, A);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(t0, c1);
return t1;

f(A, B, C) = not ((C or A))

const int32x4_t t0 = vorrq_s32(C, A);
const int32x4_t t1 = vmvnq_s32(t0);
return t1;

0x06 — (A ? 0 : (B xor C))

f(A, B, C) = (A notand (B xor C))

const __m128i t0 = _mm_xor_si128(B, C);
const __m128i t1 = _mm_andnot_si128(A, t0);
return t1;

f(A, B, C) = (A notand (B xor C))

const __m256i t0 = _mm256_xor_si256(B, C);
const __m256i t1 = _mm256_andnot_si256(A, t0);
return t1;

f(A, B, C) = (A notand (B xor C))

const __m512i t0 = _mm512_xor_si512(B, C);
const __m512i t1 = _mm512_andnot_si512(A, t0);
return t1;

f(A, B, C) = (not (A) and (B xor C))

const uint64_t t0 = ~A;
const uint64_t t1 = B ^ C;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = (not (A) and (B xor C))

const uint32_t t0 = ~A;
const uint32_t t1 = B ^ C;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = (A notand (B xor C))

const __m128i t0 = _mm_xor_si128(B, C);
const __m128i t1 = _mm_andnot_si128(A, t0);
return t1;

f(A, B, C) = (A notand (B xor C))

const int32x4_t t0 = veorq_s32(B, C);
const int32x4_t t1 = vbicq_s32(t0, A);
return t1;

0x07 — (A nor (B and C))

f(A, B, C) = ((A or (B and C)) xor 1)

const __m128i t0 = _mm_and_si128(B, C);
const __m128i t1 = _mm_or_si128(A, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = ((A or (B and C)) xor 1)

const __m256i t0 = _mm256_and_si256(B, C);
const __m256i t1 = _mm256_or_si256(A, t0);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t2 = _mm256_xor_si256(t1, c1);
return t2;

f(A, B, C) = ((A or (B and C)) xor 1)

const __m512i t0 = _mm512_and_si512(B, C);
const __m512i t1 = _mm512_or_si512(A, t0);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t2 = _mm512_xor_si512(t1, c1);
return t2;

f(A, B, C) = not ((A or (B and C)))

const uint64_t t0 = B & C;
const uint64_t t1 = A | t0;
const uint64_t t2 = ~t1;
return t2;

f(A, B, C) = not ((A or (B and C)))

const uint32_t t0 = B & C;
const uint32_t t1 = A | t0;
const uint32_t t2 = ~t1;
return t2;

f(A, B, C) = ((A or (B and C)) xor 1)

const __m128i t0 = _mm_and_si128(B, C);
const __m128i t1 = _mm_or_si128(A, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = not ((A or (B and C)))

const int32x4_t t0 = vandq_s32(B, C);
const int32x4_t t1 = vorrq_s32(A, t0);
const int32x4_t t2 = vmvnq_s32(t1);
return t2;

0x08 — (B ? (not (A) and C) : B)

f(A, B, C) = (A notand (B and C))

const __m128i t0 = _mm_and_si128(B, C);
const __m128i t1 = _mm_andnot_si128(A, t0);
return t1;

f(A, B, C) = (A notand (B and C))

const __m256i t0 = _mm256_and_si256(B, C);
const __m256i t1 = _mm256_andnot_si256(A, t0);
return t1;

f(A, B, C) = (A notand (B and C))

const __m512i t0 = _mm512_and_si512(B, C);
const __m512i t1 = _mm512_andnot_si512(A, t0);
return t1;

f(A, B, C) = (not (A) and (B and C))

const uint64_t t0 = ~A;
const uint64_t t1 = B & C;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = (not (A) and (B and C))

const uint32_t t0 = ~A;
const uint32_t t1 = B & C;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = (A notand (B and C))

const __m128i t0 = _mm_and_si128(B, C);
const __m128i t1 = _mm_andnot_si128(A, t0);
return t1;

f(A, B, C) = (A notand (B and C))

const int32x4_t t0 = vandq_s32(B, C);
const int32x4_t t1 = vbicq_s32(t0, A);
return t1;

0x09 — (A nor (B xor C))

f(A, B, C) = ((A or (B xor C)) xor 1)

const __m128i t0 = _mm_xor_si128(B, C);
const __m128i t1 = _mm_or_si128(A, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = ((A or (B xor C)) xor 1)

const __m256i t0 = _mm256_xor_si256(B, C);
const __m256i t1 = _mm256_or_si256(A, t0);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t2 = _mm256_xor_si256(t1, c1);
return t2;

f(A, B, C) = ((A or (B xor C)) xor 1)

const __m512i t0 = _mm512_xor_si512(B, C);
const __m512i t1 = _mm512_or_si512(A, t0);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t2 = _mm512_xor_si512(t1, c1);
return t2;

f(A, B, C) = not ((A or (B xor C)))

const uint64_t t0 = B ^ C;
const uint64_t t1 = A | t0;
const uint64_t t2 = ~t1;
return t2;

f(A, B, C) = not ((A or (B xor C)))

const uint32_t t0 = B ^ C;
const uint32_t t1 = A | t0;
const uint32_t t2 = ~t1;
return t2;

f(A, B, C) = ((A or (B xor C)) xor 1)

const __m128i t0 = _mm_xor_si128(B, C);
const __m128i t1 = _mm_or_si128(A, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = not ((A or (B xor C)))

const int32x4_t t0 = veorq_s32(B, C);
const int32x4_t t1 = vorrq_s32(A, t0);
const int32x4_t t2 = vmvnq_s32(t1);
return t2;

0x0a — (C and not (A))

f(A, B, C) = (A notand C)

const __m128i t0 = _mm_andnot_si128(A, C);
return t0;

f(A, B, C) = (A notand C)

const __m256i t0 = _mm256_andnot_si256(A, C);
return t0;

f(A, B, C) = (A notand C)

const __m512i t0 = _mm512_andnot_si512(A, C);
return t0;

f(A, B, C) = (C and not (A))

const uint64_t t0 = ~A;
const uint64_t t1 = C & t0;
return t1;

f(A, B, C) = (C and not (A))

const uint32_t t0 = ~A;
const uint32_t t1 = C & t0;
return t1;

f(A, B, C) = (A notand C)

const __m128i t0 = _mm_andnot_si128(A, C);
return t0;

f(A, B, C) = (A notand C)

const int32x4_t t0 = vbicq_s32(C, A);
return t0;

0x0b — (B ? (not (A) and C) : (A xor 1))

f(A, B, C) = (A notand ((B xor 1) or C))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(B, c1);
const __m128i t1 = _mm_or_si128(t0, C);
const __m128i t2 = _mm_andnot_si128(A, t1);
return t2;

f(A, B, C) = (A notand ((B xor 1) or C))

const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t0 = _mm256_xor_si256(B, c1);
const __m256i t1 = _mm256_or_si256(t0, C);
const __m256i t2 = _mm256_andnot_si256(A, t1);
return t2;

f(A, B, C) = (A notand ((B xor 1) or C))

const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t0 = _mm512_xor_si512(B, c1);
const __m512i t1 = _mm512_or_si512(t0, C);
const __m512i t2 = _mm512_andnot_si512(A, t1);
return t2;

f(A, B, C) = (not (A) and not ((B and not (C))))

const uint64_t t0 = ~A;
const uint64_t t1 = ~C;
const uint64_t t2 = B & t1;
const uint64_t t3 = ~t2;
const uint64_t t4 = t0 & t3;
return t4;

f(A, B, C) = (not (A) and not ((B and not (C))))

const uint32_t t0 = ~A;
const uint32_t t1 = ~C;
const uint32_t t2 = B & t1;
const uint32_t t3 = ~t2;
const uint32_t t4 = t0 & t3;
return t4;

f(A, B, C) = (A notand ((B xor 1) or C))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(B, c1);
const __m128i t1 = _mm_or_si128(t0, C);
const __m128i t2 = _mm_andnot_si128(A, t1);
return t2;

f(A, B, C) = (A notand not ((B and not (C))))

const int32x4_t t0 = vmvnq_s32(C);
const int32x4_t t1 = vandq_s32(B, t0);
const int32x4_t t2 = vmvnq_s32(t1);
const int32x4_t t3 = vbicq_s32(t2, A);
return t3;

0x0c — (B and not (A))

f(A, B, C) = (A notand B)

const __m128i t0 = _mm_andnot_si128(A, B);
return t0;

f(A, B, C) = (A notand B)

const __m256i t0 = _mm256_andnot_si256(A, B);
return t0;

f(A, B, C) = (A notand B)

const __m512i t0 = _mm512_andnot_si512(A, B);
return t0;

f(A, B, C) = (B and not (A))

const uint64_t t0 = ~A;
const uint64_t t1 = B & t0;
return t1;

f(A, B, C) = (B and not (A))

const uint32_t t0 = ~A;
const uint32_t t1 = B & t0;
return t1;

f(A, B, C) = (A notand B)

const __m128i t0 = _mm_andnot_si128(A, B);
return t0;

f(A, B, C) = (A notand B)

const int32x4_t t0 = vbicq_s32(B, A);
return t0;

0x0d — (C ? (not (A) and B) : (A xor 1))

f(A, B, C) = (A notand (B or (C xor 1)))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(C, c1);
const __m128i t1 = _mm_or_si128(B, t0);
const __m128i t2 = _mm_andnot_si128(A, t1);
return t2;

f(A, B, C) = (A notand (B or (C xor 1)))

const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t0 = _mm256_xor_si256(C, c1);
const __m256i t1 = _mm256_or_si256(B, t0);
const __m256i t2 = _mm256_andnot_si256(A, t1);
return t2;

f(A, B, C) = (A notand (B or (C xor 1)))

const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t0 = _mm512_xor_si512(C, c1);
const __m512i t1 = _mm512_or_si512(B, t0);
const __m512i t2 = _mm512_andnot_si512(A, t1);
return t2;

f(A, B, C) = (not (A) and not ((not (B) and C)))

const uint64_t t0 = ~A;
const uint64_t t1 = ~B;
const uint64_t t2 = t1 & C;
const uint64_t t3 = ~t2;
const uint64_t t4 = t0 & t3;
return t4;

f(A, B, C) = (not (A) and not ((not (B) and C)))

const uint32_t t0 = ~A;
const uint32_t t1 = ~B;
const uint32_t t2 = t1 & C;
const uint32_t t3 = ~t2;
const uint32_t t4 = t0 & t3;
return t4;

f(A, B, C) = (A notand (B or (C xor 1)))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(C, c1);
const __m128i t1 = _mm_or_si128(B, t0);
const __m128i t2 = _mm_andnot_si128(A, t1);
return t2;

f(A, B, C) = (A notand not ((not (B) and C)))

const int32x4_t t0 = vmvnq_s32(B);
const int32x4_t t1 = vandq_s32(t0, C);
const int32x4_t t2 = vmvnq_s32(t1);
const int32x4_t t3 = vbicq_s32(t2, A);
return t3;

0x0e — (A ? 0 : (B or C))

f(A, B, C) = (A notand (B or C))

const __m128i t0 = _mm_or_si128(B, C);
const __m128i t1 = _mm_andnot_si128(A, t0);
return t1;

f(A, B, C) = (A notand (B or C))

const __m256i t0 = _mm256_or_si256(B, C);
const __m256i t1 = _mm256_andnot_si256(A, t0);
return t1;

f(A, B, C) = (A notand (B or C))

const __m512i t0 = _mm512_or_si512(B, C);
const __m512i t1 = _mm512_andnot_si512(A, t0);
return t1;

f(A, B, C) = (not (A) and (B or C))

const uint64_t t0 = ~A;
const uint64_t t1 = B | C;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = (not (A) and (B or C))

const uint32_t t0 = ~A;
const uint32_t t1 = B | C;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = (A notand (B or C))

const __m128i t0 = _mm_or_si128(B, C);
const __m128i t1 = _mm_andnot_si128(A, t0);
return t1;

f(A, B, C) = (A notand (B or C))

const int32x4_t t0 = vorrq_s32(B, C);
const int32x4_t t1 = vbicq_s32(t0, A);
return t1;

0x0f — not (A)

f(A, B, C) = (A xor 1)

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(A, c1);
return t0;

f(A, B, C) = (A xor 1)

const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t0 = _mm256_xor_si256(A, c1);
return t0;

f(A, B, C) = (A xor 1)

const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t0 = _mm512_xor_si512(A, c1);
return t0;

f(A, B, C) = not (A)

const uint64_t t0 = ~A;
return t0;

f(A, B, C) = not (A)

const uint32_t t0 = ~A;
return t0;

f(A, B, C) = (A xor 1)

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(A, c1);
return t0;

f(A, B, C) = not (A)

const int32x4_t t0 = vmvnq_s32(A);
return t0;

0x10 — (A and (B nor C))

f(A, B, C) = ((B or C) notand A)

const __m128i t0 = _mm_or_si128(B, C);
const __m128i t1 = _mm_andnot_si128(t0, A);
return t1;

f(A, B, C) = ((B or C) notand A)

const __m256i t0 = _mm256_or_si256(B, C);
const __m256i t1 = _mm256_andnot_si256(t0, A);
return t1;

f(A, B, C) = ((B or C) notand A)

const __m512i t0 = _mm512_or_si512(B, C);
const __m512i t1 = _mm512_andnot_si512(t0, A);
return t1;

f(A, B, C) = (A and not ((B or C)))

const uint64_t t0 = B | C;
const uint64_t t1 = ~t0;
const uint64_t t2 = A & t1;
return t2;

f(A, B, C) = (A and not ((B or C)))

const uint32_t t0 = B | C;
const uint32_t t1 = ~t0;
const uint32_t t2 = A & t1;
return t2;

f(A, B, C) = ((B or C) notand A)

const __m128i t0 = _mm_or_si128(B, C);
const __m128i t1 = _mm_andnot_si128(t0, A);
return t1;

f(A, B, C) = ((B or C) notand A)

const int32x4_t t0 = vorrq_s32(B, C);
const int32x4_t t1 = vbicq_s32(A, t0);
return t1;

0x11 — (C nor B)

f(A, B, C) = ((C or B) xor 1)

const __m128i t0 = _mm_or_si128(C, B);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(t0, c1);
return t1;

f(A, B, C) = ((C or B) xor 1)

const __m256i t0 = _mm256_or_si256(C, B);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(t0, c1);
return t1;

f(A, B, C) = ((C or B) xor 1)

const __m512i t0 = _mm512_or_si512(C, B);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(t0, c1);
return t1;

f(A, B, C) = not ((C or B))

const uint64_t t0 = C | B;
const uint64_t t1 = ~t0;
return t1;

f(A, B, C) = not ((C or B))

const uint32_t t0 = C | B;
const uint32_t t1 = ~t0;
return t1;

f(A, B, C) = ((C or B) xor 1)

const __m128i t0 = _mm_or_si128(C, B);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(t0, c1);
return t1;

f(A, B, C) = not ((C or B))

const int32x4_t t0 = vorrq_s32(C, B);
const int32x4_t t1 = vmvnq_s32(t0);
return t1;

0x12 — (B ? 0 : (A xor C))

f(A, B, C) = (B notand (A xor C))

const __m128i t0 = _mm_xor_si128(A, C);
const __m128i t1 = _mm_andnot_si128(B, t0);
return t1;

f(A, B, C) = (B notand (A xor C))

const __m256i t0 = _mm256_xor_si256(A, C);
const __m256i t1 = _mm256_andnot_si256(B, t0);
return t1;

f(A, B, C) = (B notand (A xor C))

const __m512i t0 = _mm512_xor_si512(A, C);
const __m512i t1 = _mm512_andnot_si512(B, t0);
return t1;

f(A, B, C) = (not (B) and (A xor C))

const uint64_t t0 = ~B;
const uint64_t t1 = A ^ C;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = (not (B) and (A xor C))

const uint32_t t0 = ~B;
const uint32_t t1 = A ^ C;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = (B notand (A xor C))

const __m128i t0 = _mm_xor_si128(A, C);
const __m128i t1 = _mm_andnot_si128(B, t0);
return t1;

f(A, B, C) = (B notand (A xor C))

const int32x4_t t0 = veorq_s32(A, C);
const int32x4_t t1 = vbicq_s32(t0, B);
return t1;

0x13 — (B nor (A and C))

f(A, B, C) = ((B or (A and C)) xor 1)

const __m128i t0 = _mm_and_si128(A, C);
const __m128i t1 = _mm_or_si128(B, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = ((B or (A and C)) xor 1)

const __m256i t0 = _mm256_and_si256(A, C);
const __m256i t1 = _mm256_or_si256(B, t0);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t2 = _mm256_xor_si256(t1, c1);
return t2;

f(A, B, C) = ((B or (A and C)) xor 1)

const __m512i t0 = _mm512_and_si512(A, C);
const __m512i t1 = _mm512_or_si512(B, t0);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t2 = _mm512_xor_si512(t1, c1);
return t2;

f(A, B, C) = not ((B or (A and C)))

const uint64_t t0 = A & C;
const uint64_t t1 = B | t0;
const uint64_t t2 = ~t1;
return t2;

f(A, B, C) = not ((B or (A and C)))

const uint32_t t0 = A & C;
const uint32_t t1 = B | t0;
const uint32_t t2 = ~t1;
return t2;

f(A, B, C) = ((B or (A and C)) xor 1)

const __m128i t0 = _mm_and_si128(A, C);
const __m128i t1 = _mm_or_si128(B, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = not ((B or (A and C)))

const int32x4_t t0 = vandq_s32(A, C);
const int32x4_t t1 = vorrq_s32(B, t0);
const int32x4_t t2 = vmvnq_s32(t1);
return t2;

0x14 — (C ? 0 : (A xor B))

f(A, B, C) = (C notand (A xor B))

const __m128i t0 = _mm_xor_si128(A, B);
const __m128i t1 = _mm_andnot_si128(C, t0);
return t1;

f(A, B, C) = (C notand (A xor B))

const __m256i t0 = _mm256_xor_si256(A, B);
const __m256i t1 = _mm256_andnot_si256(C, t0);
return t1;

f(A, B, C) = (C notand (A xor B))

const __m512i t0 = _mm512_xor_si512(A, B);
const __m512i t1 = _mm512_andnot_si512(C, t0);
return t1;

f(A, B, C) = (not (C) and (A xor B))

const uint64_t t0 = ~C;
const uint64_t t1 = A ^ B;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = (not (C) and (A xor B))

const uint32_t t0 = ~C;
const uint32_t t1 = A ^ B;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = (C notand (A xor B))

const __m128i t0 = _mm_xor_si128(A, B);
const __m128i t1 = _mm_andnot_si128(C, t0);
return t1;

f(A, B, C) = (C notand (A xor B))

const int32x4_t t0 = veorq_s32(A, B);
const int32x4_t t1 = vbicq_s32(t0, C);
return t1;

0x15 — (C nor (B and A))

f(A, B, C) = ((C or (B and A)) xor 1)

const __m128i t0 = _mm_and_si128(B, A);
const __m128i t1 = _mm_or_si128(C, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = ((C or (B and A)) xor 1)

const __m256i t0 = _mm256_and_si256(B, A);
const __m256i t1 = _mm256_or_si256(C, t0);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t2 = _mm256_xor_si256(t1, c1);
return t2;

f(A, B, C) = ((C or (B and A)) xor 1)

const __m512i t0 = _mm512_and_si512(B, A);
const __m512i t1 = _mm512_or_si512(C, t0);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t2 = _mm512_xor_si512(t1, c1);
return t2;

f(A, B, C) = not ((C or (B and A)))

const uint64_t t0 = B & A;
const uint64_t t1 = C | t0;
const uint64_t t2 = ~t1;
return t2;

f(A, B, C) = not ((C or (B and A)))

const uint32_t t0 = B & A;
const uint32_t t1 = C | t0;
const uint32_t t2 = ~t1;
return t2;

f(A, B, C) = ((C or (B and A)) xor 1)

const __m128i t0 = _mm_and_si128(B, A);
const __m128i t1 = _mm_or_si128(C, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = not ((C or (B and A)))

const int32x4_t t0 = vandq_s32(B, A);
const int32x4_t t1 = vorrq_s32(C, t0);
const int32x4_t t2 = vmvnq_s32(t1);
return t2;

0x16 — (A ? (not (C) and (A xor B)) : (B xor C))

f(A, B, C) = (((B or C) notand A) or (A notand (B xor C)))

const __m128i t0 = _mm_or_si128(B, C);
const __m128i t1 = _mm_andnot_si128(t0, A);
const __m128i t2 = _mm_xor_si128(B, C);
const __m128i t3 = _mm_andnot_si128(A, t2);
const __m128i t4 = _mm_or_si128(t1, t3);
return t4;

f(A, B, C) = (((B or C) notand A) or (A notand (B xor C)))

const __m256i t0 = _mm256_or_si256(B, C);
const __m256i t1 = _mm256_andnot_si256(t0, A);
const __m256i t2 = _mm256_xor_si256(B, C);
const __m256i t3 = _mm256_andnot_si256(A, t2);
const __m256i t4 = _mm256_or_si256(t1, t3);
return t4;

f(A, B, C) = (((B or C) notand A) or (A notand (B xor C)))

const __m512i t0 = _mm512_or_si512(B, C);
const __m512i t1 = _mm512_andnot_si512(t0, A);
const __m512i t2 = _mm512_xor_si512(B, C);
const __m512i t3 = _mm512_andnot_si512(A, t2);
const __m512i t4 = _mm512_or_si512(t1, t3);
return t4;

f(A, B, C) = ((A and not ((B or C))) or (not (A) and (B xor C)))

const uint64_t t0 = B | C;
const uint64_t t1 = ~t0;
const uint64_t t2 = A & t1;
const uint64_t t3 = ~A;
const uint64_t t4 = B ^ C;
const uint64_t t5 = t3 & t4;
const uint64_t t6 = t2 | t5;
return t6;

f(A, B, C) = ((A and not ((B or C))) or (not (A) and (B xor C)))

const uint32_t t0 = B | C;
const uint32_t t1 = ~t0;
const uint32_t t2 = A & t1;
const uint32_t t3 = ~A;
const uint32_t t4 = B ^ C;
const uint32_t t5 = t3 & t4;
const uint32_t t6 = t2 | t5;
return t6;

f(A, B, C) = (A ? (C notand (A xor B)) : (B xor C))

const __m128i t0 = _mm_xor_si128(A, B);
const __m128i t1 = _mm_andnot_si128(C, t0);
const __m128i t2 = _mm_xor_si128(B, C);
const __m128i t3 = _mm_cmov_si128(t1, t2, A);
return t3;

f(A, B, C) = (((B or C) notand A) or (A notand (B xor C)))

const int32x4_t t0 = vorrq_s32(B, C);
const int32x4_t t1 = vbicq_s32(A, t0);
const int32x4_t t2 = veorq_s32(B, C);
const int32x4_t t3 = vbicq_s32(t2, A);
const int32x4_t t4 = vorrq_s32(t1, t3);
return t4;

0x17 — ((B nor C) or (not (A) and (B xor C)))

f(A, B, C) = (((B or C) xor 1) or (A notand (B xor C)))

const __m128i t0 = _mm_or_si128(B, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(t0, c1);
const __m128i t2 = _mm_xor_si128(B, C);
const __m128i t3 = _mm_andnot_si128(A, t2);
const __m128i t4 = _mm_or_si128(t1, t3);
return t4;

f(A, B, C) = (((B or C) xor 1) or (A notand (B xor C)))

const __m256i t0 = _mm256_or_si256(B, C);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(t0, c1);
const __m256i t2 = _mm256_xor_si256(B, C);
const __m256i t3 = _mm256_andnot_si256(A, t2);
const __m256i t4 = _mm256_or_si256(t1, t3);
return t4;

f(A, B, C) = (((B or C) xor 1) or (A notand (B xor C)))

const __m512i t0 = _mm512_or_si512(B, C);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(t0, c1);
const __m512i t2 = _mm512_xor_si512(B, C);
const __m512i t3 = _mm512_andnot_si512(A, t2);
const __m512i t4 = _mm512_or_si512(t1, t3);
return t4;

f(A, B, C) = not ((A ? (B or C) : (B and C)))

const uint64_t t0 = B | C;
const uint64_t t1 = B & C;
const uint64_t t2 = (A & t0) | (~A & t1);
const uint64_t t3 = ~t2;
return t3;

f(A, B, C) = not ((A ? (B or C) : (B and C)))

const uint32_t t0 = B | C;
const uint32_t t1 = B & C;
const uint32_t t2 = (A & t0) | (~A & t1);
const uint32_t t3 = ~t2;
return t3;

f(A, B, C) = ((A ? (B or C) : (B and C)) xor 1)

const __m128i t0 = _mm_or_si128(B, C);
const __m128i t1 = _mm_and_si128(B, C);
const __m128i t2 = _mm_cmov_si128(t0, t1, A);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t3 = _mm_xor_si128(t2, c1);
return t3;

f(A, B, C) = ((B or C) notor (A notand (B xor C)))

const int32x4_t t0 = vorrq_s32(B, C);
const int32x4_t t1 = veorq_s32(B, C);
const int32x4_t t2 = vbicq_s32(t1, A);
const int32x4_t t3 = vornq_s32(t2, t0);
return t3;

0x18 — (B ? (not (A) and C) : (not (C) and A))

f(A, B, C) = ((A xor B) and (A xor C))

const __m128i t0 = _mm_xor_si128(A, B);
const __m128i t1 = _mm_xor_si128(A, C);
const __m128i t2 = _mm_and_si128(t0, t1);
return t2;

f(A, B, C) = ((A xor B) and (A xor C))

const __m256i t0 = _mm256_xor_si256(A, B);
const __m256i t1 = _mm256_xor_si256(A, C);
const __m256i t2 = _mm256_and_si256(t0, t1);
return t2;

f(A, B, C) = ((A xor B) and (A xor C))

const __m512i t0 = _mm512_xor_si512(A, B);
const __m512i t1 = _mm512_xor_si512(A, C);
const __m512i t2 = _mm512_and_si512(t0, t1);
return t2;

f(A, B, C) = ((A xor B) and (A xor C))

const uint64_t t0 = A ^ B;
const uint64_t t1 = A ^ C;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = ((A xor B) and (A xor C))

const uint32_t t0 = A ^ B;
const uint32_t t1 = A ^ C;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = ((A xor B) and (A xor C))

const __m128i t0 = _mm_xor_si128(A, B);
const __m128i t1 = _mm_xor_si128(A, C);
const __m128i t2 = _mm_and_si128(t0, t1);
return t2;

f(A, B, C) = ((A xor B) and (A xor C))

const int32x4_t t0 = veorq_s32(A, B);
const int32x4_t t1 = veorq_s32(A, C);
const int32x4_t t2 = vandq_s32(t0, t1);
return t2;

0x19 — (B ? (not (A) and C) : (C xor 1))

f(A, B, C) = ((A and B) notand (B xor (C xor 1)))

const __m128i t0 = _mm_and_si128(A, B);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(C, c1);
const __m128i t2 = _mm_xor_si128(B, t1);
const __m128i t3 = _mm_andnot_si128(t0, t2);
return t3;

f(A, B, C) = ((A and B) notand (B xor (C xor 1)))

const __m256i t0 = _mm256_and_si256(A, B);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(C, c1);
const __m256i t2 = _mm256_xor_si256(B, t1);
const __m256i t3 = _mm256_andnot_si256(t0, t2);
return t3;

f(A, B, C) = ((A and B) notand (B xor (C xor 1)))

const __m512i t0 = _mm512_and_si512(A, B);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(C, c1);
const __m512i t2 = _mm512_xor_si512(B, t1);
const __m512i t3 = _mm512_andnot_si512(t0, t2);
return t3;

f(A, B, C) = not (((B xor C) xor (A and (B and C))))

const uint64_t t0 = B ^ C;
const uint64_t t1 = B & C;
const uint64_t t2 = A & t1;
const uint64_t t3 = t0 ^ t2;
const uint64_t t4 = ~t3;
return t4;

f(A, B, C) = not (((B xor C) xor (A and (B and C))))

const uint32_t t0 = B ^ C;
const uint32_t t1 = B & C;
const uint32_t t2 = A & t1;
const uint32_t t3 = t0 ^ t2;
const uint32_t t4 = ~t3;
return t4;

f(A, B, C) = (B ? (A notand C) : (C xor 1))

const __m128i t0 = _mm_andnot_si128(A, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(C, c1);
const __m128i t2 = _mm_cmov_si128(t0, t1, B);
return t2;

f(A, B, C) = not (((B xor C) xor (A and (B and C))))

const int32x4_t t0 = veorq_s32(B, C);
const int32x4_t t1 = vandq_s32(B, C);
const int32x4_t t2 = vandq_s32(A, t1);
const int32x4_t t3 = veorq_s32(t0, t2);
const int32x4_t t4 = vmvnq_s32(t3);
return t4;

0x1a — (A ? (not (C) and (A xor B)) : C)

f(A, B, C) = ((A and B) notand (A xor C))

const __m128i t0 = _mm_and_si128(A, B);
const __m128i t1 = _mm_xor_si128(A, C);
const __m128i t2 = _mm_andnot_si128(t0, t1);
return t2;

f(A, B, C) = ((A and B) notand (A xor C))

const __m256i t0 = _mm256_and_si256(A, B);
const __m256i t1 = _mm256_xor_si256(A, C);
const __m256i t2 = _mm256_andnot_si256(t0, t1);
return t2;

f(A, B, C) = ((A and B) notand (A xor C))

const __m512i t0 = _mm512_and_si512(A, B);
const __m512i t1 = _mm512_xor_si512(A, C);
const __m512i t2 = _mm512_andnot_si512(t0, t1);
return t2;

f(A, B, C) = (not ((A and B)) and (A xor C))

const uint64_t t0 = A & B;
const uint64_t t1 = ~t0;
const uint64_t t2 = A ^ C;
const uint64_t t3 = t1 & t2;
return t3;

f(A, B, C) = (not ((A and B)) and (A xor C))

const uint32_t t0 = A & B;
const uint32_t t1 = ~t0;
const uint32_t t2 = A ^ C;
const uint32_t t3 = t1 & t2;
return t3;

f(A, B, C) = ((A and B) notand (A xor C))

const __m128i t0 = _mm_and_si128(A, B);
const __m128i t1 = _mm_xor_si128(A, C);
const __m128i t2 = _mm_andnot_si128(t0, t1);
return t2;

f(A, B, C) = ((A and B) notand (A xor C))

const int32x4_t t0 = vandq_s32(A, B);
const int32x4_t t1 = veorq_s32(A, C);
const int32x4_t t2 = vbicq_s32(t1, t0);
return t2;

0x1b — (C ? not (A) : not (B))

f(A, B, C) = ((A notand C) or (C notand (B xor 1)))

const __m128i t0 = _mm_andnot_si128(A, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(B, c1);
const __m128i t2 = _mm_andnot_si128(C, t1);
const __m128i t3 = _mm_or_si128(t0, t2);
return t3;

f(A, B, C) = ((A notand C) or (C notand (B xor 1)))

const __m256i t0 = _mm256_andnot_si256(A, C);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(B, c1);
const __m256i t2 = _mm256_andnot_si256(C, t1);
const __m256i t3 = _mm256_or_si256(t0, t2);
return t3;

f(A, B, C) = ((A notand C) or (C notand (B xor 1)))

const __m512i t0 = _mm512_andnot_si512(A, C);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(B, c1);
const __m512i t2 = _mm512_andnot_si512(C, t1);
const __m512i t3 = _mm512_or_si512(t0, t2);
return t3;

f(A, B, C) = ((C and not (A)) or (not (C) and not (B)))

const uint64_t t0 = ~A;
const uint64_t t1 = C & t0;
const uint64_t t2 = ~C;
const uint64_t t3 = ~B;
const uint64_t t4 = t2 & t3;
const uint64_t t5 = t1 | t4;
return t5;

f(A, B, C) = ((C and not (A)) or (not (C) and not (B)))

const uint32_t t0 = ~A;
const uint32_t t1 = C & t0;
const uint32_t t2 = ~C;
const uint32_t t3 = ~B;
const uint32_t t4 = t2 & t3;
const uint32_t t5 = t1 | t4;
return t5;

f(A, B, C) = (C ? (A xor 1) : (B xor 1))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(A, c1);
const __m128i t1 = _mm_xor_si128(B, c1);
const __m128i t2 = _mm_cmov_si128(t0, t1, C);
return t2;

f(A, B, C) = ((A notand C) or (C notand not (B)))

const int32x4_t t0 = vbicq_s32(C, A);
const int32x4_t t1 = vmvnq_s32(B);
const int32x4_t t2 = vbicq_s32(t1, C);
const int32x4_t t3 = vorrq_s32(t0, t2);
return t3;

0x1c — (A ? (not (C) and (A xor B)) : B)

f(A, B, C) = ((A and C) notand (A xor B))

const __m128i t0 = _mm_and_si128(A, C);
const __m128i t1 = _mm_xor_si128(A, B);
const __m128i t2 = _mm_andnot_si128(t0, t1);
return t2;

f(A, B, C) = ((A and C) notand (A xor B))

const __m256i t0 = _mm256_and_si256(A, C);
const __m256i t1 = _mm256_xor_si256(A, B);
const __m256i t2 = _mm256_andnot_si256(t0, t1);
return t2;

f(A, B, C) = ((A and C) notand (A xor B))

const __m512i t0 = _mm512_and_si512(A, C);
const __m512i t1 = _mm512_xor_si512(A, B);
const __m512i t2 = _mm512_andnot_si512(t0, t1);
return t2;

f(A, B, C) = (not ((A and C)) and (A xor B))

const uint64_t t0 = A & C;
const uint64_t t1 = ~t0;
const uint64_t t2 = A ^ B;
const uint64_t t3 = t1 & t2;
return t3;

f(A, B, C) = (not ((A and C)) and (A xor B))

const uint32_t t0 = A & C;
const uint32_t t1 = ~t0;
const uint32_t t2 = A ^ B;
const uint32_t t3 = t1 & t2;
return t3;

f(A, B, C) = ((A and C) notand (A xor B))

const __m128i t0 = _mm_and_si128(A, C);
const __m128i t1 = _mm_xor_si128(A, B);
const __m128i t2 = _mm_andnot_si128(t0, t1);
return t2;

f(A, B, C) = ((A and C) notand (A xor B))

const int32x4_t t0 = vandq_s32(A, C);
const int32x4_t t1 = veorq_s32(A, B);
const int32x4_t t2 = vbicq_s32(t1, t0);
return t2;

0x1d — (B ? not (A) : not (C))

f(A, B, C) = ((A notand B) or (B notand (C xor 1)))

const __m128i t0 = _mm_andnot_si128(A, B);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(C, c1);
const __m128i t2 = _mm_andnot_si128(B, t1);
const __m128i t3 = _mm_or_si128(t0, t2);
return t3;

f(A, B, C) = ((A notand B) or (B notand (C xor 1)))

const __m256i t0 = _mm256_andnot_si256(A, B);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(C, c1);
const __m256i t2 = _mm256_andnot_si256(B, t1);
const __m256i t3 = _mm256_or_si256(t0, t2);
return t3;

f(A, B, C) = ((A notand B) or (B notand (C xor 1)))

const __m512i t0 = _mm512_andnot_si512(A, B);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(C, c1);
const __m512i t2 = _mm512_andnot_si512(B, t1);
const __m512i t3 = _mm512_or_si512(t0, t2);
return t3;

f(A, B, C) = ((B and not (A)) or (not (B) and not (C)))

const uint64_t t0 = ~A;
const uint64_t t1 = B & t0;
const uint64_t t2 = ~B;
const uint64_t t3 = ~C;
const uint64_t t4 = t2 & t3;
const uint64_t t5 = t1 | t4;
return t5;

f(A, B, C) = ((B and not (A)) or (not (B) and not (C)))

const uint32_t t0 = ~A;
const uint32_t t1 = B & t0;
const uint32_t t2 = ~B;
const uint32_t t3 = ~C;
const uint32_t t4 = t2 & t3;
const uint32_t t5 = t1 | t4;
return t5;

f(A, B, C) = (B ? (A xor 1) : (C xor 1))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(A, c1);
const __m128i t1 = _mm_xor_si128(C, c1);
const __m128i t2 = _mm_cmov_si128(t0, t1, B);
return t2;

f(A, B, C) = ((A notand B) or (B notand not (C)))

const int32x4_t t0 = vbicq_s32(B, A);
const int32x4_t t1 = vmvnq_s32(C);
const int32x4_t t2 = vbicq_s32(t1, B);
const int32x4_t t3 = vorrq_s32(t0, t2);
return t3;

0x1e — (A xor (B or C))

f(A, B, C) = (A xor (B or C))

const __m128i t0 = _mm_or_si128(B, C);
const __m128i t1 = _mm_xor_si128(A, t0);
return t1;

f(A, B, C) = (A xor (B or C))

const __m256i t0 = _mm256_or_si256(B, C);
const __m256i t1 = _mm256_xor_si256(A, t0);
return t1;

f(A, B, C) = (A xor (B or C))

const __m512i t0 = _mm512_or_si512(B, C);
const __m512i t1 = _mm512_xor_si512(A, t0);
return t1;

f(A, B, C) = (A xor (B or C))

const uint64_t t0 = B | C;
const uint64_t t1 = A ^ t0;
return t1;

f(A, B, C) = (A xor (B or C))

const uint32_t t0 = B | C;
const uint32_t t1 = A ^ t0;
return t1;

f(A, B, C) = (A xor (B or C))

const __m128i t0 = _mm_or_si128(B, C);
const __m128i t1 = _mm_xor_si128(A, t0);
return t1;

f(A, B, C) = (A xor (B or C))

const int32x4_t t0 = vorrq_s32(B, C);
const int32x4_t t1 = veorq_s32(A, t0);
return t1;

0x1f — (A nand (B or C))

f(A, B, C) = ((A and (B or C)) xor 1)

const __m128i t0 = _mm_or_si128(B, C);
const __m128i t1 = _mm_and_si128(A, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = ((A and (B or C)) xor 1)

const __m256i t0 = _mm256_or_si256(B, C);
const __m256i t1 = _mm256_and_si256(A, t0);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t2 = _mm256_xor_si256(t1, c1);
return t2;

f(A, B, C) = ((A and (B or C)) xor 1)

const __m512i t0 = _mm512_or_si512(B, C);
const __m512i t1 = _mm512_and_si512(A, t0);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t2 = _mm512_xor_si512(t1, c1);
return t2;

f(A, B, C) = not ((A and (B or C)))

const uint64_t t0 = B | C;
const uint64_t t1 = A & t0;
const uint64_t t2 = ~t1;
return t2;

f(A, B, C) = not ((A and (B or C)))

const uint32_t t0 = B | C;
const uint32_t t1 = A & t0;
const uint32_t t2 = ~t1;
return t2;

f(A, B, C) = ((A and (B or C)) xor 1)

const __m128i t0 = _mm_or_si128(B, C);
const __m128i t1 = _mm_and_si128(A, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = not ((A and (B or C)))

const int32x4_t t0 = vorrq_s32(B, C);
const int32x4_t t1 = vandq_s32(A, t0);
const int32x4_t t2 = vmvnq_s32(t1);
return t2;

0x20 — (A ? (not (B) and C) : A)

f(A, B, C) = (A and (B notand C))

const __m128i t0 = _mm_andnot_si128(B, C);
const __m128i t1 = _mm_and_si128(A, t0);
return t1;

f(A, B, C) = (A and (B notand C))

const __m256i t0 = _mm256_andnot_si256(B, C);
const __m256i t1 = _mm256_and_si256(A, t0);
return t1;

f(A, B, C) = (A and (B notand C))

const __m512i t0 = _mm512_andnot_si512(B, C);
const __m512i t1 = _mm512_and_si512(A, t0);
return t1;

f(A, B, C) = (A and (not (B) and C))

const uint64_t t0 = ~B;
const uint64_t t1 = t0 & C;
const uint64_t t2 = A & t1;
return t2;

f(A, B, C) = (A and (not (B) and C))

const uint32_t t0 = ~B;
const uint32_t t1 = t0 & C;
const uint32_t t2 = A & t1;
return t2;

f(A, B, C) = (A and (B notand C))

const __m128i t0 = _mm_andnot_si128(B, C);
const __m128i t1 = _mm_and_si128(A, t0);
return t1;

f(A, B, C) = (A and (B notand C))

const int32x4_t t0 = vbicq_s32(C, B);
const int32x4_t t1 = vandq_s32(A, t0);
return t1;

0x21 — (B nor (A xor C))

f(A, B, C) = ((B or (A xor C)) xor 1)

const __m128i t0 = _mm_xor_si128(A, C);
const __m128i t1 = _mm_or_si128(B, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = ((B or (A xor C)) xor 1)

const __m256i t0 = _mm256_xor_si256(A, C);
const __m256i t1 = _mm256_or_si256(B, t0);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t2 = _mm256_xor_si256(t1, c1);
return t2;

f(A, B, C) = ((B or (A xor C)) xor 1)

const __m512i t0 = _mm512_xor_si512(A, C);
const __m512i t1 = _mm512_or_si512(B, t0);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t2 = _mm512_xor_si512(t1, c1);
return t2;

f(A, B, C) = not ((B or (A xor C)))

const uint64_t t0 = A ^ C;
const uint64_t t1 = B | t0;
const uint64_t t2 = ~t1;
return t2;

f(A, B, C) = not ((B or (A xor C)))

const uint32_t t0 = A ^ C;
const uint32_t t1 = B | t0;
const uint32_t t2 = ~t1;
return t2;

f(A, B, C) = ((B or (A xor C)) xor 1)

const __m128i t0 = _mm_xor_si128(A, C);
const __m128i t1 = _mm_or_si128(B, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = not ((B or (A xor C)))

const int32x4_t t0 = veorq_s32(A, C);
const int32x4_t t1 = vorrq_s32(B, t0);
const int32x4_t t2 = vmvnq_s32(t1);
return t2;

0x22 — (C and not (B))

f(A, B, C) = (B notand C)

const __m128i t0 = _mm_andnot_si128(B, C);
return t0;

f(A, B, C) = (B notand C)

const __m256i t0 = _mm256_andnot_si256(B, C);
return t0;

f(A, B, C) = (B notand C)

const __m512i t0 = _mm512_andnot_si512(B, C);
return t0;

f(A, B, C) = (C and not (B))

const uint64_t t0 = ~B;
const uint64_t t1 = C & t0;
return t1;

f(A, B, C) = (C and not (B))

const uint32_t t0 = ~B;
const uint32_t t1 = C & t0;
return t1;

f(A, B, C) = (B notand C)

const __m128i t0 = _mm_andnot_si128(B, C);
return t0;

f(A, B, C) = (B notand C)

const int32x4_t t0 = vbicq_s32(C, B);
return t0;

0x23 — (A ? (not (B) and C) : (B xor 1))

f(A, B, C) = (B notand ((A xor 1) or C))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(A, c1);
const __m128i t1 = _mm_or_si128(t0, C);
const __m128i t2 = _mm_andnot_si128(B, t1);
return t2;

f(A, B, C) = (B notand ((A xor 1) or C))

const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t0 = _mm256_xor_si256(A, c1);
const __m256i t1 = _mm256_or_si256(t0, C);
const __m256i t2 = _mm256_andnot_si256(B, t1);
return t2;

f(A, B, C) = (B notand ((A xor 1) or C))

const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t0 = _mm512_xor_si512(A, c1);
const __m512i t1 = _mm512_or_si512(t0, C);
const __m512i t2 = _mm512_andnot_si512(B, t1);
return t2;

f(A, B, C) = (not (B) and (not (A) or (A and C)))

const uint64_t t0 = ~B;
const uint64_t t1 = ~A;
const uint64_t t2 = A & C;
const uint64_t t3 = t1 | t2;
const uint64_t t4 = t0 & t3;
return t4;

f(A, B, C) = (not (B) and (not (A) or (A and C)))

const uint32_t t0 = ~B;
const uint32_t t1 = ~A;
const uint32_t t2 = A & C;
const uint32_t t3 = t1 | t2;
const uint32_t t4 = t0 & t3;
return t4;

f(A, B, C) = (B notand ((A xor 1) or C))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(A, c1);
const __m128i t1 = _mm_or_si128(t0, C);
const __m128i t2 = _mm_andnot_si128(B, t1);
return t2;

f(A, B, C) = (B notand (A notor (A and C)))

const int32x4_t t0 = vandq_s32(A, C);
const int32x4_t t1 = vornq_s32(t0, A);
const int32x4_t t2 = vbicq_s32(t1, B);
return t2;

0x24 — (A ? (not (B) and C) : (not (C) and B))

f(A, B, C) = ((B xor C) and (A xor B))

const __m128i t0 = _mm_xor_si128(B, C);
const __m128i t1 = _mm_xor_si128(A, B);
const __m128i t2 = _mm_and_si128(t0, t1);
return t2;

f(A, B, C) = ((B xor C) and (A xor B))

const __m256i t0 = _mm256_xor_si256(B, C);
const __m256i t1 = _mm256_xor_si256(A, B);
const __m256i t2 = _mm256_and_si256(t0, t1);
return t2;

f(A, B, C) = ((B xor C) and (A xor B))

const __m512i t0 = _mm512_xor_si512(B, C);
const __m512i t1 = _mm512_xor_si512(A, B);
const __m512i t2 = _mm512_and_si512(t0, t1);
return t2;

f(A, B, C) = ((B xor C) and (A xor B))

const uint64_t t0 = B ^ C;
const uint64_t t1 = A ^ B;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = ((B xor C) and (A xor B))

const uint32_t t0 = B ^ C;
const uint32_t t1 = A ^ B;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = ((B xor C) and (A xor B))

const __m128i t0 = _mm_xor_si128(B, C);
const __m128i t1 = _mm_xor_si128(A, B);
const __m128i t2 = _mm_and_si128(t0, t1);
return t2;

f(A, B, C) = ((B xor C) and (A xor B))

const int32x4_t t0 = veorq_s32(B, C);
const int32x4_t t1 = veorq_s32(A, B);
const int32x4_t t2 = vandq_s32(t0, t1);
return t2;

0x25 — (A ? (not (B) and C) : (C xor 1))

f(A, B, C) = ((A and B) notand (A xor (C xor 1)))

const __m128i t0 = _mm_and_si128(A, B);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(C, c1);
const __m128i t2 = _mm_xor_si128(A, t1);
const __m128i t3 = _mm_andnot_si128(t0, t2);
return t3;

f(A, B, C) = ((A and B) notand (A xor (C xor 1)))

const __m256i t0 = _mm256_and_si256(A, B);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(C, c1);
const __m256i t2 = _mm256_xor_si256(A, t1);
const __m256i t3 = _mm256_andnot_si256(t0, t2);
return t3;

f(A, B, C) = ((A and B) notand (A xor (C xor 1)))

const __m512i t0 = _mm512_and_si512(A, B);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(C, c1);
const __m512i t2 = _mm512_xor_si512(A, t1);
const __m512i t3 = _mm512_andnot_si512(t0, t2);
return t3;

f(A, B, C) = (not ((A and B)) and (A xor (C xor 1)))

const uint64_t t0 = A & B;
const uint64_t t1 = ~t0;
const uint64_t c1 = uint64_t(-1);
const uint64_t t2 = C ^ c1;
const uint64_t t3 = A ^ t2;
const uint64_t t4 = t1 & t3;
return t4;

f(A, B, C) = (not ((A and B)) and (A xor (C xor 1)))

const uint32_t t0 = A & B;
const uint32_t t1 = ~t0;
const uint32_t c1 = uint32_t(-1);
const uint32_t t2 = C ^ c1;
const uint32_t t3 = A ^ t2;
const uint32_t t4 = t1 & t3;
return t4;

f(A, B, C) = (A ? (B notand C) : (C xor 1))

const __m128i t0 = _mm_andnot_si128(B, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(C, c1);
const __m128i t2 = _mm_cmov_si128(t0, t1, A);
return t2;

f(A, B, C) = ((A and (B notand C)) or (A notand not (C)))

const int32x4_t t0 = vbicq_s32(C, B);
const int32x4_t t1 = vandq_s32(A, t0);
const int32x4_t t2 = vmvnq_s32(C);
const int32x4_t t3 = vbicq_s32(t2, A);
const int32x4_t t4 = vorrq_s32(t1, t3);
return t4;

0x26 — (A ? (not (B) and C) : (B xor C))

f(A, B, C) = ((A and B) notand (B xor C))

const __m128i t0 = _mm_and_si128(A, B);
const __m128i t1 = _mm_xor_si128(B, C);
const __m128i t2 = _mm_andnot_si128(t0, t1);
return t2;

f(A, B, C) = ((A and B) notand (B xor C))

const __m256i t0 = _mm256_and_si256(A, B);
const __m256i t1 = _mm256_xor_si256(B, C);
const __m256i t2 = _mm256_andnot_si256(t0, t1);
return t2;

f(A, B, C) = ((A and B) notand (B xor C))

const __m512i t0 = _mm512_and_si512(A, B);
const __m512i t1 = _mm512_xor_si512(B, C);
const __m512i t2 = _mm512_andnot_si512(t0, t1);
return t2;

f(A, B, C) = (not ((A and B)) and (B xor C))

const uint64_t t0 = A & B;
const uint64_t t1 = ~t0;
const uint64_t t2 = B ^ C;
const uint64_t t3 = t1 & t2;
return t3;

f(A, B, C) = (not ((A and B)) and (B xor C))

const uint32_t t0 = A & B;
const uint32_t t1 = ~t0;
const uint32_t t2 = B ^ C;
const uint32_t t3 = t1 & t2;
return t3;

f(A, B, C) = ((A and B) notand (B xor C))

const __m128i t0 = _mm_and_si128(A, B);
const __m128i t1 = _mm_xor_si128(B, C);
const __m128i t2 = _mm_andnot_si128(t0, t1);
return t2;

f(A, B, C) = ((A and B) notand (B xor C))

const int32x4_t t0 = vandq_s32(A, B);
const int32x4_t t1 = veorq_s32(B, C);
const int32x4_t t2 = vbicq_s32(t1, t0);
return t2;

0x27 — (C ? not (B) : not (A))

f(A, B, C) = ((B notand C) or (C notand (A xor 1)))

const __m128i t0 = _mm_andnot_si128(B, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(A, c1);
const __m128i t2 = _mm_andnot_si128(C, t1);
const __m128i t3 = _mm_or_si128(t0, t2);
return t3;

f(A, B, C) = ((B notand C) or (C notand (A xor 1)))

const __m256i t0 = _mm256_andnot_si256(B, C);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(A, c1);
const __m256i t2 = _mm256_andnot_si256(C, t1);
const __m256i t3 = _mm256_or_si256(t0, t2);
return t3;

f(A, B, C) = ((B notand C) or (C notand (A xor 1)))

const __m512i t0 = _mm512_andnot_si512(B, C);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(A, c1);
const __m512i t2 = _mm512_andnot_si512(C, t1);
const __m512i t3 = _mm512_or_si512(t0, t2);
return t3;

f(A, B, C) = ((C and not (B)) or (not (C) and not (A)))

const uint64_t t0 = ~B;
const uint64_t t1 = C & t0;
const uint64_t t2 = ~C;
const uint64_t t3 = ~A;
const uint64_t t4 = t2 & t3;
const uint64_t t5 = t1 | t4;
return t5;

f(A, B, C) = ((C and not (B)) or (not (C) and not (A)))

const uint32_t t0 = ~B;
const uint32_t t1 = C & t0;
const uint32_t t2 = ~C;
const uint32_t t3 = ~A;
const uint32_t t4 = t2 & t3;
const uint32_t t5 = t1 | t4;
return t5;

f(A, B, C) = (C ? (B xor 1) : (A xor 1))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(B, c1);
const __m128i t1 = _mm_xor_si128(A, c1);
const __m128i t2 = _mm_cmov_si128(t0, t1, C);
return t2;

f(A, B, C) = ((B notand C) or (C notand not (A)))

const int32x4_t t0 = vbicq_s32(C, B);
const int32x4_t t1 = vmvnq_s32(A);
const int32x4_t t2 = vbicq_s32(t1, C);
const int32x4_t t3 = vorrq_s32(t0, t2);
return t3;

0x28 — (C and (B xor A))

f(A, B, C) = (C and (B xor A))

const __m128i t0 = _mm_xor_si128(B, A);
const __m128i t1 = _mm_and_si128(C, t0);
return t1;

f(A, B, C) = (C and (B xor A))

const __m256i t0 = _mm256_xor_si256(B, A);
const __m256i t1 = _mm256_and_si256(C, t0);
return t1;

f(A, B, C) = (C and (B xor A))

const __m512i t0 = _mm512_xor_si512(B, A);
const __m512i t1 = _mm512_and_si512(C, t0);
return t1;

f(A, B, C) = (C and (B xor A))

const uint64_t t0 = B ^ A;
const uint64_t t1 = C & t0;
return t1;

f(A, B, C) = (C and (B xor A))

const uint32_t t0 = B ^ A;
const uint32_t t1 = C & t0;
return t1;

f(A, B, C) = (C and (B xor A))

const __m128i t0 = _mm_xor_si128(B, A);
const __m128i t1 = _mm_and_si128(C, t0);
return t1;

f(A, B, C) = (C and (B xor A))

const int32x4_t t0 = veorq_s32(B, A);
const int32x4_t t1 = vandq_s32(C, t0);
return t1;

0x29 — (C ? (B xor A) : (B nor A))

f(A, B, C) = ((C and (B xor A)) or (C notand ((B or A) xor 1)))

const __m128i t0 = _mm_xor_si128(B, A);
const __m128i t1 = _mm_and_si128(C, t0);
const __m128i t2 = _mm_or_si128(B, A);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t3 = _mm_xor_si128(t2, c1);
const __m128i t4 = _mm_andnot_si128(C, t3);
const __m128i t5 = _mm_or_si128(t1, t4);
return t5;

f(A, B, C) = ((C and (B xor A)) or (C notand ((B or A) xor 1)))

const __m256i t0 = _mm256_xor_si256(B, A);
const __m256i t1 = _mm256_and_si256(C, t0);
const __m256i t2 = _mm256_or_si256(B, A);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t3 = _mm256_xor_si256(t2, c1);
const __m256i t4 = _mm256_andnot_si256(C, t3);
const __m256i t5 = _mm256_or_si256(t1, t4);
return t5;

f(A, B, C) = ((C and (B xor A)) or (C notand ((B or A) xor 1)))

const __m512i t0 = _mm512_xor_si512(B, A);
const __m512i t1 = _mm512_and_si512(C, t0);
const __m512i t2 = _mm512_or_si512(B, A);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t3 = _mm512_xor_si512(t2, c1);
const __m512i t4 = _mm512_andnot_si512(C, t3);
const __m512i t5 = _mm512_or_si512(t1, t4);
return t5;

f(A, B, C) = ((C and (B xor A)) or (not (C) and not ((B or A))))

const uint64_t t0 = B ^ A;
const uint64_t t1 = C & t0;
const uint64_t t2 = ~C;
const uint64_t t3 = B | A;
const uint64_t t4 = ~t3;
const uint64_t t5 = t2 & t4;
const uint64_t t6 = t1 | t5;
return t6;

f(A, B, C) = ((C and (B xor A)) or (not (C) and not ((B or A))))

const uint32_t t0 = B ^ A;
const uint32_t t1 = C & t0;
const uint32_t t2 = ~C;
const uint32_t t3 = B | A;
const uint32_t t4 = ~t3;
const uint32_t t5 = t2 & t4;
const uint32_t t6 = t1 | t5;
return t6;

f(A, B, C) = (C ? (B xor A) : ((B or A) xor 1))

const __m128i t0 = _mm_xor_si128(B, A);
const __m128i t1 = _mm_or_si128(B, A);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
const __m128i t3 = _mm_cmov_si128(t0, t2, C);
return t3;

f(A, B, C) = ((C and (B xor A)) or (C notand not ((B or A))))

const int32x4_t t0 = veorq_s32(B, A);
const int32x4_t t1 = vandq_s32(C, t0);
const int32x4_t t2 = vorrq_s32(B, A);
const int32x4_t t3 = vmvnq_s32(t2);
const int32x4_t t4 = vbicq_s32(t3, C);
const int32x4_t t5 = vorrq_s32(t1, t4);
return t5;

0x2a — (C and (B nand A))

f(A, B, C) = ((B and A) notand C)

const __m128i t0 = _mm_and_si128(B, A);
const __m128i t1 = _mm_andnot_si128(t0, C);
return t1;

f(A, B, C) = ((B and A) notand C)

const __m256i t0 = _mm256_and_si256(B, A);
const __m256i t1 = _mm256_andnot_si256(t0, C);
return t1;

f(A, B, C) = ((B and A) notand C)

const __m512i t0 = _mm512_and_si512(B, A);
const __m512i t1 = _mm512_andnot_si512(t0, C);
return t1;

f(A, B, C) = (C and not ((B and A)))

const uint64_t t0 = B & A;
const uint64_t t1 = ~t0;
const uint64_t t2 = C & t1;
return t2;

f(A, B, C) = (C and not ((B and A)))

const uint32_t t0 = B & A;
const uint32_t t1 = ~t0;
const uint32_t t2 = C & t1;
return t2;

f(A, B, C) = ((B and A) notand C)

const __m128i t0 = _mm_and_si128(B, A);
const __m128i t1 = _mm_andnot_si128(t0, C);
return t1;

f(A, B, C) = ((B and A) notand C)

const int32x4_t t0 = vandq_s32(B, A);
const int32x4_t t1 = vbicq_s32(C, t0);
return t1;

0x2b — (A ? (not (B) and C) : ((B xor 1) or C))

f(A, B, C) = (((B and A) notand C) or (C notand ((B or A) xor 1)))

const __m128i t0 = _mm_and_si128(B, A);
const __m128i t1 = _mm_andnot_si128(t0, C);
const __m128i t2 = _mm_or_si128(B, A);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t3 = _mm_xor_si128(t2, c1);
const __m128i t4 = _mm_andnot_si128(C, t3);
const __m128i t5 = _mm_or_si128(t1, t4);
return t5;

f(A, B, C) = (((B and A) notand C) or (C notand ((B or A) xor 1)))

const __m256i t0 = _mm256_and_si256(B, A);
const __m256i t1 = _mm256_andnot_si256(t0, C);
const __m256i t2 = _mm256_or_si256(B, A);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t3 = _mm256_xor_si256(t2, c1);
const __m256i t4 = _mm256_andnot_si256(C, t3);
const __m256i t5 = _mm256_or_si256(t1, t4);
return t5;

f(A, B, C) = (((B and A) notand C) or (C notand ((B or A) xor 1)))

const __m512i t0 = _mm512_and_si512(B, A);
const __m512i t1 = _mm512_andnot_si512(t0, C);
const __m512i t2 = _mm512_or_si512(B, A);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t3 = _mm512_xor_si512(t2, c1);
const __m512i t4 = _mm512_andnot_si512(C, t3);
const __m512i t5 = _mm512_or_si512(t1, t4);
return t5;

f(A, B, C) = ((C and not ((B and A))) or (not (C) and not ((B or A))))

const uint64_t t0 = B & A;
const uint64_t t1 = ~t0;
const uint64_t t2 = C & t1;
const uint64_t t3 = ~C;
const uint64_t t4 = B | A;
const uint64_t t5 = ~t4;
const uint64_t t6 = t3 & t5;
const uint64_t t7 = t2 | t6;
return t7;

f(A, B, C) = ((C and not ((B and A))) or (not (C) and not ((B or A))))

const uint32_t t0 = B & A;
const uint32_t t1 = ~t0;
const uint32_t t2 = C & t1;
const uint32_t t3 = ~C;
const uint32_t t4 = B | A;
const uint32_t t5 = ~t4;
const uint32_t t6 = t3 & t5;
const uint32_t t7 = t2 | t6;
return t7;

f(A, B, C) = (A ? (B notand C) : ((B xor 1) or C))

const __m128i t0 = _mm_andnot_si128(B, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(B, c1);
const __m128i t2 = _mm_or_si128(t1, C);
const __m128i t3 = _mm_cmov_si128(t0, t2, A);
return t3;

f(A, B, C) = (((B and A) notand C) or (C notand not ((B or A))))

const int32x4_t t0 = vandq_s32(B, A);
const int32x4_t t1 = vbicq_s32(C, t0);
const int32x4_t t2 = vorrq_s32(B, A);
const int32x4_t t3 = vmvnq_s32(t2);
const int32x4_t t4 = vbicq_s32(t3, C);
const int32x4_t t5 = vorrq_s32(t1, t4);
return t5;

0x2c — (A ? (not (B) and C) : B)

f(A, B, C) = ((B or C) and (A xor B))

const __m128i t0 = _mm_or_si128(B, C);
const __m128i t1 = _mm_xor_si128(A, B);
const __m128i t2 = _mm_and_si128(t0, t1);
return t2;

f(A, B, C) = ((B or C) and (A xor B))

const __m256i t0 = _mm256_or_si256(B, C);
const __m256i t1 = _mm256_xor_si256(A, B);
const __m256i t2 = _mm256_and_si256(t0, t1);
return t2;

f(A, B, C) = ((B or C) and (A xor B))

const __m512i t0 = _mm512_or_si512(B, C);
const __m512i t1 = _mm512_xor_si512(A, B);
const __m512i t2 = _mm512_and_si512(t0, t1);
return t2;

f(A, B, C) = ((B or C) and (A xor B))

const uint64_t t0 = B | C;
const uint64_t t1 = A ^ B;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = ((B or C) and (A xor B))

const uint32_t t0 = B | C;
const uint32_t t1 = A ^ B;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = (A ? (B notand C) : B)

const __m128i t0 = _mm_andnot_si128(B, C);
const __m128i t1 = _mm_cmov_si128(t0, B, A);
return t1;

f(A, B, C) = ((B or C) and (A xor B))

const int32x4_t t0 = vorrq_s32(B, C);
const int32x4_t t1 = veorq_s32(A, B);
const int32x4_t t2 = vandq_s32(t0, t1);
return t2;

0x2d — (C ? (A xor B) : (A xor 1))

f(A, B, C) = (A xor (B or (C xor 1)))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(C, c1);
const __m128i t1 = _mm_or_si128(B, t0);
const __m128i t2 = _mm_xor_si128(A, t1);
return t2;

f(A, B, C) = (A xor (B or (C xor 1)))

const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t0 = _mm256_xor_si256(C, c1);
const __m256i t1 = _mm256_or_si256(B, t0);
const __m256i t2 = _mm256_xor_si256(A, t1);
return t2;

f(A, B, C) = (A xor (B or (C xor 1)))

const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t0 = _mm512_xor_si512(C, c1);
const __m512i t1 = _mm512_or_si512(B, t0);
const __m512i t2 = _mm512_xor_si512(A, t1);
return t2;

f(A, B, C) = (A xor (B or not (C)))

const uint64_t t0 = ~C;
const uint64_t t1 = B | t0;
const uint64_t t2 = A ^ t1;
return t2;

f(A, B, C) = (A xor (B or not (C)))

const uint32_t t0 = ~C;
const uint32_t t1 = B | t0;
const uint32_t t2 = A ^ t1;
return t2;

f(A, B, C) = (A xor (B or (C xor 1)))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(C, c1);
const __m128i t1 = _mm_or_si128(B, t0);
const __m128i t2 = _mm_xor_si128(A, t1);
return t2;

f(A, B, C) = (A xor (C notor B))

const int32x4_t t0 = vornq_s32(B, C);
const int32x4_t t1 = veorq_s32(A, t0);
return t1;

0x2e — (B ? (not (A) and B) : C)

f(A, B, C) = ((A notand B) or (B notand C))

const __m128i t0 = _mm_andnot_si128(A, B);
const __m128i t1 = _mm_andnot_si128(B, C);
const __m128i t2 = _mm_or_si128(t0, t1);
return t2;

f(A, B, C) = ((A notand B) or (B notand C))

const __m256i t0 = _mm256_andnot_si256(A, B);
const __m256i t1 = _mm256_andnot_si256(B, C);
const __m256i t2 = _mm256_or_si256(t0, t1);
return t2;

f(A, B, C) = ((A notand B) or (B notand C))

const __m512i t0 = _mm512_andnot_si512(A, B);
const __m512i t1 = _mm512_andnot_si512(B, C);
const __m512i t2 = _mm512_or_si512(t0, t1);
return t2;

f(A, B, C) = ((B or C) xor (A and B))

const uint64_t t0 = B | C;
const uint64_t t1 = A & B;
const uint64_t t2 = t0 ^ t1;
return t2;

f(A, B, C) = ((B or C) xor (A and B))

const uint32_t t0 = B | C;
const uint32_t t1 = A & B;
const uint32_t t2 = t0 ^ t1;
return t2;

f(A, B, C) = (B ? (A notand B) : C)

const __m128i t0 = _mm_andnot_si128(A, B);
const __m128i t1 = _mm_cmov_si128(t0, C, B);
return t1;

f(A, B, C) = ((A notand B) or (B notand C))

const int32x4_t t0 = vbicq_s32(B, A);
const int32x4_t t1 = vbicq_s32(C, B);
const int32x4_t t2 = vorrq_s32(t0, t1);
return t2;

0x2f — (A ? (not (B) and C) : 1)

f(A, B, C) = ((A xor 1) or (B notand C))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(A, c1);
const __m128i t1 = _mm_andnot_si128(B, C);
const __m128i t2 = _mm_or_si128(t0, t1);
return t2;

f(A, B, C) = ((A xor 1) or (B notand C))

const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t0 = _mm256_xor_si256(A, c1);
const __m256i t1 = _mm256_andnot_si256(B, C);
const __m256i t2 = _mm256_or_si256(t0, t1);
return t2;

f(A, B, C) = ((A xor 1) or (B notand C))

const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t0 = _mm512_xor_si512(A, c1);
const __m512i t1 = _mm512_andnot_si512(B, C);
const __m512i t2 = _mm512_or_si512(t0, t1);
return t2;

f(A, B, C) = (not (A) or (not (B) and C))

const uint64_t t0 = ~A;
const uint64_t t1 = ~B;
const uint64_t t2 = t1 & C;
const uint64_t t3 = t0 | t2;
return t3;

f(A, B, C) = (not (A) or (not (B) and C))

const uint32_t t0 = ~A;
const uint32_t t1 = ~B;
const uint32_t t2 = t1 & C;
const uint32_t t3 = t0 | t2;
return t3;

f(A, B, C) = (A ? (B notand C) : 1)

const __m128i t0 = _mm_andnot_si128(B, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_cmov_si128(t0, c1, A);
return t1;

f(A, B, C) = (A notor (B notand C))

const int32x4_t t0 = vbicq_s32(C, B);
const int32x4_t t1 = vornq_s32(t0, A);
return t1;

0x30 — (A and not (B))

f(A, B, C) = (B notand A)

const __m128i t0 = _mm_andnot_si128(B, A);
return t0;

f(A, B, C) = (B notand A)

const __m256i t0 = _mm256_andnot_si256(B, A);
return t0;

f(A, B, C) = (B notand A)

const __m512i t0 = _mm512_andnot_si512(B, A);
return t0;

f(A, B, C) = (A and not (B))

const uint64_t t0 = ~B;
const uint64_t t1 = A & t0;
return t1;

f(A, B, C) = (A and not (B))

const uint32_t t0 = ~B;
const uint32_t t1 = A & t0;
return t1;

f(A, B, C) = (B notand A)

const __m128i t0 = _mm_andnot_si128(B, A);
return t0;

f(A, B, C) = (B notand A)

const int32x4_t t0 = vbicq_s32(A, B);
return t0;

0x31 — (C ? (not (B) and A) : (B xor 1))

f(A, B, C) = (B notand (A or (C xor 1)))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(C, c1);
const __m128i t1 = _mm_or_si128(A, t0);
const __m128i t2 = _mm_andnot_si128(B, t1);
return t2;

f(A, B, C) = (B notand (A or (C xor 1)))

const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t0 = _mm256_xor_si256(C, c1);
const __m256i t1 = _mm256_or_si256(A, t0);
const __m256i t2 = _mm256_andnot_si256(B, t1);
return t2;

f(A, B, C) = (B notand (A or (C xor 1)))

const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t0 = _mm512_xor_si512(C, c1);
const __m512i t1 = _mm512_or_si512(A, t0);
const __m512i t2 = _mm512_andnot_si512(B, t1);
return t2;

f(A, B, C) = (not ((B or C)) or (A and not (B)))

const uint64_t t0 = B | C;
const uint64_t t1 = ~t0;
const uint64_t t2 = ~B;
const uint64_t t3 = A & t2;
const uint64_t t4 = t1 | t3;
return t4;

f(A, B, C) = (not ((B or C)) or (A and not (B)))

const uint32_t t0 = B | C;
const uint32_t t1 = ~t0;
const uint32_t t2 = ~B;
const uint32_t t3 = A & t2;
const uint32_t t4 = t1 | t3;
return t4;

f(A, B, C) = (B notand (A or (C xor 1)))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(C, c1);
const __m128i t1 = _mm_or_si128(A, t0);
const __m128i t2 = _mm_andnot_si128(B, t1);
return t2;

f(A, B, C) = ((B or C) notor (B notand A))

const int32x4_t t0 = vorrq_s32(B, C);
const int32x4_t t1 = vbicq_s32(A, B);
const int32x4_t t2 = vornq_s32(t1, t0);
return t2;

0x32 — (A ? (not (B) and A) : (not (B) and C))

f(A, B, C) = (B notand (A or C))

const __m128i t0 = _mm_or_si128(A, C);
const __m128i t1 = _mm_andnot_si128(B, t0);
return t1;

f(A, B, C) = (B notand (A or C))

const __m256i t0 = _mm256_or_si256(A, C);
const __m256i t1 = _mm256_andnot_si256(B, t0);
return t1;

f(A, B, C) = (B notand (A or C))

const __m512i t0 = _mm512_or_si512(A, C);
const __m512i t1 = _mm512_andnot_si512(B, t0);
return t1;

f(A, B, C) = (not (B) and (A or C))

const uint64_t t0 = ~B;
const uint64_t t1 = A | C;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = (not (B) and (A or C))

const uint32_t t0 = ~B;
const uint32_t t1 = A | C;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = (B notand (A or C))

const __m128i t0 = _mm_or_si128(A, C);
const __m128i t1 = _mm_andnot_si128(B, t0);
return t1;

f(A, B, C) = (B notand (A or C))

const int32x4_t t0 = vorrq_s32(A, C);
const int32x4_t t1 = vbicq_s32(t0, B);
return t1;

0x33 — not (B)

f(A, B, C) = (B xor 1)

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(B, c1);
return t0;

f(A, B, C) = (B xor 1)

const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t0 = _mm256_xor_si256(B, c1);
return t0;

f(A, B, C) = (B xor 1)

const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t0 = _mm512_xor_si512(B, c1);
return t0;

f(A, B, C) = not (B)

const uint64_t t0 = ~B;
return t0;

f(A, B, C) = not (B)

const uint32_t t0 = ~B;
return t0;

f(A, B, C) = (B xor 1)

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(B, c1);
return t0;

f(A, B, C) = not (B)

const int32x4_t t0 = vmvnq_s32(B);
return t0;

0x34 — (A ? (not (B) and A) : (not (C) and B))

f(A, B, C) = ((B and C) notand (A xor B))

const __m128i t0 = _mm_and_si128(B, C);
const __m128i t1 = _mm_xor_si128(A, B);
const __m128i t2 = _mm_andnot_si128(t0, t1);
return t2;

f(A, B, C) = ((B and C) notand (A xor B))

const __m256i t0 = _mm256_and_si256(B, C);
const __m256i t1 = _mm256_xor_si256(A, B);
const __m256i t2 = _mm256_andnot_si256(t0, t1);
return t2;

f(A, B, C) = ((B and C) notand (A xor B))

const __m512i t0 = _mm512_and_si512(B, C);
const __m512i t1 = _mm512_xor_si512(A, B);
const __m512i t2 = _mm512_andnot_si512(t0, t1);
return t2;

f(A, B, C) = (not ((B and C)) and (A xor B))

const uint64_t t0 = B & C;
const uint64_t t1 = ~t0;
const uint64_t t2 = A ^ B;
const uint64_t t3 = t1 & t2;
return t3;

f(A, B, C) = (not ((B and C)) and (A xor B))

const uint32_t t0 = B & C;
const uint32_t t1 = ~t0;
const uint32_t t2 = A ^ B;
const uint32_t t3 = t1 & t2;
return t3;

f(A, B, C) = ((B and C) notand (A xor B))

const __m128i t0 = _mm_and_si128(B, C);
const __m128i t1 = _mm_xor_si128(A, B);
const __m128i t2 = _mm_andnot_si128(t0, t1);
return t2;

f(A, B, C) = ((B and C) notand (A xor B))

const int32x4_t t0 = vandq_s32(B, C);
const int32x4_t t1 = veorq_s32(A, B);
const int32x4_t t2 = vbicq_s32(t1, t0);
return t2;

0x35 — (A ? not (B) : not (C))

f(A, B, C) = ((B notand A) or (A notand (C xor 1)))

const __m128i t0 = _mm_andnot_si128(B, A);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(C, c1);
const __m128i t2 = _mm_andnot_si128(A, t1);
const __m128i t3 = _mm_or_si128(t0, t2);
return t3;

f(A, B, C) = ((B notand A) or (A notand (C xor 1)))

const __m256i t0 = _mm256_andnot_si256(B, A);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(C, c1);
const __m256i t2 = _mm256_andnot_si256(A, t1);
const __m256i t3 = _mm256_or_si256(t0, t2);
return t3;

f(A, B, C) = ((B notand A) or (A notand (C xor 1)))

const __m512i t0 = _mm512_andnot_si512(B, A);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(C, c1);
const __m512i t2 = _mm512_andnot_si512(A, t1);
const __m512i t3 = _mm512_or_si512(t0, t2);
return t3;

f(A, B, C) = ((A and not (B)) or (not (A) and not (C)))

const uint64_t t0 = ~B;
const uint64_t t1 = A & t0;
const uint64_t t2 = ~A;
const uint64_t t3 = ~C;
const uint64_t t4 = t2 & t3;
const uint64_t t5 = t1 | t4;
return t5;

f(A, B, C) = ((A and not (B)) or (not (A) and not (C)))

const uint32_t t0 = ~B;
const uint32_t t1 = A & t0;
const uint32_t t2 = ~A;
const uint32_t t3 = ~C;
const uint32_t t4 = t2 & t3;
const uint32_t t5 = t1 | t4;
return t5;

f(A, B, C) = (A ? (B xor 1) : (C xor 1))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(B, c1);
const __m128i t1 = _mm_xor_si128(C, c1);
const __m128i t2 = _mm_cmov_si128(t0, t1, A);
return t2;

f(A, B, C) = ((B notand A) or (A notand not (C)))

const int32x4_t t0 = vbicq_s32(A, B);
const int32x4_t t1 = vmvnq_s32(C);
const int32x4_t t2 = vbicq_s32(t1, A);
const int32x4_t t3 = vorrq_s32(t0, t2);
return t3;

0x36 — (B xor (A or C))

f(A, B, C) = (B xor (A or C))

const __m128i t0 = _mm_or_si128(A, C);
const __m128i t1 = _mm_xor_si128(B, t0);
return t1;

f(A, B, C) = (B xor (A or C))

const __m256i t0 = _mm256_or_si256(A, C);
const __m256i t1 = _mm256_xor_si256(B, t0);
return t1;

f(A, B, C) = (B xor (A or C))

const __m512i t0 = _mm512_or_si512(A, C);
const __m512i t1 = _mm512_xor_si512(B, t0);
return t1;

f(A, B, C) = (B xor (A or C))

const uint64_t t0 = A | C;
const uint64_t t1 = B ^ t0;
return t1;

f(A, B, C) = (B xor (A or C))

const uint32_t t0 = A | C;
const uint32_t t1 = B ^ t0;
return t1;

f(A, B, C) = (B xor (A or C))

const __m128i t0 = _mm_or_si128(A, C);
const __m128i t1 = _mm_xor_si128(B, t0);
return t1;

f(A, B, C) = (B xor (A or C))

const int32x4_t t0 = vorrq_s32(A, C);
const int32x4_t t1 = veorq_s32(B, t0);
return t1;

0x37 — (B nand (A or C))

f(A, B, C) = ((B and (A or C)) xor 1)

const __m128i t0 = _mm_or_si128(A, C);
const __m128i t1 = _mm_and_si128(B, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = ((B and (A or C)) xor 1)

const __m256i t0 = _mm256_or_si256(A, C);
const __m256i t1 = _mm256_and_si256(B, t0);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t2 = _mm256_xor_si256(t1, c1);
return t2;

f(A, B, C) = ((B and (A or C)) xor 1)

const __m512i t0 = _mm512_or_si512(A, C);
const __m512i t1 = _mm512_and_si512(B, t0);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t2 = _mm512_xor_si512(t1, c1);
return t2;

f(A, B, C) = not ((B and (A or C)))

const uint64_t t0 = A | C;
const uint64_t t1 = B & t0;
const uint64_t t2 = ~t1;
return t2;

f(A, B, C) = not ((B and (A or C)))

const uint32_t t0 = A | C;
const uint32_t t1 = B & t0;
const uint32_t t2 = ~t1;
return t2;

f(A, B, C) = ((B and (A or C)) xor 1)

const __m128i t0 = _mm_or_si128(A, C);
const __m128i t1 = _mm_and_si128(B, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = not ((B and (A or C)))

const int32x4_t t0 = vorrq_s32(A, C);
const int32x4_t t1 = vandq_s32(B, t0);
const int32x4_t t2 = vmvnq_s32(t1);
return t2;

0x38 — (B ? (not (A) and C) : A)

f(A, B, C) = ((A or C) and (A xor B))

const __m128i t0 = _mm_or_si128(A, C);
const __m128i t1 = _mm_xor_si128(A, B);
const __m128i t2 = _mm_and_si128(t0, t1);
return t2;

f(A, B, C) = ((A or C) and (A xor B))

const __m256i t0 = _mm256_or_si256(A, C);
const __m256i t1 = _mm256_xor_si256(A, B);
const __m256i t2 = _mm256_and_si256(t0, t1);
return t2;

f(A, B, C) = ((A or C) and (A xor B))

const __m512i t0 = _mm512_or_si512(A, C);
const __m512i t1 = _mm512_xor_si512(A, B);
const __m512i t2 = _mm512_and_si512(t0, t1);
return t2;

f(A, B, C) = ((A or C) and (A xor B))

const uint64_t t0 = A | C;
const uint64_t t1 = A ^ B;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = ((A or C) and (A xor B))

const uint32_t t0 = A | C;
const uint32_t t1 = A ^ B;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = (B ? (A notand C) : A)

const __m128i t0 = _mm_andnot_si128(A, C);
const __m128i t1 = _mm_cmov_si128(t0, A, B);
return t1;

f(A, B, C) = ((A or C) and (A xor B))

const int32x4_t t0 = vorrq_s32(A, C);
const int32x4_t t1 = veorq_s32(A, B);
const int32x4_t t2 = vandq_s32(t0, t1);
return t2;

0x39 — (C ? (A xor B) : (B xor 1))

f(A, B, C) = (B xor (A or (C xor 1)))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(C, c1);
const __m128i t1 = _mm_or_si128(A, t0);
const __m128i t2 = _mm_xor_si128(B, t1);
return t2;

f(A, B, C) = (B xor (A or (C xor 1)))

const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t0 = _mm256_xor_si256(C, c1);
const __m256i t1 = _mm256_or_si256(A, t0);
const __m256i t2 = _mm256_xor_si256(B, t1);
return t2;

f(A, B, C) = (B xor (A or (C xor 1)))

const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t0 = _mm512_xor_si512(C, c1);
const __m512i t1 = _mm512_or_si512(A, t0);
const __m512i t2 = _mm512_xor_si512(B, t1);
return t2;

f(A, B, C) = (B xor (A or (C xor 1)))

const uint64_t c1 = uint64_t(-1);
const uint64_t t0 = C ^ c1;
const uint64_t t1 = A | t0;
const uint64_t t2 = B ^ t1;
return t2;

f(A, B, C) = (B xor (A or (C xor 1)))

const uint32_t c1 = uint32_t(-1);
const uint32_t t0 = C ^ c1;
const uint32_t t1 = A | t0;
const uint32_t t2 = B ^ t1;
return t2;

f(A, B, C) = (B xor (A or (C xor 1)))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(C, c1);
const __m128i t1 = _mm_or_si128(A, t0);
const __m128i t2 = _mm_xor_si128(B, t1);
return t2;

f(A, B, C) = (B xor (A or (C xor 1)))

const int32x4_t c1 = vdupq_n_s32(-1);
const int32x4_t t0 = veorq_s32(C, c1);
const int32x4_t t1 = vorrq_s32(A, t0);
const int32x4_t t2 = veorq_s32(B, t1);
return t2;

0x3a — (A ? (not (B) and A) : C)

f(A, B, C) = ((B notand A) or (A notand C))

const __m128i t0 = _mm_andnot_si128(B, A);
const __m128i t1 = _mm_andnot_si128(A, C);
const __m128i t2 = _mm_or_si128(t0, t1);
return t2;

f(A, B, C) = ((B notand A) or (A notand C))

const __m256i t0 = _mm256_andnot_si256(B, A);
const __m256i t1 = _mm256_andnot_si256(A, C);
const __m256i t2 = _mm256_or_si256(t0, t1);
return t2;

f(A, B, C) = ((B notand A) or (A notand C))

const __m512i t0 = _mm512_andnot_si512(B, A);
const __m512i t1 = _mm512_andnot_si512(A, C);
const __m512i t2 = _mm512_or_si512(t0, t1);
return t2;

f(A, B, C) = ((A and not (B)) or (not (A) and C))

const uint64_t t0 = ~B;
const uint64_t t1 = A & t0;
const uint64_t t2 = ~A;
const uint64_t t3 = t2 & C;
const uint64_t t4 = t1 | t3;
return t4;

f(A, B, C) = ((A and not (B)) or (not (A) and C))

const uint32_t t0 = ~B;
const uint32_t t1 = A & t0;
const uint32_t t2 = ~A;
const uint32_t t3 = t2 & C;
const uint32_t t4 = t1 | t3;
return t4;

f(A, B, C) = (A ? (B notand A) : C)

const __m128i t0 = _mm_andnot_si128(B, A);
const __m128i t1 = _mm_cmov_si128(t0, C, A);
return t1;

f(A, B, C) = ((B notand A) or (A notand C))

const int32x4_t t0 = vbicq_s32(A, B);
const int32x4_t t1 = vbicq_s32(C, A);
const int32x4_t t2 = vorrq_s32(t0, t1);
return t2;

0x3b — (B ? (not (A) and C) : 1)

f(A, B, C) = ((A notand C) or (B xor 1))

const __m128i t0 = _mm_andnot_si128(A, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(B, c1);
const __m128i t2 = _mm_or_si128(t0, t1);
return t2;

f(A, B, C) = ((A notand C) or (B xor 1))

const __m256i t0 = _mm256_andnot_si256(A, C);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(B, c1);
const __m256i t2 = _mm256_or_si256(t0, t1);
return t2;

f(A, B, C) = ((A notand C) or (B xor 1))

const __m512i t0 = _mm512_andnot_si512(A, C);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(B, c1);
const __m512i t2 = _mm512_or_si512(t0, t1);
return t2;

f(A, B, C) = (not (B) or (not (A) and (B and C)))

const uint64_t t0 = ~B;
const uint64_t t1 = ~A;
const uint64_t t2 = B & C;
const uint64_t t3 = t1 & t2;
const uint64_t t4 = t0 | t3;
return t4;

f(A, B, C) = (not (B) or (not (A) and (B and C)))

const uint32_t t0 = ~B;
const uint32_t t1 = ~A;
const uint32_t t2 = B & C;
const uint32_t t3 = t1 & t2;
const uint32_t t4 = t0 | t3;
return t4;

f(A, B, C) = (B ? (A notand C) : 1)

const __m128i t0 = _mm_andnot_si128(A, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_cmov_si128(t0, c1, B);
return t1;

f(A, B, C) = (B notor (A notand (B and C)))

const int32x4_t t0 = vandq_s32(B, C);
const int32x4_t t1 = vbicq_s32(t0, A);
const int32x4_t t2 = vornq_s32(t1, B);
return t2;

0x3c — (B xor A)

f(A, B, C) = (B xor A)

const __m128i t0 = _mm_xor_si128(B, A);
return t0;

f(A, B, C) = (B xor A)

const __m256i t0 = _mm256_xor_si256(B, A);
return t0;

f(A, B, C) = (B xor A)

const __m512i t0 = _mm512_xor_si512(B, A);
return t0;

f(A, B, C) = (B xor A)

const uint64_t t0 = B ^ A;
return t0;

f(A, B, C) = (B xor A)

const uint32_t t0 = B ^ A;
return t0;

f(A, B, C) = (B xor A)

const __m128i t0 = _mm_xor_si128(B, A);
return t0;

f(A, B, C) = (B xor A)

const int32x4_t t0 = veorq_s32(B, A);
return t0;

0x3d — ((A xor B) or ((A or C) xor 1))

f(A, B, C) = ((A xor B) or ((A or C) xor 1))

const __m128i t0 = _mm_xor_si128(A, B);
const __m128i t1 = _mm_or_si128(A, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
const __m128i t3 = _mm_or_si128(t0, t2);
return t3;

f(A, B, C) = ((A xor B) or ((A or C) xor 1))

const __m256i t0 = _mm256_xor_si256(A, B);
const __m256i t1 = _mm256_or_si256(A, C);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t2 = _mm256_xor_si256(t1, c1);
const __m256i t3 = _mm256_or_si256(t0, t2);
return t3;

f(A, B, C) = ((A xor B) or ((A or C) xor 1))

const __m512i t0 = _mm512_xor_si512(A, B);
const __m512i t1 = _mm512_or_si512(A, C);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t2 = _mm512_xor_si512(t1, c1);
const __m512i t3 = _mm512_or_si512(t0, t2);
return t3;

f(A, B, C) = ((A xor B) or not ((A or C)))

const uint64_t t0 = A ^ B;
const uint64_t t1 = A | C;
const uint64_t t2 = ~t1;
const uint64_t t3 = t0 | t2;
return t3;

f(A, B, C) = ((A xor B) or not ((A or C)))

const uint32_t t0 = A ^ B;
const uint32_t t1 = A | C;
const uint32_t t2 = ~t1;
const uint32_t t3 = t0 | t2;
return t3;

f(A, B, C) = (C ? (B xor A) : ((B and A) xor 1))

const __m128i t0 = _mm_xor_si128(B, A);
const __m128i t1 = _mm_and_si128(B, A);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
const __m128i t3 = _mm_cmov_si128(t0, t2, C);
return t3;

f(A, B, C) = ((A or C) notor (A xor B))

const int32x4_t t0 = vorrq_s32(A, C);
const int32x4_t t1 = veorq_s32(A, B);
const int32x4_t t2 = vornq_s32(t1, t0);
return t2;

0x3e — (A ? (not (B) and A) : (B or C))

f(A, B, C) = ((A notand C) or (A xor B))

const __m128i t0 = _mm_andnot_si128(A, C);
const __m128i t1 = _mm_xor_si128(A, B);
const __m128i t2 = _mm_or_si128(t0, t1);
return t2;

f(A, B, C) = ((A notand C) or (A xor B))

const __m256i t0 = _mm256_andnot_si256(A, C);
const __m256i t1 = _mm256_xor_si256(A, B);
const __m256i t2 = _mm256_or_si256(t0, t1);
return t2;

f(A, B, C) = ((A notand C) or (A xor B))

const __m512i t0 = _mm512_andnot_si512(A, C);
const __m512i t1 = _mm512_xor_si512(A, B);
const __m512i t2 = _mm512_or_si512(t0, t1);
return t2;

f(A, B, C) = ((not (A) and C) or (A xor B))

const uint64_t t0 = ~A;
const uint64_t t1 = t0 & C;
const uint64_t t2 = A ^ B;
const uint64_t t3 = t1 | t2;
return t3;

f(A, B, C) = ((not (A) and C) or (A xor B))

const uint32_t t0 = ~A;
const uint32_t t1 = t0 & C;
const uint32_t t2 = A ^ B;
const uint32_t t3 = t1 | t2;
return t3;

f(A, B, C) = ((A notand C) or (A xor B))

const __m128i t0 = _mm_andnot_si128(A, C);
const __m128i t1 = _mm_xor_si128(A, B);
const __m128i t2 = _mm_or_si128(t0, t1);
return t2;

f(A, B, C) = ((A notand C) or (A xor B))

const int32x4_t t0 = vbicq_s32(C, A);
const int32x4_t t1 = veorq_s32(A, B);
const int32x4_t t2 = vorrq_s32(t0, t1);
return t2;

0x3f — (B nand A)

f(A, B, C) = ((B and A) xor 1)

const __m128i t0 = _mm_and_si128(B, A);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(t0, c1);
return t1;

f(A, B, C) = ((B and A) xor 1)

const __m256i t0 = _mm256_and_si256(B, A);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(t0, c1);
return t1;

f(A, B, C) = ((B and A) xor 1)

const __m512i t0 = _mm512_and_si512(B, A);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(t0, c1);
return t1;

f(A, B, C) = not ((B and A))

const uint64_t t0 = B & A;
const uint64_t t1 = ~t0;
return t1;

f(A, B, C) = not ((B and A))

const uint32_t t0 = B & A;
const uint32_t t1 = ~t0;
return t1;

f(A, B, C) = ((B and A) xor 1)

const __m128i t0 = _mm_and_si128(B, A);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(t0, c1);
return t1;

f(A, B, C) = not ((B and A))

const int32x4_t t0 = vandq_s32(B, A);
const int32x4_t t1 = vmvnq_s32(t0);
return t1;

0x40 — (A ? (not (C) and B) : A)

f(A, B, C) = (C notand (B and A))

const __m128i t0 = _mm_and_si128(B, A);
const __m128i t1 = _mm_andnot_si128(C, t0);
return t1;

f(A, B, C) = (C notand (B and A))

const __m256i t0 = _mm256_and_si256(B, A);
const __m256i t1 = _mm256_andnot_si256(C, t0);
return t1;

f(A, B, C) = (C notand (B and A))

const __m512i t0 = _mm512_and_si512(B, A);
const __m512i t1 = _mm512_andnot_si512(C, t0);
return t1;

f(A, B, C) = (not (C) and (B and A))

const uint64_t t0 = ~C;
const uint64_t t1 = B & A;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = (not (C) and (B and A))

const uint32_t t0 = ~C;
const uint32_t t1 = B & A;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = (C notand (B and A))

const __m128i t0 = _mm_and_si128(B, A);
const __m128i t1 = _mm_andnot_si128(C, t0);
return t1;

f(A, B, C) = (C notand (B and A))

const int32x4_t t0 = vandq_s32(B, A);
const int32x4_t t1 = vbicq_s32(t0, C);
return t1;

0x41 — (C nor (B xor A))

f(A, B, C) = ((C or (B xor A)) xor 1)

const __m128i t0 = _mm_xor_si128(B, A);
const __m128i t1 = _mm_or_si128(C, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = ((C or (B xor A)) xor 1)

const __m256i t0 = _mm256_xor_si256(B, A);
const __m256i t1 = _mm256_or_si256(C, t0);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t2 = _mm256_xor_si256(t1, c1);
return t2;

f(A, B, C) = ((C or (B xor A)) xor 1)

const __m512i t0 = _mm512_xor_si512(B, A);
const __m512i t1 = _mm512_or_si512(C, t0);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t2 = _mm512_xor_si512(t1, c1);
return t2;

f(A, B, C) = not ((C or (B xor A)))

const uint64_t t0 = B ^ A;
const uint64_t t1 = C | t0;
const uint64_t t2 = ~t1;
return t2;

f(A, B, C) = not ((C or (B xor A)))

const uint32_t t0 = B ^ A;
const uint32_t t1 = C | t0;
const uint32_t t2 = ~t1;
return t2;

f(A, B, C) = ((C or (B xor A)) xor 1)

const __m128i t0 = _mm_xor_si128(B, A);
const __m128i t1 = _mm_or_si128(C, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = not ((C or (B xor A)))

const int32x4_t t0 = veorq_s32(B, A);
const int32x4_t t1 = vorrq_s32(C, t0);
const int32x4_t t2 = vmvnq_s32(t1);
return t2;

0x42 — (A ? (not (C) and B) : (not (B) and C))

f(A, B, C) = ((A xor B) notand (B xor C))

const __m128i t0 = _mm_xor_si128(A, B);
const __m128i t1 = _mm_xor_si128(B, C);
const __m128i t2 = _mm_andnot_si128(t0, t1);
return t2;

f(A, B, C) = ((A xor B) notand (B xor C))

const __m256i t0 = _mm256_xor_si256(A, B);
const __m256i t1 = _mm256_xor_si256(B, C);
const __m256i t2 = _mm256_andnot_si256(t0, t1);
return t2;

f(A, B, C) = ((A xor B) notand (B xor C))

const __m512i t0 = _mm512_xor_si512(A, B);
const __m512i t1 = _mm512_xor_si512(B, C);
const __m512i t2 = _mm512_andnot_si512(t0, t1);
return t2;

f(A, B, C) = ((A xor C) and (B xor C))

const uint64_t t0 = A ^ C;
const uint64_t t1 = B ^ C;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = ((A xor C) and (B xor C))

const uint32_t t0 = A ^ C;
const uint32_t t1 = B ^ C;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = ((A xor B) notand (B xor C))

const __m128i t0 = _mm_xor_si128(A, B);
const __m128i t1 = _mm_xor_si128(B, C);
const __m128i t2 = _mm_andnot_si128(t0, t1);
return t2;

f(A, B, C) = ((A xor B) notand (B xor C))

const int32x4_t t0 = veorq_s32(A, B);
const int32x4_t t1 = veorq_s32(B, C);
const int32x4_t t2 = vbicq_s32(t1, t0);
return t2;

0x43 — (A ? (not (C) and B) : (B xor 1))

f(A, B, C) = ((A and C) notand (A xor (B xor 1)))

const __m128i t0 = _mm_and_si128(A, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(B, c1);
const __m128i t2 = _mm_xor_si128(A, t1);
const __m128i t3 = _mm_andnot_si128(t0, t2);
return t3;

f(A, B, C) = ((A and C) notand (A xor (B xor 1)))

const __m256i t0 = _mm256_and_si256(A, C);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(B, c1);
const __m256i t2 = _mm256_xor_si256(A, t1);
const __m256i t3 = _mm256_andnot_si256(t0, t2);
return t3;

f(A, B, C) = ((A and C) notand (A xor (B xor 1)))

const __m512i t0 = _mm512_and_si512(A, C);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(B, c1);
const __m512i t2 = _mm512_xor_si512(A, t1);
const __m512i t3 = _mm512_andnot_si512(t0, t2);
return t3;

f(A, B, C) = (not ((A and C)) and (A xor (B xor 1)))

const uint64_t t0 = A & C;
const uint64_t t1 = ~t0;
const uint64_t c1 = uint64_t(-1);
const uint64_t t2 = B ^ c1;
const uint64_t t3 = A ^ t2;
const uint64_t t4 = t1 & t3;
return t4;

f(A, B, C) = (not ((A and C)) and (A xor (B xor 1)))

const uint32_t t0 = A & C;
const uint32_t t1 = ~t0;
const uint32_t c1 = uint32_t(-1);
const uint32_t t2 = B ^ c1;
const uint32_t t3 = A ^ t2;
const uint32_t t4 = t1 & t3;
return t4;

f(A, B, C) = (A ? (C notand B) : (B xor 1))

const __m128i t0 = _mm_andnot_si128(C, B);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(B, c1);
const __m128i t2 = _mm_cmov_si128(t0, t1, A);
return t2;

f(A, B, C) = ((A and (C notand B)) or (A notand not (B)))

const int32x4_t t0 = vbicq_s32(B, C);
const int32x4_t t1 = vandq_s32(A, t0);
const int32x4_t t2 = vmvnq_s32(B);
const int32x4_t t3 = vbicq_s32(t2, A);
const int32x4_t t4 = vorrq_s32(t1, t3);
return t4;

0x44 — (B and not (C))

f(A, B, C) = (C notand B)

const __m128i t0 = _mm_andnot_si128(C, B);
return t0;

f(A, B, C) = (C notand B)

const __m256i t0 = _mm256_andnot_si256(C, B);
return t0;

f(A, B, C) = (C notand B)

const __m512i t0 = _mm512_andnot_si512(C, B);
return t0;

f(A, B, C) = (B and not (C))

const uint64_t t0 = ~C;
const uint64_t t1 = B & t0;
return t1;

f(A, B, C) = (B and not (C))

const uint32_t t0 = ~C;
const uint32_t t1 = B & t0;
return t1;

f(A, B, C) = (C notand B)

const __m128i t0 = _mm_andnot_si128(C, B);
return t0;

f(A, B, C) = (C notand B)

const int32x4_t t0 = vbicq_s32(B, C);
return t0;

0x45 — (A ? (not (C) and B) : (C xor 1))

f(A, B, C) = (C notand ((A xor 1) or B))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(A, c1);
const __m128i t1 = _mm_or_si128(t0, B);
const __m128i t2 = _mm_andnot_si128(C, t1);
return t2;

f(A, B, C) = (C notand ((A xor 1) or B))

const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t0 = _mm256_xor_si256(A, c1);
const __m256i t1 = _mm256_or_si256(t0, B);
const __m256i t2 = _mm256_andnot_si256(C, t1);
return t2;

f(A, B, C) = (C notand ((A xor 1) or B))

const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t0 = _mm512_xor_si512(A, c1);
const __m512i t1 = _mm512_or_si512(t0, B);
const __m512i t2 = _mm512_andnot_si512(C, t1);
return t2;

f(A, B, C) = (not (C) and (not (A) or (A and B)))

const uint64_t t0 = ~C;
const uint64_t t1 = ~A;
const uint64_t t2 = A & B;
const uint64_t t3 = t1 | t2;
const uint64_t t4 = t0 & t3;
return t4;

f(A, B, C) = (not (C) and (not (A) or (A and B)))

const uint32_t t0 = ~C;
const uint32_t t1 = ~A;
const uint32_t t2 = A & B;
const uint32_t t3 = t1 | t2;
const uint32_t t4 = t0 & t3;
return t4;

f(A, B, C) = (C notand ((A xor 1) or B))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(A, c1);
const __m128i t1 = _mm_or_si128(t0, B);
const __m128i t2 = _mm_andnot_si128(C, t1);
return t2;

f(A, B, C) = (C notand (A notor (A and B)))

const int32x4_t t0 = vandq_s32(A, B);
const int32x4_t t1 = vornq_s32(t0, A);
const int32x4_t t2 = vbicq_s32(t1, C);
return t2;

0x46 — (A ? (not (C) and B) : (B xor C))

f(A, B, C) = ((A and C) notand (B xor C))

const __m128i t0 = _mm_and_si128(A, C);
const __m128i t1 = _mm_xor_si128(B, C);
const __m128i t2 = _mm_andnot_si128(t0, t1);
return t2;

f(A, B, C) = ((A and C) notand (B xor C))

const __m256i t0 = _mm256_and_si256(A, C);
const __m256i t1 = _mm256_xor_si256(B, C);
const __m256i t2 = _mm256_andnot_si256(t0, t1);
return t2;

f(A, B, C) = ((A and C) notand (B xor C))

const __m512i t0 = _mm512_and_si512(A, C);
const __m512i t1 = _mm512_xor_si512(B, C);
const __m512i t2 = _mm512_andnot_si512(t0, t1);
return t2;

f(A, B, C) = (not ((A and C)) and (B xor C))

const uint64_t t0 = A & C;
const uint64_t t1 = ~t0;
const uint64_t t2 = B ^ C;
const uint64_t t3 = t1 & t2;
return t3;

f(A, B, C) = (not ((A and C)) and (B xor C))

const uint32_t t0 = A & C;
const uint32_t t1 = ~t0;
const uint32_t t2 = B ^ C;
const uint32_t t3 = t1 & t2;
return t3;

f(A, B, C) = ((A and C) notand (B xor C))

const __m128i t0 = _mm_and_si128(A, C);
const __m128i t1 = _mm_xor_si128(B, C);
const __m128i t2 = _mm_andnot_si128(t0, t1);
return t2;

f(A, B, C) = ((A and C) notand (B xor C))

const int32x4_t t0 = vandq_s32(A, C);
const int32x4_t t1 = veorq_s32(B, C);
const int32x4_t t2 = vbicq_s32(t1, t0);
return t2;

0x47 — (B ? not (C) : not (A))

f(A, B, C) = ((C notand B) or (B notand (A xor 1)))

const __m128i t0 = _mm_andnot_si128(C, B);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(A, c1);
const __m128i t2 = _mm_andnot_si128(B, t1);
const __m128i t3 = _mm_or_si128(t0, t2);
return t3;

f(A, B, C) = ((C notand B) or (B notand (A xor 1)))

const __m256i t0 = _mm256_andnot_si256(C, B);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(A, c1);
const __m256i t2 = _mm256_andnot_si256(B, t1);
const __m256i t3 = _mm256_or_si256(t0, t2);
return t3;

f(A, B, C) = ((C notand B) or (B notand (A xor 1)))

const __m512i t0 = _mm512_andnot_si512(C, B);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(A, c1);
const __m512i t2 = _mm512_andnot_si512(B, t1);
const __m512i t3 = _mm512_or_si512(t0, t2);
return t3;

f(A, B, C) = ((B and not (C)) or (not (B) and not (A)))

const uint64_t t0 = ~C;
const uint64_t t1 = B & t0;
const uint64_t t2 = ~B;
const uint64_t t3 = ~A;
const uint64_t t4 = t2 & t3;
const uint64_t t5 = t1 | t4;
return t5;

f(A, B, C) = ((B and not (C)) or (not (B) and not (A)))

const uint32_t t0 = ~C;
const uint32_t t1 = B & t0;
const uint32_t t2 = ~B;
const uint32_t t3 = ~A;
const uint32_t t4 = t2 & t3;
const uint32_t t5 = t1 | t4;
return t5;

f(A, B, C) = (B ? (C xor 1) : (A xor 1))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(C, c1);
const __m128i t1 = _mm_xor_si128(A, c1);
const __m128i t2 = _mm_cmov_si128(t0, t1, B);
return t2;

f(A, B, C) = ((C notand B) or (B notand not (A)))

const int32x4_t t0 = vbicq_s32(B, C);
const int32x4_t t1 = vmvnq_s32(A);
const int32x4_t t2 = vbicq_s32(t1, B);
const int32x4_t t3 = vorrq_s32(t0, t2);
return t3;

0x48 — (B and (A xor C))

f(A, B, C) = (B and (A xor C))

const __m128i t0 = _mm_xor_si128(A, C);
const __m128i t1 = _mm_and_si128(B, t0);
return t1;

f(A, B, C) = (B and (A xor C))

const __m256i t0 = _mm256_xor_si256(A, C);
const __m256i t1 = _mm256_and_si256(B, t0);
return t1;

f(A, B, C) = (B and (A xor C))

const __m512i t0 = _mm512_xor_si512(A, C);
const __m512i t1 = _mm512_and_si512(B, t0);
return t1;

f(A, B, C) = (B and (A xor C))

const uint64_t t0 = A ^ C;
const uint64_t t1 = B & t0;
return t1;

f(A, B, C) = (B and (A xor C))

const uint32_t t0 = A ^ C;
const uint32_t t1 = B & t0;
return t1;

f(A, B, C) = (B and (A xor C))

const __m128i t0 = _mm_xor_si128(A, C);
const __m128i t1 = _mm_and_si128(B, t0);
return t1;

f(A, B, C) = (B and (A xor C))

const int32x4_t t0 = veorq_s32(A, C);
const int32x4_t t1 = vandq_s32(B, t0);
return t1;

0x49 — (B ? (A xor C) : (A nor C))

f(A, B, C) = ((B and (A xor C)) or (B notand ((A or C) xor 1)))

const __m128i t0 = _mm_xor_si128(A, C);
const __m128i t1 = _mm_and_si128(B, t0);
const __m128i t2 = _mm_or_si128(A, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t3 = _mm_xor_si128(t2, c1);
const __m128i t4 = _mm_andnot_si128(B, t3);
const __m128i t5 = _mm_or_si128(t1, t4);
return t5;

f(A, B, C) = ((B and (A xor C)) or (B notand ((A or C) xor 1)))

const __m256i t0 = _mm256_xor_si256(A, C);
const __m256i t1 = _mm256_and_si256(B, t0);
const __m256i t2 = _mm256_or_si256(A, C);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t3 = _mm256_xor_si256(t2, c1);
const __m256i t4 = _mm256_andnot_si256(B, t3);
const __m256i t5 = _mm256_or_si256(t1, t4);
return t5;

f(A, B, C) = ((B and (A xor C)) or (B notand ((A or C) xor 1)))

const __m512i t0 = _mm512_xor_si512(A, C);
const __m512i t1 = _mm512_and_si512(B, t0);
const __m512i t2 = _mm512_or_si512(A, C);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t3 = _mm512_xor_si512(t2, c1);
const __m512i t4 = _mm512_andnot_si512(B, t3);
const __m512i t5 = _mm512_or_si512(t1, t4);
return t5;

f(A, B, C) = ((B and (A xor C)) or (not (B) and not ((A or C))))

const uint64_t t0 = A ^ C;
const uint64_t t1 = B & t0;
const uint64_t t2 = ~B;
const uint64_t t3 = A | C;
const uint64_t t4 = ~t3;
const uint64_t t5 = t2 & t4;
const uint64_t t6 = t1 | t5;
return t6;

f(A, B, C) = ((B and (A xor C)) or (not (B) and not ((A or C))))

const uint32_t t0 = A ^ C;
const uint32_t t1 = B & t0;
const uint32_t t2 = ~B;
const uint32_t t3 = A | C;
const uint32_t t4 = ~t3;
const uint32_t t5 = t2 & t4;
const uint32_t t6 = t1 | t5;
return t6;

f(A, B, C) = (B ? (A xor C) : ((A or C) xor 1))

const __m128i t0 = _mm_xor_si128(A, C);
const __m128i t1 = _mm_or_si128(A, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
const __m128i t3 = _mm_cmov_si128(t0, t2, B);
return t3;

f(A, B, C) = ((B and (A xor C)) or (B notand not ((A or C))))

const int32x4_t t0 = veorq_s32(A, C);
const int32x4_t t1 = vandq_s32(B, t0);
const int32x4_t t2 = vorrq_s32(A, C);
const int32x4_t t3 = vmvnq_s32(t2);
const int32x4_t t4 = vbicq_s32(t3, B);
const int32x4_t t5 = vorrq_s32(t1, t4);
return t5;

0x4a — (A ? (not (C) and B) : C)

f(A, B, C) = ((B or C) and (A xor C))

const __m128i t0 = _mm_or_si128(B, C);
const __m128i t1 = _mm_xor_si128(A, C);
const __m128i t2 = _mm_and_si128(t0, t1);
return t2;

f(A, B, C) = ((B or C) and (A xor C))

const __m256i t0 = _mm256_or_si256(B, C);
const __m256i t1 = _mm256_xor_si256(A, C);
const __m256i t2 = _mm256_and_si256(t0, t1);
return t2;

f(A, B, C) = ((B or C) and (A xor C))

const __m512i t0 = _mm512_or_si512(B, C);
const __m512i t1 = _mm512_xor_si512(A, C);
const __m512i t2 = _mm512_and_si512(t0, t1);
return t2;

f(A, B, C) = ((B or C) and (A xor C))

const uint64_t t0 = B | C;
const uint64_t t1 = A ^ C;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = ((B or C) and (A xor C))

const uint32_t t0 = B | C;
const uint32_t t1 = A ^ C;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = (A ? (C notand B) : C)

const __m128i t0 = _mm_andnot_si128(C, B);
const __m128i t1 = _mm_cmov_si128(t0, C, A);
return t1;

f(A, B, C) = ((B or C) and (A xor C))

const int32x4_t t0 = vorrq_s32(B, C);
const int32x4_t t1 = veorq_s32(A, C);
const int32x4_t t2 = vandq_s32(t0, t1);
return t2;

0x4b — (A xor ((B xor 1) or C))

f(A, B, C) = (A xor ((B xor 1) or C))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(B, c1);
const __m128i t1 = _mm_or_si128(t0, C);
const __m128i t2 = _mm_xor_si128(A, t1);
return t2;

f(A, B, C) = (A xor ((B xor 1) or C))

const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t0 = _mm256_xor_si256(B, c1);
const __m256i t1 = _mm256_or_si256(t0, C);
const __m256i t2 = _mm256_xor_si256(A, t1);
return t2;

f(A, B, C) = (A xor ((B xor 1) or C))

const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t0 = _mm512_xor_si512(B, c1);
const __m512i t1 = _mm512_or_si512(t0, C);
const __m512i t2 = _mm512_xor_si512(A, t1);
return t2;

f(A, B, C) = (A xor (not (B) or C))

const uint64_t t0 = ~B;
const uint64_t t1 = t0 | C;
const uint64_t t2 = A ^ t1;
return t2;

f(A, B, C) = (A xor (not (B) or C))

const uint32_t t0 = ~B;
const uint32_t t1 = t0 | C;
const uint32_t t2 = A ^ t1;
return t2;

f(A, B, C) = (B ? (A xor C) : (A xor 1))

const __m128i t0 = _mm_xor_si128(A, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(A, c1);
const __m128i t2 = _mm_cmov_si128(t0, t1, B);
return t2;

f(A, B, C) = (A xor (B notor C))

const int32x4_t t0 = vornq_s32(C, B);
const int32x4_t t1 = veorq_s32(A, t0);
return t1;

0x4c — (B and (A nand C))

f(A, B, C) = ((A and C) notand B)

const __m128i t0 = _mm_and_si128(A, C);
const __m128i t1 = _mm_andnot_si128(t0, B);
return t1;

f(A, B, C) = ((A and C) notand B)

const __m256i t0 = _mm256_and_si256(A, C);
const __m256i t1 = _mm256_andnot_si256(t0, B);
return t1;

f(A, B, C) = ((A and C) notand B)

const __m512i t0 = _mm512_and_si512(A, C);
const __m512i t1 = _mm512_andnot_si512(t0, B);
return t1;

f(A, B, C) = (B and not ((A and C)))

const uint64_t t0 = A & C;
const uint64_t t1 = ~t0;
const uint64_t t2 = B & t1;
return t2;

f(A, B, C) = (B and not ((A and C)))

const uint32_t t0 = A & C;
const uint32_t t1 = ~t0;
const uint32_t t2 = B & t1;
return t2;

f(A, B, C) = ((A and C) notand B)

const __m128i t0 = _mm_and_si128(A, C);
const __m128i t1 = _mm_andnot_si128(t0, B);
return t1;

f(A, B, C) = ((A and C) notand B)

const int32x4_t t0 = vandq_s32(A, C);
const int32x4_t t1 = vbicq_s32(B, t0);
return t1;

0x4d — (A ? (not (C) and B) : (B or (C xor 1)))

f(A, B, C) = (((A and C) notand B) or (B notand ((A or C) xor 1)))

const __m128i t0 = _mm_and_si128(A, C);
const __m128i t1 = _mm_andnot_si128(t0, B);
const __m128i t2 = _mm_or_si128(A, C);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t3 = _mm_xor_si128(t2, c1);
const __m128i t4 = _mm_andnot_si128(B, t3);
const __m128i t5 = _mm_or_si128(t1, t4);
return t5;

f(A, B, C) = (((A and C) notand B) or (B notand ((A or C) xor 1)))

const __m256i t0 = _mm256_and_si256(A, C);
const __m256i t1 = _mm256_andnot_si256(t0, B);
const __m256i t2 = _mm256_or_si256(A, C);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t3 = _mm256_xor_si256(t2, c1);
const __m256i t4 = _mm256_andnot_si256(B, t3);
const __m256i t5 = _mm256_or_si256(t1, t4);
return t5;

f(A, B, C) = (((A and C) notand B) or (B notand ((A or C) xor 1)))

const __m512i t0 = _mm512_and_si512(A, C);
const __m512i t1 = _mm512_andnot_si512(t0, B);
const __m512i t2 = _mm512_or_si512(A, C);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t3 = _mm512_xor_si512(t2, c1);
const __m512i t4 = _mm512_andnot_si512(B, t3);
const __m512i t5 = _mm512_or_si512(t1, t4);
return t5;

f(A, B, C) = ((B and not ((A and C))) or (not (B) and not ((A or C))))

const uint64_t t0 = A & C;
const uint64_t t1 = ~t0;
const uint64_t t2 = B & t1;
const uint64_t t3 = ~B;
const uint64_t t4 = A | C;
const uint64_t t5 = ~t4;
const uint64_t t6 = t3 & t5;
const uint64_t t7 = t2 | t6;
return t7;

f(A, B, C) = ((B and not ((A and C))) or (not (B) and not ((A or C))))

const uint32_t t0 = A & C;
const uint32_t t1 = ~t0;
const uint32_t t2 = B & t1;
const uint32_t t3 = ~B;
const uint32_t t4 = A | C;
const uint32_t t5 = ~t4;
const uint32_t t6 = t3 & t5;
const uint32_t t7 = t2 | t6;
return t7;

f(A, B, C) = (A ? (C notand B) : (B or (C xor 1)))

const __m128i t0 = _mm_andnot_si128(C, B);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(C, c1);
const __m128i t2 = _mm_or_si128(B, t1);
const __m128i t3 = _mm_cmov_si128(t0, t2, A);
return t3;

f(A, B, C) = (((A and C) notand B) or (B notand not ((A or C))))

const int32x4_t t0 = vandq_s32(A, C);
const int32x4_t t1 = vbicq_s32(B, t0);
const int32x4_t t2 = vorrq_s32(A, C);
const int32x4_t t3 = vmvnq_s32(t2);
const int32x4_t t4 = vbicq_s32(t3, B);
const int32x4_t t5 = vorrq_s32(t1, t4);
return t5;

0x4e — (C ? (not (A) and C) : B)

f(A, B, C) = ((A notand C) or (C notand B))

const __m128i t0 = _mm_andnot_si128(A, C);
const __m128i t1 = _mm_andnot_si128(C, B);
const __m128i t2 = _mm_or_si128(t0, t1);
return t2;

f(A, B, C) = ((A notand C) or (C notand B))

const __m256i t0 = _mm256_andnot_si256(A, C);
const __m256i t1 = _mm256_andnot_si256(C, B);
const __m256i t2 = _mm256_or_si256(t0, t1);
return t2;

f(A, B, C) = ((A notand C) or (C notand B))

const __m512i t0 = _mm512_andnot_si512(A, C);
const __m512i t1 = _mm512_andnot_si512(C, B);
const __m512i t2 = _mm512_or_si512(t0, t1);
return t2;

f(A, B, C) = ((C and not (A)) or (not (C) and B))

const uint64_t t0 = ~A;
const uint64_t t1 = C & t0;
const uint64_t t2 = ~C;
const uint64_t t3 = t2 & B;
const uint64_t t4 = t1 | t3;
return t4;

f(A, B, C) = ((C and not (A)) or (not (C) and B))

const uint32_t t0 = ~A;
const uint32_t t1 = C & t0;
const uint32_t t2 = ~C;
const uint32_t t3 = t2 & B;
const uint32_t t4 = t1 | t3;
return t4;

f(A, B, C) = (C ? (A notand C) : B)

const __m128i t0 = _mm_andnot_si128(A, C);
const __m128i t1 = _mm_cmov_si128(t0, B, C);
return t1;

f(A, B, C) = ((A notand C) or (C notand B))

const int32x4_t t0 = vbicq_s32(C, A);
const int32x4_t t1 = vbicq_s32(B, C);
const int32x4_t t2 = vorrq_s32(t0, t1);
return t2;

0x4f — (A ? (not (C) and B) : 1)

f(A, B, C) = ((A xor 1) or (C notand B))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(A, c1);
const __m128i t1 = _mm_andnot_si128(C, B);
const __m128i t2 = _mm_or_si128(t0, t1);
return t2;

f(A, B, C) = ((A xor 1) or (C notand B))

const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t0 = _mm256_xor_si256(A, c1);
const __m256i t1 = _mm256_andnot_si256(C, B);
const __m256i t2 = _mm256_or_si256(t0, t1);
return t2;

f(A, B, C) = ((A xor 1) or (C notand B))

const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t0 = _mm512_xor_si512(A, c1);
const __m512i t1 = _mm512_andnot_si512(C, B);
const __m512i t2 = _mm512_or_si512(t0, t1);
return t2;

f(A, B, C) = (not (A) or (B and not (C)))

const uint64_t t0 = ~A;
const uint64_t t1 = ~C;
const uint64_t t2 = B & t1;
const uint64_t t3 = t0 | t2;
return t3;

f(A, B, C) = (not (A) or (B and not (C)))

const uint32_t t0 = ~A;
const uint32_t t1 = ~C;
const uint32_t t2 = B & t1;
const uint32_t t3 = t0 | t2;
return t3;

f(A, B, C) = (A ? (C notand B) : 1)

const __m128i t0 = _mm_andnot_si128(C, B);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_cmov_si128(t0, c1, A);
return t1;

f(A, B, C) = (A notor (C notand B))

const int32x4_t t0 = vbicq_s32(B, C);
const int32x4_t t1 = vornq_s32(t0, A);
return t1;

0x50 — (A and not (C))

f(A, B, C) = (C notand A)

const __m128i t0 = _mm_andnot_si128(C, A);
return t0;

f(A, B, C) = (C notand A)

const __m256i t0 = _mm256_andnot_si256(C, A);
return t0;

f(A, B, C) = (C notand A)

const __m512i t0 = _mm512_andnot_si512(C, A);
return t0;

f(A, B, C) = (A and not (C))

const uint64_t t0 = ~C;
const uint64_t t1 = A & t0;
return t1;

f(A, B, C) = (A and not (C))

const uint32_t t0 = ~C;
const uint32_t t1 = A & t0;
return t1;

f(A, B, C) = (C notand A)

const __m128i t0 = _mm_andnot_si128(C, A);
return t0;

f(A, B, C) = (C notand A)

const int32x4_t t0 = vbicq_s32(A, C);
return t0;

0x51 — (B ? (not (C) and A) : (C xor 1))

f(A, B, C) = (C notand (A or (B xor 1)))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(B, c1);
const __m128i t1 = _mm_or_si128(A, t0);
const __m128i t2 = _mm_andnot_si128(C, t1);
return t2;

f(A, B, C) = (C notand (A or (B xor 1)))

const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t0 = _mm256_xor_si256(B, c1);
const __m256i t1 = _mm256_or_si256(A, t0);
const __m256i t2 = _mm256_andnot_si256(C, t1);
return t2;

f(A, B, C) = (C notand (A or (B xor 1)))

const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t0 = _mm512_xor_si512(B, c1);
const __m512i t1 = _mm512_or_si512(A, t0);
const __m512i t2 = _mm512_andnot_si512(C, t1);
return t2;

f(A, B, C) = (not ((B or C)) or (A and not (C)))

const uint64_t t0 = B | C;
const uint64_t t1 = ~t0;
const uint64_t t2 = ~C;
const uint64_t t3 = A & t2;
const uint64_t t4 = t1 | t3;
return t4;

f(A, B, C) = (not ((B or C)) or (A and not (C)))

const uint32_t t0 = B | C;
const uint32_t t1 = ~t0;
const uint32_t t2 = ~C;
const uint32_t t3 = A & t2;
const uint32_t t4 = t1 | t3;
return t4;

f(A, B, C) = (C notand (A or (B xor 1)))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(B, c1);
const __m128i t1 = _mm_or_si128(A, t0);
const __m128i t2 = _mm_andnot_si128(C, t1);
return t2;

f(A, B, C) = ((B or C) notor (C notand A))

const int32x4_t t0 = vorrq_s32(B, C);
const int32x4_t t1 = vbicq_s32(A, C);
const int32x4_t t2 = vornq_s32(t1, t0);
return t2;

0x52 — (A ? (not (C) and A) : (not (B) and C))

f(A, B, C) = ((B and C) notand (A xor C))

const __m128i t0 = _mm_and_si128(B, C);
const __m128i t1 = _mm_xor_si128(A, C);
const __m128i t2 = _mm_andnot_si128(t0, t1);
return t2;

f(A, B, C) = ((B and C) notand (A xor C))

const __m256i t0 = _mm256_and_si256(B, C);
const __m256i t1 = _mm256_xor_si256(A, C);
const __m256i t2 = _mm256_andnot_si256(t0, t1);
return t2;

f(A, B, C) = ((B and C) notand (A xor C))

const __m512i t0 = _mm512_and_si512(B, C);
const __m512i t1 = _mm512_xor_si512(A, C);
const __m512i t2 = _mm512_andnot_si512(t0, t1);
return t2;

f(A, B, C) = (not ((B and C)) and (A xor C))

const uint64_t t0 = B & C;
const uint64_t t1 = ~t0;
const uint64_t t2 = A ^ C;
const uint64_t t3 = t1 & t2;
return t3;

f(A, B, C) = (not ((B and C)) and (A xor C))

const uint32_t t0 = B & C;
const uint32_t t1 = ~t0;
const uint32_t t2 = A ^ C;
const uint32_t t3 = t1 & t2;
return t3;

f(A, B, C) = ((B and C) notand (A xor C))

const __m128i t0 = _mm_and_si128(B, C);
const __m128i t1 = _mm_xor_si128(A, C);
const __m128i t2 = _mm_andnot_si128(t0, t1);
return t2;

f(A, B, C) = ((B and C) notand (A xor C))

const int32x4_t t0 = vandq_s32(B, C);
const int32x4_t t1 = veorq_s32(A, C);
const int32x4_t t2 = vbicq_s32(t1, t0);
return t2;

0x53 — (A ? not (C) : not (B))

f(A, B, C) = ((C notand A) or (A notand (B xor 1)))

const __m128i t0 = _mm_andnot_si128(C, A);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t1 = _mm_xor_si128(B, c1);
const __m128i t2 = _mm_andnot_si128(A, t1);
const __m128i t3 = _mm_or_si128(t0, t2);
return t3;

f(A, B, C) = ((C notand A) or (A notand (B xor 1)))

const __m256i t0 = _mm256_andnot_si256(C, A);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t1 = _mm256_xor_si256(B, c1);
const __m256i t2 = _mm256_andnot_si256(A, t1);
const __m256i t3 = _mm256_or_si256(t0, t2);
return t3;

f(A, B, C) = ((C notand A) or (A notand (B xor 1)))

const __m512i t0 = _mm512_andnot_si512(C, A);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t1 = _mm512_xor_si512(B, c1);
const __m512i t2 = _mm512_andnot_si512(A, t1);
const __m512i t3 = _mm512_or_si512(t0, t2);
return t3;

f(A, B, C) = ((A and not (C)) or (not (A) and not (B)))

const uint64_t t0 = ~C;
const uint64_t t1 = A & t0;
const uint64_t t2 = ~A;
const uint64_t t3 = ~B;
const uint64_t t4 = t2 & t3;
const uint64_t t5 = t1 | t4;
return t5;

f(A, B, C) = ((A and not (C)) or (not (A) and not (B)))

const uint32_t t0 = ~C;
const uint32_t t1 = A & t0;
const uint32_t t2 = ~A;
const uint32_t t3 = ~B;
const uint32_t t4 = t2 & t3;
const uint32_t t5 = t1 | t4;
return t5;

f(A, B, C) = (A ? (C xor 1) : (B xor 1))

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(C, c1);
const __m128i t1 = _mm_xor_si128(B, c1);
const __m128i t2 = _mm_cmov_si128(t0, t1, A);
return t2;

f(A, B, C) = ((C notand A) or (A notand not (B)))

const int32x4_t t0 = vbicq_s32(A, C);
const int32x4_t t1 = vmvnq_s32(B);
const int32x4_t t2 = vbicq_s32(t1, A);
const int32x4_t t3 = vorrq_s32(t0, t2);
return t3;

0x54 — (A ? (not (C) and A) : (not (C) and B))

f(A, B, C) = (C notand (A or B))

const __m128i t0 = _mm_or_si128(A, B);
const __m128i t1 = _mm_andnot_si128(C, t0);
return t1;

f(A, B, C) = (C notand (A or B))

const __m256i t0 = _mm256_or_si256(A, B);
const __m256i t1 = _mm256_andnot_si256(C, t0);
return t1;

f(A, B, C) = (C notand (A or B))

const __m512i t0 = _mm512_or_si512(A, B);
const __m512i t1 = _mm512_andnot_si512(C, t0);
return t1;

f(A, B, C) = (not (C) and (A or B))

const uint64_t t0 = ~C;
const uint64_t t1 = A | B;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = (not (C) and (A or B))

const uint32_t t0 = ~C;
const uint32_t t1 = A | B;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = (C notand (A or B))

const __m128i t0 = _mm_or_si128(A, B);
const __m128i t1 = _mm_andnot_si128(C, t0);
return t1;

f(A, B, C) = (C notand (A or B))

const int32x4_t t0 = vorrq_s32(A, B);
const int32x4_t t1 = vbicq_s32(t0, C);
return t1;

0x55 — not (C)

f(A, B, C) = (C xor 1)

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(C, c1);
return t0;

f(A, B, C) = (C xor 1)

const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t0 = _mm256_xor_si256(C, c1);
return t0;

f(A, B, C) = (C xor 1)

const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t0 = _mm512_xor_si512(C, c1);
return t0;

f(A, B, C) = not (C)

const uint64_t t0 = ~C;
return t0;

f(A, B, C) = not (C)

const uint32_t t0 = ~C;
return t0;

f(A, B, C) = (C xor 1)

const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t0 = _mm_xor_si128(C, c1);
return t0;

f(A, B, C) = not (C)

const int32x4_t t0 = vmvnq_s32(C);
return t0;

0x56 — (C xor (B or A))

f(A, B, C) = (C xor (B or A))

const __m128i t0 = _mm_or_si128(B, A);
const __m128i t1 = _mm_xor_si128(C, t0);
return t1;

f(A, B, C) = (C xor (B or A))

const __m256i t0 = _mm256_or_si256(B, A);
const __m256i t1 = _mm256_xor_si256(C, t0);
return t1;

f(A, B, C) = (C xor (B or A))

const __m512i t0 = _mm512_or_si512(B, A);
const __m512i t1 = _mm512_xor_si512(C, t0);
return t1;

f(A, B, C) = (C xor (B or A))

const uint64_t t0 = B | A;
const uint64_t t1 = C ^ t0;
return t1;

f(A, B, C) = (C xor (B or A))

const uint32_t t0 = B | A;
const uint32_t t1 = C ^ t0;
return t1;

f(A, B, C) = (C xor (B or A))

const __m128i t0 = _mm_or_si128(B, A);
const __m128i t1 = _mm_xor_si128(C, t0);
return t1;

f(A, B, C) = (C xor (B or A))

const int32x4_t t0 = vorrq_s32(B, A);
const int32x4_t t1 = veorq_s32(C, t0);
return t1;

0x57 — (C nand (B or A))

f(A, B, C) = ((C and (B or A)) xor 1)

const __m128i t0 = _mm_or_si128(B, A);
const __m128i t1 = _mm_and_si128(C, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = ((C and (B or A)) xor 1)

const __m256i t0 = _mm256_or_si256(B, A);
const __m256i t1 = _mm256_and_si256(C, t0);
const __m256i c1 = _mm256_set1_epi32(-1);
const __m256i t2 = _mm256_xor_si256(t1, c1);
return t2;

f(A, B, C) = ((C and (B or A)) xor 1)

const __m512i t0 = _mm512_or_si512(B, A);
const __m512i t1 = _mm512_and_si512(C, t0);
const __m512i c1 = _mm512_set1_epi32(-1);
const __m512i t2 = _mm512_xor_si512(t1, c1);
return t2;

f(A, B, C) = not ((C and (B or A)))

const uint64_t t0 = B | A;
const uint64_t t1 = C & t0;
const uint64_t t2 = ~t1;
return t2;

f(A, B, C) = not ((C and (B or A)))

const uint32_t t0 = B | A;
const uint32_t t1 = C & t0;
const uint32_t t2 = ~t1;
return t2;

f(A, B, C) = ((C and (B or A)) xor 1)

const __m128i t0 = _mm_or_si128(B, A);
const __m128i t1 = _mm_and_si128(C, t0);
const __m128i c1 = _mm_set1_epi32(-1);
const __m128i t2 = _mm_xor_si128(t1, c1);
return t2;

f(A, B, C) = not ((C and (B or A)))

const int32x4_t t0 = vorrq_s32(B, A);
const int32x4_t t1 = vandq_s32(C, t0);
const int32x4_t t2 = vmvnq_s32(t1);
return t2;

0x58 — (C ? (not (A) and B) : A)

f(A, B, C) = ((A or B) and (A xor C))

const __m128i t0 = _mm_or_si128(A, B);
const __m128i t1 = _mm_xor_si128(A, C);
const __m128i t2 = _mm_and_si128(t0, t1);
return t2;

f(A, B, C) = ((A or B) and (A xor C))

const __m256i t0 = _mm256_or_si256(A, B);
const __m256i t1 = _mm256_xor_si256(A, C);
const __m256i t2 = _mm256_and_si256(t0, t1);
return t2;

f(A, B, C) = ((A or B) and (A xor C))

const __m512i t0 = _mm512_or_si512(A, B);
const __m512i t1 = _mm512_xor_si512(A, C);
const __m512i t2 = _mm512_and_si512(t0, t1);
return t2;

f(A, B, C) = ((A or B) and (A xor C))

const uint64_t t0 = A | B;
const uint64_t t1 = A ^ C;
const uint64_t t2 = t0 & t1;
return t2;

f(A, B, C) = ((A or B) and (A xor C))

const uint32_t t0 = A | B;
const uint32_t t1 = A ^ C;
const uint32_t t2 = t0 & t1;
return t2;

f(A, B, C) = (C ? (A notand B) : A)

const __m128i t0 = _mm_andnot_si128(A, B);
const __m128i t1 = _mm_cmov_si128(t0, A, C);
return t1;

f(A, B, C) = ((A or B) and (A xor C))

const int32x4_t t0 = vorrq_s32(A, B);
const int32x4_t t1 = veorq_s32(A, C);
const int32x4_t t2 = vandq_s32(t0, t1);
return t2;