Пример #1
0
/*
* Blowfish Decryption
*/
void Blowfish::decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const
   {
   verify_key_set(m_S.empty() == false);

   while(blocks >= 2)
      {
      uint32_t L0, R0, L1, R1;
      load_be(in, L0, R0, L1, R1);

      for(size_t r = 17; r != 1; r -= 2)
         {
         L0 ^= m_P[r];
         L1 ^= m_P[r];
         R0 ^= BFF(L0, m_S);
         R1 ^= BFF(L1, m_S);

         R0 ^= m_P[r-1];
         R1 ^= m_P[r-1];
         L0 ^= BFF(R0, m_S);
         L1 ^= BFF(R1, m_S);
         }

      L0 ^= m_P[1]; R0 ^= m_P[0];
      L1 ^= m_P[1]; R1 ^= m_P[0];

      store_be(out, R0, L0, R1, L1);

      in += 2*BLOCK_SIZE;
      out += 2*BLOCK_SIZE;
      blocks -= 2;
      }

   if(blocks)
      {
      uint32_t L, R;
      load_be(in, L, R);

      for(size_t r = 17; r != 1; r -= 2)
         {
         L ^= m_P[r];
         R ^= BFF(L, m_S);

         R ^= m_P[r-1];
         L ^= BFF(R, m_S);
         }

      L ^= m_P[1]; R ^= m_P[0];

      store_be(out, R, L);
      }
   }
Пример #2
0
/**
* The GOST 34.11 compression function
*/
void GOST_34_11::compress_n(const uint8_t input[], size_t blocks)
{
    for(size_t i = 0; i != blocks; ++i)
    {
        for(uint16_t j = 0, carry = 0; j != 32; ++j)
        {
            uint16_t s = m_sum[j] + input[32*i+j] + carry;
            carry = get_byte(0, s);
            m_sum[j] = get_byte(1, s);
        }

        uint8_t S[32] = { 0 };

        uint64_t U[4], V[4];
        load_be(U, m_hash.data(), 4);
        load_be(V, input + 32*i, 4);

        for(size_t j = 0; j != 4; ++j)
        {
            uint8_t key[32] = { 0 };

            // P transformation
            for(size_t k = 0; k != 4; ++k)
                for(size_t l = 0; l != 8; ++l)
                    key[4*l+k] = get_byte(l, U[k]) ^ get_byte(l, V[k]);

            m_cipher.set_key(key, 32);
            m_cipher.encrypt(&m_hash[8*j], S + 8*j);

            if(j == 3)
                break;

            // A(x)
            uint64_t A_U = U[0];
            U[0] = U[1];
            U[1] = U[2];
            U[2] = U[3];
            U[3] = U[0] ^ A_U;

            if(j == 1) // C_3
            {
                U[0] ^= 0x00FF00FF00FF00FF;
                U[1] ^= 0xFF00FF00FF00FF00;
                U[2] ^= 0x00FFFF00FF0000FF;
                U[3] ^= 0xFF000000FFFF00FF;
            }

            // A(A(x))
            uint64_t AA_V_1 = V[0] ^ V[1];
            uint64_t AA_V_2 = V[1] ^ V[2];
            V[0] = V[2];
            V[1] = V[3];
            V[2] = AA_V_1;
            V[3] = AA_V_2;
        }

        uint8_t S2[32] = { 0 };

        // 12 rounds of psi
        S2[ 0] = S[24];
        S2[ 1] = S[25];
        S2[ 2] = S[26];
        S2[ 3] = S[27];
        S2[ 4] = S[28];
        S2[ 5] = S[29];
        S2[ 6] = S[30];
        S2[ 7] = S[31];
        S2[ 8] = S[ 0] ^ S[ 2] ^ S[ 4] ^ S[ 6] ^ S[24] ^ S[30];
        S2[ 9] = S[ 1] ^ S[ 3] ^ S[ 5] ^ S[ 7] ^ S[25] ^ S[31];
        S2[10] = S[ 0] ^ S[ 8] ^ S[24] ^ S[26] ^ S[30];
        S2[11] = S[ 1] ^ S[ 9] ^ S[25] ^ S[27] ^ S[31];
        S2[12] = S[ 0] ^ S[ 4] ^ S[ 6] ^ S[10] ^ S[24] ^ S[26] ^ S[28] ^ S[30];
        S2[13] = S[ 1] ^ S[ 5] ^ S[ 7] ^ S[11] ^ S[25] ^ S[27] ^ S[29] ^ S[31];
        S2[14] = S[ 0] ^ S[ 4] ^ S[ 8] ^ S[12] ^ S[24] ^ S[26] ^ S[28];
        S2[15] = S[ 1] ^ S[ 5] ^ S[ 9] ^ S[13] ^ S[25] ^ S[27] ^ S[29];
        S2[16] = S[ 2] ^ S[ 6] ^ S[10] ^ S[14] ^ S[26] ^ S[28] ^ S[30];
        S2[17] = S[ 3] ^ S[ 7] ^ S[11] ^ S[15] ^ S[27] ^ S[29] ^ S[31];
        S2[18] = S[ 0] ^ S[ 2] ^ S[ 6] ^ S[ 8] ^ S[12] ^ S[16] ^ S[24] ^ S[28];
        S2[19] = S[ 1] ^ S[ 3] ^ S[ 7] ^ S[ 9] ^ S[13] ^ S[17] ^ S[25] ^ S[29];
        S2[20] = S[ 2] ^ S[ 4] ^ S[ 8] ^ S[10] ^ S[14] ^ S[18] ^ S[26] ^ S[30];
        S2[21] = S[ 3] ^ S[ 5] ^ S[ 9] ^ S[11] ^ S[15] ^ S[19] ^ S[27] ^ S[31];
        S2[22] = S[ 0] ^ S[ 2] ^ S[10] ^ S[12] ^ S[16] ^ S[20] ^ S[24] ^ S[28] ^ S[30];
        S2[23] = S[ 1] ^ S[ 3] ^ S[11] ^ S[13] ^ S[17] ^ S[21] ^ S[25] ^ S[29] ^ S[31];
        S2[24] = S[ 0] ^ S[ 6] ^ S[12] ^ S[14] ^ S[18] ^ S[22] ^ S[24] ^ S[26];
        S2[25] = S[ 1] ^ S[ 7] ^ S[13] ^ S[15] ^ S[19] ^ S[23] ^ S[25] ^ S[27];
        S2[26] = S[ 2] ^ S[ 8] ^ S[14] ^ S[16] ^ S[20] ^ S[24] ^ S[26] ^ S[28];
        S2[27] = S[ 3] ^ S[ 9] ^ S[15] ^ S[17] ^ S[21] ^ S[25] ^ S[27] ^ S[29];
        S2[28] = S[ 4] ^ S[10] ^ S[16] ^ S[18] ^ S[22] ^ S[26] ^ S[28] ^ S[30];
        S2[29] = S[ 5] ^ S[11] ^ S[17] ^ S[19] ^ S[23] ^ S[27] ^ S[29] ^ S[31];
        S2[30] = S[ 0] ^ S[ 2] ^ S[ 4] ^ S[12] ^ S[18] ^ S[20] ^ S[28];
        S2[31] = S[ 1] ^ S[ 3] ^ S[ 5] ^ S[13] ^ S[19] ^ S[21] ^ S[29];

        xor_buf(S, S2, input + 32*i, 32);

        S2[0] = S[0] ^ S[2] ^ S[4] ^ S[6] ^ S[24] ^ S[30];
        S2[1] = S[1] ^ S[3] ^ S[5] ^ S[7] ^ S[25] ^ S[31];

        copy_mem(S, S+2, 30);
        S[30] = S2[0];
        S[31] = S2[1];

        xor_buf(S, m_hash.data(), 32);

        // 61 rounds of psi
        S2[ 0] = S[ 2] ^ S[ 6] ^ S[14] ^ S[20] ^ S[22] ^ S[26] ^ S[28] ^ S[30];
        S2[ 1] = S[ 3] ^ S[ 7] ^ S[15] ^ S[21] ^ S[23] ^ S[27] ^ S[29] ^ S[31];
        S2[ 2] = S[ 0] ^ S[ 2] ^ S[ 6] ^ S[ 8] ^ S[16] ^ S[22] ^ S[28];
        S2[ 3] = S[ 1] ^ S[ 3] ^ S[ 7] ^ S[ 9] ^ S[17] ^ S[23] ^ S[29];
        S2[ 4] = S[ 2] ^ S[ 4] ^ S[ 8] ^ S[10] ^ S[18] ^ S[24] ^ S[30];
        S2[ 5] = S[ 3] ^ S[ 5] ^ S[ 9] ^ S[11] ^ S[19] ^ S[25] ^ S[31];
        S2[ 6] = S[ 0] ^ S[ 2] ^ S[10] ^ S[12] ^ S[20] ^ S[24] ^ S[26] ^ S[30];
        S2[ 7] = S[ 1] ^ S[ 3] ^ S[11] ^ S[13] ^ S[21] ^ S[25] ^ S[27] ^ S[31];
        S2[ 8] = S[ 0] ^ S[ 6] ^ S[12] ^ S[14] ^ S[22] ^ S[24] ^ S[26] ^ S[28] ^ S[30];
        S2[ 9] = S[ 1] ^ S[ 7] ^ S[13] ^ S[15] ^ S[23] ^ S[25] ^ S[27] ^ S[29] ^ S[31];
        S2[10] = S[ 0] ^ S[ 4] ^ S[ 6] ^ S[ 8] ^ S[14] ^ S[16] ^ S[26] ^ S[28];
        S2[11] = S[ 1] ^ S[ 5] ^ S[ 7] ^ S[ 9] ^ S[15] ^ S[17] ^ S[27] ^ S[29];
        S2[12] = S[ 2] ^ S[ 6] ^ S[ 8] ^ S[10] ^ S[16] ^ S[18] ^ S[28] ^ S[30];
        S2[13] = S[ 3] ^ S[ 7] ^ S[ 9] ^ S[11] ^ S[17] ^ S[19] ^ S[29] ^ S[31];
        S2[14] = S[ 0] ^ S[ 2] ^ S[ 6] ^ S[ 8] ^ S[10] ^ S[12] ^ S[18] ^ S[20] ^ S[24];
        S2[15] = S[ 1] ^ S[ 3] ^ S[ 7] ^ S[ 9] ^ S[11] ^ S[13] ^ S[19] ^ S[21] ^ S[25];
        S2[16] = S[ 2] ^ S[ 4] ^ S[ 8] ^ S[10] ^ S[12] ^ S[14] ^ S[20] ^ S[22] ^ S[26];
        S2[17] = S[ 3] ^ S[ 5] ^ S[ 9] ^ S[11] ^ S[13] ^ S[15] ^ S[21] ^ S[23] ^ S[27];
        S2[18] = S[ 4] ^ S[ 6] ^ S[10] ^ S[12] ^ S[14] ^ S[16] ^ S[22] ^ S[24] ^ S[28];
        S2[19] = S[ 5] ^ S[ 7] ^ S[11] ^ S[13] ^ S[15] ^ S[17] ^ S[23] ^ S[25] ^ S[29];
        S2[20] = S[ 6] ^ S[ 8] ^ S[12] ^ S[14] ^ S[16] ^ S[18] ^ S[24] ^ S[26] ^ S[30];
        S2[21] = S[ 7] ^ S[ 9] ^ S[13] ^ S[15] ^ S[17] ^ S[19] ^ S[25] ^ S[27] ^ S[31];
        S2[22] = S[ 0] ^ S[ 2] ^ S[ 4] ^ S[ 6] ^ S[ 8] ^ S[10] ^ S[14] ^ S[16] ^
                 S[18] ^ S[20] ^ S[24] ^ S[26] ^ S[28] ^ S[30];
        S2[23] = S[ 1] ^ S[ 3] ^ S[ 5] ^ S[ 7] ^ S[ 9] ^ S[11] ^ S[15] ^ S[17] ^
                 S[19] ^ S[21] ^ S[25] ^ S[27] ^ S[29] ^ S[31];
        S2[24] = S[ 0] ^ S[ 8] ^ S[10] ^ S[12] ^ S[16] ^ S[18] ^ S[20] ^ S[22] ^
                 S[24] ^ S[26] ^ S[28];
        S2[25] = S[ 1] ^ S[ 9] ^ S[11] ^ S[13] ^ S[17] ^ S[19] ^ S[21] ^ S[23] ^
                 S[25] ^ S[27] ^ S[29];
        S2[26] = S[ 2] ^ S[10] ^ S[12] ^ S[14] ^ S[18] ^ S[20] ^ S[22] ^ S[24] ^
                 S[26] ^ S[28] ^ S[30];
        S2[27] = S[ 3] ^ S[11] ^ S[13] ^ S[15] ^ S[19] ^ S[21] ^ S[23] ^ S[25] ^
                 S[27] ^ S[29] ^ S[31];
        S2[28] = S[ 0] ^ S[ 2] ^ S[ 6] ^ S[12] ^ S[14] ^ S[16] ^ S[20] ^ S[22] ^ S[26] ^ S[28];
        S2[29] = S[ 1] ^ S[ 3] ^ S[ 7] ^ S[13] ^ S[15] ^ S[17] ^ S[21] ^ S[23] ^ S[27] ^ S[29];
        S2[30] = S[ 2] ^ S[ 4] ^ S[ 8] ^ S[14] ^ S[16] ^ S[18] ^ S[22] ^ S[24] ^ S[28] ^ S[30];
        S2[31] = S[ 3] ^ S[ 5] ^ S[ 9] ^ S[15] ^ S[17] ^ S[19] ^ S[23] ^ S[25] ^ S[29] ^ S[31];

        copy_mem(m_hash.data(), S2, 32);
    }
}
Пример #3
0
/*
* Whirlpool Compression Function
*/
void Whirlpool::compress_n(const byte in[], size_t blocks)
   {
   static const u64bit RC[10] = {
      0x1823C6E887B8014F, 0x36A6D2F5796F9152,
      0x60BC9B8EA30C7B35, 0x1DE0D7C22E4BFE57,
      0x157737E59FF04ADA, 0x58C9290AB1A06B85,
      0xBD5D10F4CB3E0567, 0xE427418BA77D95D8,
      0xFBEE7C66DD17479E, 0xCA2DBF07AD5A8333
   };

   for(size_t i = 0; i != blocks; ++i)
      {
      load_be(&M[0], in, M.size());

      u64bit K0, K1, K2, K3, K4, K5, K6, K7;
      K0 = digest[0]; K1 = digest[1]; K2 = digest[2]; K3 = digest[3];
      K4 = digest[4]; K5 = digest[5]; K6 = digest[6]; K7 = digest[7];

      u64bit B0, B1, B2, B3, B4, B5, B6, B7;
      B0 = K0 ^ M[0]; B1 = K1 ^ M[1]; B2 = K2 ^ M[2]; B3 = K3 ^ M[3];
      B4 = K4 ^ M[4]; B5 = K5 ^ M[5]; B6 = K6 ^ M[6]; B7 = K7 ^ M[7];

      for(size_t j = 0; j != 10; ++j)
         {
         u64bit T0, T1, T2, T3, T4, T5, T6, T7;
         T0 = C0[get_byte(0, K0)] ^ C1[get_byte(1, K7)] ^
              C2[get_byte(2, K6)] ^ C3[get_byte(3, K5)] ^
              C4[get_byte(4, K4)] ^ C5[get_byte(5, K3)] ^
              C6[get_byte(6, K2)] ^ C7[get_byte(7, K1)] ^ RC[j];
         T1 = C0[get_byte(0, K1)] ^ C1[get_byte(1, K0)] ^
              C2[get_byte(2, K7)] ^ C3[get_byte(3, K6)] ^
              C4[get_byte(4, K5)] ^ C5[get_byte(5, K4)] ^
              C6[get_byte(6, K3)] ^ C7[get_byte(7, K2)];
         T2 = C0[get_byte(0, K2)] ^ C1[get_byte(1, K1)] ^
              C2[get_byte(2, K0)] ^ C3[get_byte(3, K7)] ^
              C4[get_byte(4, K6)] ^ C5[get_byte(5, K5)] ^
              C6[get_byte(6, K4)] ^ C7[get_byte(7, K3)];
         T3 = C0[get_byte(0, K3)] ^ C1[get_byte(1, K2)] ^
              C2[get_byte(2, K1)] ^ C3[get_byte(3, K0)] ^
              C4[get_byte(4, K7)] ^ C5[get_byte(5, K6)] ^
              C6[get_byte(6, K5)] ^ C7[get_byte(7, K4)];
         T4 = C0[get_byte(0, K4)] ^ C1[get_byte(1, K3)] ^
              C2[get_byte(2, K2)] ^ C3[get_byte(3, K1)] ^
              C4[get_byte(4, K0)] ^ C5[get_byte(5, K7)] ^
              C6[get_byte(6, K6)] ^ C7[get_byte(7, K5)];
         T5 = C0[get_byte(0, K5)] ^ C1[get_byte(1, K4)] ^
              C2[get_byte(2, K3)] ^ C3[get_byte(3, K2)] ^
              C4[get_byte(4, K1)] ^ C5[get_byte(5, K0)] ^
              C6[get_byte(6, K7)] ^ C7[get_byte(7, K6)];
         T6 = C0[get_byte(0, K6)] ^ C1[get_byte(1, K5)] ^
              C2[get_byte(2, K4)] ^ C3[get_byte(3, K3)] ^
              C4[get_byte(4, K2)] ^ C5[get_byte(5, K1)] ^
              C6[get_byte(6, K0)] ^ C7[get_byte(7, K7)];
         T7 = C0[get_byte(0, K7)] ^ C1[get_byte(1, K6)] ^
              C2[get_byte(2, K5)] ^ C3[get_byte(3, K4)] ^
              C4[get_byte(4, K3)] ^ C5[get_byte(5, K2)] ^
              C6[get_byte(6, K1)] ^ C7[get_byte(7, K0)];

         K0 = T0; K1 = T1; K2 = T2; K3 = T3;
         K4 = T4; K5 = T5; K6 = T6; K7 = T7;

         T0 = C0[get_byte(0, B0)] ^ C1[get_byte(1, B7)] ^
              C2[get_byte(2, B6)] ^ C3[get_byte(3, B5)] ^
              C4[get_byte(4, B4)] ^ C5[get_byte(5, B3)] ^
              C6[get_byte(6, B2)] ^ C7[get_byte(7, B1)] ^ K0;
         T1 = C0[get_byte(0, B1)] ^ C1[get_byte(1, B0)] ^
              C2[get_byte(2, B7)] ^ C3[get_byte(3, B6)] ^
              C4[get_byte(4, B5)] ^ C5[get_byte(5, B4)] ^
              C6[get_byte(6, B3)] ^ C7[get_byte(7, B2)] ^ K1;
         T2 = C0[get_byte(0, B2)] ^ C1[get_byte(1, B1)] ^
              C2[get_byte(2, B0)] ^ C3[get_byte(3, B7)] ^
              C4[get_byte(4, B6)] ^ C5[get_byte(5, B5)] ^
              C6[get_byte(6, B4)] ^ C7[get_byte(7, B3)] ^ K2;
         T3 = C0[get_byte(0, B3)] ^ C1[get_byte(1, B2)] ^
              C2[get_byte(2, B1)] ^ C3[get_byte(3, B0)] ^
              C4[get_byte(4, B7)] ^ C5[get_byte(5, B6)] ^
              C6[get_byte(6, B5)] ^ C7[get_byte(7, B4)] ^ K3;
         T4 = C0[get_byte(0, B4)] ^ C1[get_byte(1, B3)] ^
              C2[get_byte(2, B2)] ^ C3[get_byte(3, B1)] ^
              C4[get_byte(4, B0)] ^ C5[get_byte(5, B7)] ^
              C6[get_byte(6, B6)] ^ C7[get_byte(7, B5)] ^ K4;
         T5 = C0[get_byte(0, B5)] ^ C1[get_byte(1, B4)] ^
              C2[get_byte(2, B3)] ^ C3[get_byte(3, B2)] ^
              C4[get_byte(4, B1)] ^ C5[get_byte(5, B0)] ^
              C6[get_byte(6, B7)] ^ C7[get_byte(7, B6)] ^ K5;
         T6 = C0[get_byte(0, B6)] ^ C1[get_byte(1, B5)] ^
              C2[get_byte(2, B4)] ^ C3[get_byte(3, B3)] ^
              C4[get_byte(4, B2)] ^ C5[get_byte(5, B1)] ^
              C6[get_byte(6, B0)] ^ C7[get_byte(7, B7)] ^ K6;
         T7 = C0[get_byte(0, B7)] ^ C1[get_byte(1, B6)] ^
              C2[get_byte(2, B5)] ^ C3[get_byte(3, B4)] ^
              C4[get_byte(4, B3)] ^ C5[get_byte(5, B2)] ^
              C6[get_byte(6, B1)] ^ C7[get_byte(7, B0)] ^ K7;

         B0 = T0; B1 = T1; B2 = T2; B3 = T3;
         B4 = T4; B5 = T5; B6 = T6; B7 = T7;
         }

      digest[0] ^= B0 ^ M[0];
      digest[1] ^= B1 ^ M[1];
      digest[2] ^= B2 ^ M[2];
      digest[3] ^= B3 ^ M[3];
      digest[4] ^= B4 ^ M[4];
      digest[5] ^= B5 ^ M[5];
      digest[6] ^= B6 ^ M[6];
      digest[7] ^= B7 ^ M[7];

      in += hash_block_size();
      }
   }
Пример #4
0
/*
* AES Encryption
*/
void aes_encrypt_n(const uint8_t in[], uint8_t out[],
                   size_t blocks,
                   const secure_vector<uint32_t>& EK,
                   const secure_vector<uint8_t>& ME)
   {
   BOTAN_ASSERT(EK.size() && ME.size() == 16, "Key was set");

   const size_t cache_line_size = CPUID::cache_line_size();

   const std::vector<uint32_t>& TE = AES_TE();

   // Hit every cache line of TE
   uint32_t Z = 0;
   for(size_t i = 0; i < TE.size(); i += cache_line_size / sizeof(uint32_t))
      {
      Z |= TE[i];
      }
   Z &= TE[82]; // this is zero, which hopefully the compiler cannot deduce

   BOTAN_PARALLEL_FOR(size_t i = 0; i < blocks; ++i)
      {
      uint32_t T0, T1, T2, T3;
      load_be(in + 16*i, T0, T1, T2, T3);

      T0 ^= EK[0];
      T1 ^= EK[1];
      T2 ^= EK[2];
      T3 ^= EK[3];

      T0 ^= Z;

      /* Use only the first 256 entries of the TE table and do the
      * rotations directly in the code. This reduces the number of
      * cache lines potentially used in the first round from 64 to 16
      * (assuming a typical 64 byte cache line), which makes timing
      * attacks a little harder; the first round is particularly
      * vulnerable.
      */

      uint32_t B0 = TE[get_byte(0, T0)] ^
                  rotate_right(TE[get_byte(1, T1)],  8) ^
                  rotate_right(TE[get_byte(2, T2)], 16) ^
                  rotate_right(TE[get_byte(3, T3)], 24) ^ EK[4];

      uint32_t B1 = TE[get_byte(0, T1)] ^
                  rotate_right(TE[get_byte(1, T2)],  8) ^
                  rotate_right(TE[get_byte(2, T3)], 16) ^
                  rotate_right(TE[get_byte(3, T0)], 24) ^ EK[5];

      uint32_t B2 = TE[get_byte(0, T2)] ^
                  rotate_right(TE[get_byte(1, T3)],  8) ^
                  rotate_right(TE[get_byte(2, T0)], 16) ^
                  rotate_right(TE[get_byte(3, T1)], 24) ^ EK[6];

      uint32_t B3 = TE[get_byte(0, T3)] ^
                  rotate_right(TE[get_byte(1, T0)],  8) ^
                  rotate_right(TE[get_byte(2, T1)], 16) ^
                  rotate_right(TE[get_byte(3, T2)], 24) ^ EK[7];

      for(size_t r = 2*4; r < EK.size(); r += 2*4)
         {
         T0 = EK[r  ] ^ TE[get_byte(0, B0)      ] ^ TE[get_byte(1, B1) + 256] ^
                        TE[get_byte(2, B2) + 512] ^ TE[get_byte(3, B3) + 768];
         T1 = EK[r+1] ^ TE[get_byte(0, B1)      ] ^ TE[get_byte(1, B2) + 256] ^
                        TE[get_byte(2, B3) + 512] ^ TE[get_byte(3, B0) + 768];
         T2 = EK[r+2] ^ TE[get_byte(0, B2)      ] ^ TE[get_byte(1, B3) + 256] ^
                        TE[get_byte(2, B0) + 512] ^ TE[get_byte(3, B1) + 768];
         T3 = EK[r+3] ^ TE[get_byte(0, B3)      ] ^ TE[get_byte(1, B0) + 256] ^
                        TE[get_byte(2, B1) + 512] ^ TE[get_byte(3, B2) + 768];

         B0 = EK[r+4] ^ TE[get_byte(0, T0)      ] ^ TE[get_byte(1, T1) + 256] ^
                        TE[get_byte(2, T2) + 512] ^ TE[get_byte(3, T3) + 768];
         B1 = EK[r+5] ^ TE[get_byte(0, T1)      ] ^ TE[get_byte(1, T2) + 256] ^
                        TE[get_byte(2, T3) + 512] ^ TE[get_byte(3, T0) + 768];
         B2 = EK[r+6] ^ TE[get_byte(0, T2)      ] ^ TE[get_byte(1, T3) + 256] ^
                        TE[get_byte(2, T0) + 512] ^ TE[get_byte(3, T1) + 768];
         B3 = EK[r+7] ^ TE[get_byte(0, T3)      ] ^ TE[get_byte(1, T0) + 256] ^
                        TE[get_byte(2, T1) + 512] ^ TE[get_byte(3, T2) + 768];
         }

      out[16*i+ 0] = SE[get_byte(0, B0)] ^ ME[0];
      out[16*i+ 1] = SE[get_byte(1, B1)] ^ ME[1];
      out[16*i+ 2] = SE[get_byte(2, B2)] ^ ME[2];
      out[16*i+ 3] = SE[get_byte(3, B3)] ^ ME[3];
      out[16*i+ 4] = SE[get_byte(0, B1)] ^ ME[4];
      out[16*i+ 5] = SE[get_byte(1, B2)] ^ ME[5];
      out[16*i+ 6] = SE[get_byte(2, B3)] ^ ME[6];
      out[16*i+ 7] = SE[get_byte(3, B0)] ^ ME[7];
      out[16*i+ 8] = SE[get_byte(0, B2)] ^ ME[8];
      out[16*i+ 9] = SE[get_byte(1, B3)] ^ ME[9];
      out[16*i+10] = SE[get_byte(2, B0)] ^ ME[10];
      out[16*i+11] = SE[get_byte(3, B1)] ^ ME[11];
      out[16*i+12] = SE[get_byte(0, B3)] ^ ME[12];
      out[16*i+13] = SE[get_byte(1, B0)] ^ ME[13];
      out[16*i+14] = SE[get_byte(2, B1)] ^ ME[14];
      out[16*i+15] = SE[get_byte(3, B2)] ^ ME[15];
      }
   }
Пример #5
0
static void load_pbobbl2x(void)
{
   int ta,tb,tc;

   RAMSize=0x80000;

   if(!(RAM=AllocateMem(0x80000))) return;
   if(!(ROM=AllocateMem(0x100000))) return;
   if(!(GFX=AllocateMem(0x3F5D00+0x3EC700))) return;

   GFX_BG0 = GFX+0x3F5D00;
   GFX_SPR = GFX+0x000000;

   tb=0;
   if(!load_rom("e10-02.rom", ROM, 0xFD740)) return;	// 16x16 SPRITES ($3F5D)
   for(ta=0;ta<0xFD740;ta++){
      GFX[tb++]=ROM[ta]&15;
      GFX[tb++]=ROM[ta]>>4;
      tb+=2;
   }
   tb=2;
   if(!load_rom("e10-01.rom", ROM, 0xFD740)) return;	// 16x16 SPRITES
   for(ta=0;ta<0xFD740;ta++){
      GFX[tb++]=ROM[ta]&15;
      GFX[tb++]=ROM[ta]>>4;
      tb+=2;
   }
   tb=0;
   if(!load_rom("e10-07.rom", ROM, 0xFB1C0)) return;	// 16x16 TILES ($3EC7)
   for(ta=0;ta<0xFB1C0;ta+=2){
      GFX_BG0[tb++]=ROM[ta]&15;
      GFX_BG0[tb++]=ROM[ta]>>4;
      GFX_BG0[tb++]=ROM[ta+1]&15;
      GFX_BG0[tb++]=ROM[ta+1]>>4;
      tb+=4;
   }
   tb=4;
   if(!load_rom("e10-06.rom", ROM, 0xFB1C0)) return;	// 16x16 TILES
   for(ta=0;ta<0xFB1C0;ta+=2){
      GFX_BG0[tb++]=ROM[ta]&15;
      GFX_BG0[tb++]=ROM[ta]>>4;
      GFX_BG0[tb++]=ROM[ta+1]&15;
      GFX_BG0[tb++]=ROM[ta+1]>>4;
      tb+=4;
   }
   tb=0;
   if(!load_rom("e10-05.rom", ROM, 0xFB1C0)) return;	// 16x16 TILES (MASK)
   for(ta=0;ta<0xFB1C0;ta+=2){
      tc=ROM[ta];
      GFX_BG0[tb+7]|=((tc&0x80)>>7)<<4;
      GFX_BG0[tb+6]|=((tc&0x40)>>6)<<4;
      GFX_BG0[tb+5]|=((tc&0x20)>>5)<<4;
      GFX_BG0[tb+4]|=((tc&0x10)>>4)<<4;
      GFX_BG0[tb+3]|=((tc&0x08)>>3)<<4;
      GFX_BG0[tb+2]|=((tc&0x04)>>2)<<4;
      GFX_BG0[tb+1]|=((tc&0x02)>>1)<<4;
      GFX_BG0[tb+0]|=((tc&0x01)>>0)<<4;
      tc=ROM[ta+1];
      GFX_BG0[tb+7]|=((tc&0x80)>>7)<<5;
      GFX_BG0[tb+6]|=((tc&0x40)>>6)<<5;
      GFX_BG0[tb+5]|=((tc&0x20)>>5)<<5;
      GFX_BG0[tb+4]|=((tc&0x10)>>4)<<5;
      GFX_BG0[tb+3]|=((tc&0x08)>>3)<<5;
      GFX_BG0[tb+2]|=((tc&0x04)>>2)<<5;
      GFX_BG0[tb+1]|=((tc&0x02)>>1)<<5;
      GFX_BG0[tb+0]|=((tc&0x01)>>0)<<5;
      tb+=8;
   }

   GFX_BG0_SOLID = make_solid_mask_16x16(GFX_BG0, 0x3EC7);
   GFX_SPR_SOLID = make_solid_mask_16x16(GFX_SPR, 0x3F5D);

   GFX_BG0_PENS = make_colour_count_16x16(GFX_BG0, 0x3EC7);

   // Setup 68020 Memory Map
   // ----------------------

   AddF3MemoryMap(0x100000);

   RAM_BG0=RAM+0x33000;
   RAM_BG1=RAM+0x32000;
   RAM_BG2=RAM+0x31000;
   RAM_BG3=RAM+0x30000;

   RAM_SCR0=RAM+0x6A006;
   RAM_SCR1=RAM+0x6A004;
   RAM_SCR2=RAM+0x6A002;
   RAM_SCR3=RAM+0x6A000;

   SCR3_XOFS=0xF640;
   SCR2_XOFS=0xF740;
   SCR1_XOFS=0xF840;
   SCR0_XOFS=0xF940;

   SCR3_YOFS=0xF400;
   SCR2_YOFS=0xF400;
   SCR1_YOFS=0xF400;
   SCR0_YOFS=0xF400;

   if(!load_rom("e10.29", RAM, 0x40000)) return;
   for(ta=0;ta<0x40000;ta++){
      ROM[(ta<<2)+0]=RAM[ta];
   }
   if(!load_rom("e10.28", RAM, 0x40000)) return;
   for(ta=0;ta<0x40000;ta++){
      ROM[(ta<<2)+1]=RAM[ta];
   }
   if(!load_rom("e10.27", RAM, 0x40000)) return;
   for(ta=0;ta<0x40000;ta++){
      ROM[(ta<<2)+2]=RAM[ta];
   }
   if(!load_rom("e10.26", RAM, 0x40000)) return;
   for(ta=0;ta<0x40000;ta++){
      ROM[(ta<<2)+3]=RAM[ta];
   }

   // 68000 code
   M68000ROM = load_region[REGION_ROM2];
   if(!(PCMROM=AllocateMem(0x800000))) return;
   load_be("e10-03.rom",PCMROM,0x200000);
   load_be("e10-04.rom",PCMROM+0x400000,0x200000);
   max_banks_this_game=3; //=memory_region_length(REGION_SOUND1)/0x400000;

   memset(RAM+0x00000,0x00,0x80000);
   memset(RAM+0x69000,0xFF,0x01000);

   // EEPROM ACCESS
   // -------------

   WriteWord68k(&ROM[0x0044D2],0x7F00);		//	raine	#$00 <eeprom access>
   WriteWord68k(&ROM[0x0044D4],0x4ED6);		//	jmp	(a6)

   // SPEED HACK
   // ----------

   WriteWord68k(&ROM[0x031D4],0x4EF9);		//	jmp	$F8000
   WriteLong68k(&ROM[0x031D6],0x000F8000);

   WriteWord68k(&ROM[0xF8000],0x4EB9);		//	jsr	$0291C <random gen>
   WriteLong68k(&ROM[0xF8002],0x0000291C);
   WriteWord68k(&ROM[0xF8006],0x7F02);		//	raine	#$02 <stop cpu>
   WriteWord68k(&ROM[0xF8008],0x6100-10);	//	bra.s	<loop>

   F3SystemEEPROMAccess=&F3SysEEPROMAccessMode2;


   set_colour_mapper(&col_map_xxxx_xxxx_rrrr_rrrr_gggg_gggg_bbbb_bbbb);
   InitPaletteMap(RAM+0x60000, 0x200, 0x40, 0x8000);


   // Init tc0003vcu emulation
   // ------------------------

   tc0003vcu.RAM	= RAM+0x20000;
   tc0003vcu.mapper	= &Map_24bit_xRGB;
   tc0003vcu.bmp_x	= 64;
   tc0003vcu.bmp_y	= 64;
   tc0003vcu.bmp_w	= 320;
   tc0003vcu.bmp_h	= 232;
   tc0003vcu.scr_x	= 0;
   tc0003vcu.scr_y	= 0;

   // Init tc0200obj emulation
   // ------------------------

   tc0200obj.RAM	= RAM+0x20000;
   tc0200obj.RAM_B	= RAM+0x28000;
   tc0200obj.GFX	= GFX_SPR;
   tc0200obj.MASK	= GFX_SPR_SOLID;
   tc0200obj.bmp_x	= 64;
   tc0200obj.bmp_y	= 64;
   tc0200obj.bmp_w	= 320;
   tc0200obj.bmp_h	= 232;
   tc0200obj.mapper	= &Map_24bit_xRGB;
   tc0200obj.tile_mask	= 0x3FFF;
   tc0200obj.ofs_x	= 0-0x2E;
   tc0200obj.ofs_y	= 0-0x18;

   tc0200obj.cols	= 16;

   init_tc0200obj();

   init_f3_system_ioc(F3_IOC_2P_3BUTTON);

   init_m68k();
   setup_sound_68000();
}
Пример #6
0
static void load_puchicar(void)
{
   int ta,tb,tc;

   RAMSize=0x80000;

   if(!(RAM=AllocateMem(0x80000))) return;
   if(!(ROM=AllocateMem(0x200000))) return;
   if(!(GFX=AllocateMem(0xF17A00+0x3F0800))) return;

   GFX_BG0 = GFX+0xF17A00;
   GFX_SPR = GFX+0x000000;

   tb=0;
   if(!load_rom("e46.06", ROM, 0x200000)) return;       // 16x16 SPRITES ($8000)
   for(ta=0;ta<0x200000;ta++,tb+=4){
      WriteWord(&GFX_SPR[tb],((ROM[ta])|(ROM[ta]<<4))&0x0F0F);
   }
   tb=2;
   if(!load_rom("e46.04", ROM, 0x200000)) return;       // 16x16 SPRITES
   for(ta=0;ta<0x200000;ta++,tb+=4){
      WriteWord(&GFX_SPR[tb],((ROM[ta])|(ROM[ta]<<4))&0x0F0F);
   }
   tb=0;
   if(!load_rom("e46.02", ROM, 0x200000)) return;       // 16x16 SPRITES (MASK)
   for(ta=0;ta<0x200000;ta++){
      tc=ROM[ta];
      GFX[tb+3]|=((tc&0x40)>>6)<<4;
      GFX[tb+2]|=((tc&0x10)>>4)<<4;
      GFX[tb+1]|=((tc&0x04)>>2)<<4;
      GFX[tb+0]|=((tc&0x01)>>0)<<4;
      tb+=4;
   }
   tb=0x800000;
   if(!load_rom("e46.05", ROM, 0x1C5E80)) return;       // 16x16 SPRITES ($717A)
   for(ta=0;ta<0x1C5E80;ta++,tb+=4){
      WriteWord(&GFX_SPR[tb],((ROM[ta])|(ROM[ta]<<4))&0x0F0F);
   }
   tb=0x800002;
   if(!load_rom("e46.03", ROM, 0x1C5E80)) return;       // 16x16 SPRITES
   for(ta=0;ta<0x1C5E80;ta++,tb+=4){
      WriteWord(&GFX_SPR[tb],((ROM[ta])|(ROM[ta]<<4))&0x0F0F);
   }
   tb=0x800000;
   if(!load_rom("e46.01", ROM, 0x1C5E80)) return;       // 16x16 SPRITES (MASK)
   for(ta=0;ta<0x1C5E80;ta++){
      tc=ROM[ta];
      GFX[tb+3]|=((tc&0x40)>>6)<<4;
      GFX[tb+2]|=((tc&0x10)>>4)<<4;
      GFX[tb+1]|=((tc&0x04)>>2)<<4;
      GFX[tb+0]|=((tc&0x01)>>0)<<4;
      tb+=4;
   }

   tb=0;
   if(!load_rom("e46.12", ROM, 0xFC200)) return;                // 16x16 TILES ($3F08)
   for(ta=0;ta<0xFC200;ta+=2,tb+=8){
      WriteWord(&GFX_BG0[tb+0],((ROM[ta+0])|(ROM[ta+0]<<4))&0x0F0F);
      WriteWord(&GFX_BG0[tb+2],((ROM[ta+1])|(ROM[ta+1]<<4))&0x0F0F);
   }
   tb=4;
   if(!load_rom("e46.11", ROM, 0xFC200)) return;                // 16x16 TILES
   for(ta=0;ta<0xFC200;ta+=2,tb+=8){
      WriteWord(&GFX_BG0[tb+0],((ROM[ta+0])|(ROM[ta+0]<<4))&0x0F0F);
      WriteWord(&GFX_BG0[tb+2],((ROM[ta+1])|(ROM[ta+1]<<4))&0x0F0F);
   }
   tb=0;
   if(!load_rom("e46.10", ROM, 0xFC200)) return;                // 16x16 TILES (MASK)
   for(ta=0;ta<0xFC200;ta+=2){
      tc=ROM[ta];
      GFX_BG0[tb+7]|=((tc&0x80)>>7)<<4;
      GFX_BG0[tb+6]|=((tc&0x40)>>6)<<4;
      GFX_BG0[tb+5]|=((tc&0x20)>>5)<<4;
      GFX_BG0[tb+4]|=((tc&0x10)>>4)<<4;
      GFX_BG0[tb+3]|=((tc&0x08)>>3)<<4;
      GFX_BG0[tb+2]|=((tc&0x04)>>2)<<4;
      GFX_BG0[tb+1]|=((tc&0x02)>>1)<<4;
      GFX_BG0[tb+0]|=((tc&0x01)>>0)<<4;
      tc=ROM[ta+1];
      GFX_BG0[tb+7]|=((tc&0x80)>>7)<<5;
      GFX_BG0[tb+6]|=((tc&0x40)>>6)<<5;
      GFX_BG0[tb+5]|=((tc&0x20)>>5)<<5;
      GFX_BG0[tb+4]|=((tc&0x10)>>4)<<5;
      GFX_BG0[tb+3]|=((tc&0x08)>>3)<<5;
      GFX_BG0[tb+2]|=((tc&0x04)>>2)<<5;
      GFX_BG0[tb+1]|=((tc&0x02)>>1)<<5;
      GFX_BG0[tb+0]|=((tc&0x01)>>0)<<5;
      tb+=8;
   }

   GFX_BG0_SOLID = MakeSolidTileMap16x16(GFX_BG0, 0x3F08);
   GFX_SPR_SOLID = make_solid_mask_16x16(GFX_SPR, 0xF17A);

   FreeMem(ROM);
   ROM = load_region[REGION_CPU1];

   // Setup 68020 Memory Map
   // ----------------------

   AddF3MemoryMap(0x100000);

   RAM_BG0=RAM+0x30000;
   RAM_BG1=RAM+0x32000;
   RAM_BG2=RAM+0x34000;
   RAM_BG3=RAM+0x36000;

   RAM_SCR0=RAM+0x6A000;
   RAM_SCR1=RAM+0x6A002;
   RAM_SCR2=RAM+0x6A004;
   RAM_SCR3=RAM+0x6A006;

   SCR0_XOFS=0xF600;
   SCR1_XOFS=0xF700;
   SCR2_XOFS=0xF800;
   SCR3_XOFS=0xF900;

   SCR0_YOFS=0xFF80;
   SCR1_YOFS=0xFF80;
   SCR2_YOFS=0xFF80;
   SCR3_YOFS=0xFF80;

   // 68000 code
   M68000ROM = load_region[REGION_ROM2];
   if(!(PCMROM=AllocateMem(0xe00004))) return;
   load_be("e46.09",PCMROM,0x200000);
   load_be("e46.08",PCMROM+0x400000,0x200000);
   load_be("e46.07",PCMROM+0x800000,0x200000);
   max_banks_this_game=6; //=memory_region_length(REGION_SOUND1)/0x400000;

   memset(PCMROM+0xc00000,0x0,0x200003);
   memset(RAM+0x00000,0x00,0x80000);
   memset(RAM+0x69000,0xFF,0x01000);

   // EEPROM HACKS
   // ------------

   WriteWord68k(&ROM[0x0019C4],0x7F00); 	//	raine	#$00 <read/write eeprom>
   WriteWord68k(&ROM[0x0019C6],0x4ED6); 	//	jmp	(a6)

   // SPEED HACK#1
   // ------------

   // WriteWord68k(&ROM[0x009DC],0x7F02);		//	raine	#$02 <stop cpu>

   WriteWord68k(&ROM[0x009A4],0x7F02);		//	raine	#$02 <stop cpu>
   WriteWord68k(&ROM[0x009A6],0x4E71);		//	nop
   WriteWord68k(&ROM[0x009A8],0x4E71);		//	nop
   WriteWord68k(&ROM[0x009AA],0x4E71);		//	nop

   F3SystemEEPROMAccess=&F3SysEEPROMAccessMode2;


   set_colour_mapper(&col_map_xxxx_xxxx_rrrr_rrrr_gggg_gggg_bbbb_bbbb);
   InitPaletteMap(RAM+0x60000, 0x200, 0x40, 0x8000);

   // Init tc0003vcu emulation
   // ------------------------

   tc0003vcu.RAM	= RAM+0x20000;
// Mapper disabled
   tc0003vcu.bmp_x	= 64;
   tc0003vcu.bmp_y	= 64;
   tc0003vcu.bmp_w	= 320;
   tc0003vcu.bmp_h	= 232;
   tc0003vcu.scr_x	= 0;
   tc0003vcu.scr_y	= 0;

   // Init tc0200obj emulation
   // ------------------------

   tc0200obj.RAM	= RAM+0x20000;
   tc0200obj.RAM_B	= RAM+0x28000;
   tc0200obj.GFX	= GFX_SPR;
   tc0200obj.MASK	= GFX_SPR_SOLID;
   tc0200obj.bmp_x	= 64;
   tc0200obj.bmp_y	= 64;
   tc0200obj.bmp_w	= 320;
   tc0200obj.bmp_h	= 232;
// Mapper disabled
   tc0200obj.tile_mask	= 0xFFFF;
   tc0200obj.ofs_x	= 0-0x2E;
   tc0200obj.ofs_y	= 0-0x18;

   tc0200obj.cols	= 32;

   init_tc0200obj();

   init_f3_system_ioc(F3_IOC_2P_3BUTTON | F3_IOC_TRACKBALL);

   init_m68k();
   setup_sound_68000();
}
Пример #7
0
static void load_gekirido(void)
{
    int ta,tb,tc;

    RAMSize=0x80000;

    if(!(GFX=AllocateMem(0x698900+0x544800))) return;
    if(!(RAM=AllocateMem(0x80000))) return;
    if(!(ROM=AllocateMem(0x1A6240))) return;

    GFX_BG0 = GFX+0x000000;
    GFX_SPR = GFX+0x698900;

    if(!load_rom("E11-03.bin", ROM, 0x151200)) return;	// 16x16 SPRITES ($5448)
    tb=0;
    for(ta=0; ta<0x151200; ta++,tb+=4) {
        WriteWord(&GFX_SPR[tb],((ROM[ta])|(ROM[ta]<<4))&0x0F0F);
    }
    if(!load_rom("E11-02.bin", ROM, 0x151200)) return;	// 16x16 SPRITES
    tb=2;
    for(ta=0; ta<0x151200; ta++,tb+=4) {
        WriteWord(&GFX_SPR[tb],((ROM[ta])|(ROM[ta]<<4))&0x0F0F);
    }
    tb=0;
    if(!load_rom("E11-01.bin", ROM, 0x151200)) return;	// 16x16 SPRITES (MASK)
    for(ta=0; ta<0x151200; ta++) {
        tc=ROM[ta];
        GFX_SPR[tb+3]|=((tc&0x40)>>6)<<4;
        GFX_SPR[tb+2]|=((tc&0x10)>>4)<<4;
        GFX_SPR[tb+1]|=((tc&0x04)>>2)<<4;
        GFX_SPR[tb+0]|=((tc&0x01)>>0)<<4;
        tb+=4;
    }

    tb=0;
    if(!load_rom("E11-08.bin", ROM, 0x1A6240)) return;	// 16x16 TILES ($6989)
    for(ta=0; ta<0x1A6240; ta+=2,tb+=8) {
        WriteWord(&GFX_BG0[tb+0],((ROM[ta+0])|(ROM[ta+0]<<4))&0x0F0F);
        WriteWord(&GFX_BG0[tb+2],((ROM[ta+1])|(ROM[ta+1]<<4))&0x0F0F);
    }
    tb=4;
    if(!load_rom("E11-07.bin", ROM, 0x1A6240)) return;	// 16x16 TILES
    for(ta=0; ta<0x1A6240; ta+=2,tb+=8) {
        WriteWord(&GFX_BG0[tb+0],((ROM[ta+0])|(ROM[ta+0]<<4))&0x0F0F);
        WriteWord(&GFX_BG0[tb+2],((ROM[ta+1])|(ROM[ta+1]<<4))&0x0F0F);
    }
    tb=0;
    if(!load_rom("E11-06.bin", ROM, 0x1A6240)) return;	// 16x16 TILES (MASK)
    for(ta=0; ta<0x1A6240; ta+=2) {
        tc=ROM[ta];
        GFX_BG0[tb+7]|=((tc&0x80)>>7)<<4;
        GFX_BG0[tb+6]|=((tc&0x40)>>6)<<4;
        GFX_BG0[tb+5]|=((tc&0x20)>>5)<<4;
        GFX_BG0[tb+4]|=((tc&0x10)>>4)<<4;
        GFX_BG0[tb+3]|=((tc&0x08)>>3)<<4;
        GFX_BG0[tb+2]|=((tc&0x04)>>2)<<4;
        GFX_BG0[tb+1]|=((tc&0x02)>>1)<<4;
        GFX_BG0[tb+0]|=((tc&0x01)>>0)<<4;
        tb+=8;
    }

    FreeMem(ROM);
    if(!(ROM=AllocateMem(0x100000))) return;

    Rotate16x16(GFX_BG0,0x6989);
    Flip16x16_X(GFX_BG0,0x6989);
    Rotate16x16(GFX_SPR,0x5448);
    Flip16x16_X(GFX_SPR,0x5448);

    GFX_BG0_SOLID = MakeSolidTileMap16x16(GFX_BG0, 0x6989);
    GFX_SPR_SOLID = make_solid_mask_16x16(GFX_SPR, 0x5448);

    // Setup 68020 Memory Map
    // ----------------------

    AddF3MemoryMap(0x100000);

    RAM_BG3=RAM+0x30000;
    RAM_BG2=RAM+0x31000;
    RAM_BG1=RAM+0x32000;
    RAM_BG0=RAM+0x33000;

    RAM_SCR3=RAM+0x6A000;
    RAM_SCR2=RAM+0x6A002;
    RAM_SCR1=RAM+0x6A004;
    RAM_SCR0=RAM+0x6A006;

    SCR3_XOFS=0xF900;
    SCR2_XOFS=0xF800;
    SCR1_XOFS=0xF700;
    SCR0_XOFS=0xF600;

    SCR3_YOFS=0xFF80;
    SCR2_YOFS=0xF400;
    SCR1_YOFS=0xF400;
    SCR0_YOFS=0xFF80;

    if(!load_rom("E11-12.bin", RAM, 0x40000)) return;
    for(ta=0; ta<0x40000; ta++) {
        ROM[(ta<<2)+0]=RAM[ta];
    }
    if(!load_rom("E11-11.bin", RAM, 0x40000)) return;
    for(ta=0; ta<0x40000; ta++) {
        ROM[(ta<<2)+1]=RAM[ta];
    }
    if(!load_rom("E11-10.bin", RAM, 0x40000)) return;
    for(ta=0; ta<0x40000; ta++) {
        ROM[(ta<<2)+2]=RAM[ta];
    }
    if(!load_rom("E11-09.bin", RAM, 0x40000)) return;
    for(ta=0; ta<0x40000; ta++) {
        ROM[(ta<<2)+3]=RAM[ta];
    }

    for(ta=0x104F4; ta<0x124F4; ta+=4) {			// swap words
        tb=ReadWord(&ROM[ta]);
        WriteWord(&ROM[ta],ReadWord(&ROM[ta+2]));
        WriteWord(&ROM[ta+2],tb);
    }

    Rotate8x8_4bpp(ROM+0x104F4,0x2000>>5);
    Flip8x8_4bpp_X(ROM+0x104F4,0x2000>>5);

    for(ta=0x104F4; ta<0x124F4; ta+=4) {			// swap words
        tb=ReadWord(&ROM[ta]);
        WriteWord(&ROM[ta],ReadWord(&ROM[ta+2]));
        WriteWord(&ROM[ta+2],tb);
    }

    for(ta=0x8EBD8; ta<0x8EC78; ta+=4) {			// swap words
        tb=ReadWord(&ROM[ta]);
        WriteWord(&ROM[ta],ReadWord(&ROM[ta+2]));
        WriteWord(&ROM[ta+2],tb);
    }

    Rotate8x8_4bpp(ROM+0x8EBD8,0x00A0>>5);
    Flip8x8_4bpp_X(ROM+0x8EBD8,0x00A0>>5);

    for(ta=0x8EBD8; ta<0x8EC78; ta+=4) {			// swap words
        tb=ReadWord(&ROM[ta]);
        WriteWord(&ROM[ta],ReadWord(&ROM[ta+2]));
        WriteWord(&ROM[ta+2],tb);
    }

    for(ta=0xF6820; ta<0xF6D60; ta+=4) {			// swap words
        tb=ReadWord(&ROM[ta]);
        WriteWord(&ROM[ta],ReadWord(&ROM[ta+2]));
        WriteWord(&ROM[ta+2],tb);
    }

    Rotate8x8_4bpp(ROM+0xF6820,0x0540>>5);
    Flip8x8_4bpp_X(ROM+0xF6820,0x0540>>5);

    for(ta=0xF6820; ta<0xF6D60; ta+=4) {			// swap words
        tb=ReadWord(&ROM[ta]);
        WriteWord(&ROM[ta],ReadWord(&ROM[ta+2]));
        WriteWord(&ROM[ta+2],tb);
    }

    // 68000 code
    M68000ROM = load_region[REGION_ROM2];
    if(!(PCMROM=AllocateMem(0x800000))) return;
    load_be("e11-04.bin",PCMROM,0x200000);
    load_be("e11-05.bin",PCMROM+0x400000,0x200000);
    max_banks_this_game=3; //=memory_region_length(REGION_SOUND1)/0x400000;

    memset(RAM+0x00000,0x00,0x80000);
    memset(RAM+0x69000,0xFF,0x01000);

    // EEPROM HACK
    // -----------

    WriteWord68k(&ROM[0x0044F8],0x7F00);		//	raine	#$00	<eeprom read/write>
    WriteWord68k(&ROM[0x0044FA],0x4ED6);		//	jmp	(a6)

    // SPEED HACKS
    // -----------

    WriteWord68k(&ROM[0x002340],0x7F02);		//	raine	#$02 <stop cpu>
    WriteWord68k(&ROM[0x002342],0x6100-10);	//	bra.s	<loop>

    F3SystemEEPROMAccess=&F3SysEEPROMAccessMode2;


    set_colour_mapper(&col_map_xxxx_xxxx_rrrr_rrrr_gggg_gggg_bbbb_bbbb);
    InitPaletteMap(RAM+0x60000, 0x200, 0x40, 0x8000);

    // Init tc0003vcu emulation
    // ------------------------

    tc0003vcu.RAM	= RAM+0x20000;
// Mapper disabled
    tc0003vcu.bmp_x	= 64;
    tc0003vcu.bmp_y	= 64;
    tc0003vcu.bmp_w	= 232;
    tc0003vcu.bmp_h	= 320;
    tc0003vcu.scr_x	= 0;
    tc0003vcu.scr_y	= 0;

    // Init tc0200obj emulation
    // ------------------------

    tc0200obj.RAM	= RAM+0x20000;
    tc0200obj.RAM_B	= RAM+0x28000;
    tc0200obj.GFX	= GFX_SPR;
    tc0200obj.MASK	= GFX_SPR_SOLID;
    tc0200obj.bmp_x	= 64;
    tc0200obj.bmp_y	= 64;
    tc0200obj.bmp_w	= 232;
    tc0200obj.bmp_h	= 320;
// Mapper disabled
    tc0200obj.tile_mask	= 0x7FFF;
    tc0200obj.ofs_x	= 0;	//-16;		//(0-0x0C)-16;		// 0x0C 0x1F
    tc0200obj.ofs_y	= 0;		//0-0x2E;	//(0-0x1F)+15;	// 0x1F 0x2E

    tc0200obj.cols	= 32;

    init_tc0200obj();

    init_f3_system_ioc(F3_IOC_2P_3BUTTON);

    init_m68k();
    setup_sound_68000();
}