;(function(root, factory, undef) {
  if (typeof exports === 'object') {
    // CommonJS
    module.exports = exports = factory(
      require('./core'),
      require('./enc-base64'),
      require('./md5'),
      require('./evpkdf'),
      require('./cipher-core')
    )
  } else if (typeof define === 'function' && define.amd) {
    // AMD
    define([
      './core',
      './enc-base64',
      './md5',
      './evpkdf',
      './cipher-core'
    ], factory)
  } else {
    // Global (browser)
    factory(root.CryptoJS)
  }
})(this, function(CryptoJS) {
  ;(function() {
    // Shortcuts
    var C = CryptoJS
    var C_lib = C.lib
    var BlockCipher = C_lib.BlockCipher
    var C_algo = C.algo

    // Lookup tables
    var SBOX = []
    var INV_SBOX = []
    var SUB_MIX_0 = []
    var SUB_MIX_1 = []
    var SUB_MIX_2 = []
    var SUB_MIX_3 = []
    var INV_SUB_MIX_0 = []
    var INV_SUB_MIX_1 = []
    var INV_SUB_MIX_2 = []
    var INV_SUB_MIX_3 = []

    // Compute lookup tables
    ;(function() {
      // Compute double table
      var d = []
      for (var i = 0; i < 256; i++) {
        if (i < 128) {
          d[i] = i << 1
        } else {
          d[i] = (i << 1) ^ 0x11b
        }
      }

      // Walk GF(2^8)
      var x = 0
      var xi = 0
      for (var i = 0; i < 256; i++) {
        // Compute sbox
        var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4)
        sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63
        SBOX[x] = sx
        INV_SBOX[sx] = x

        // Compute multiplication
        var x2 = d[x]
        var x4 = d[x2]
        var x8 = d[x4]

        // Compute sub bytes, mix columns tables
        var t = (d[sx] * 0x101) ^ (sx * 0x1010100)
        SUB_MIX_0[x] = (t << 24) | (t >>> 8)
        SUB_MIX_1[x] = (t << 16) | (t >>> 16)
        SUB_MIX_2[x] = (t << 8) | (t >>> 24)
        SUB_MIX_3[x] = t

        // Compute inv sub bytes, inv mix columns tables
        var t =
          (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100)
        INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8)
        INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16)
        INV_SUB_MIX_2[sx] = (t << 8) | (t >>> 24)
        INV_SUB_MIX_3[sx] = t

        // Compute next counter
        if (!x) {
          x = xi = 1
        } else {
          x = x2 ^ d[d[d[x8 ^ x2]]]
          xi ^= d[d[xi]]
        }
      }
    })()

    // Precomputed Rcon lookup
    var RCON = [
      0x00,
      0x01,
      0x02,
      0x04,
      0x08,
      0x10,
      0x20,
      0x40,
      0x80,
      0x1b,
      0x36
    ]

    /**
     * AES block cipher algorithm.
     */
    var AES = (C_algo.AES = BlockCipher.extend({
      _doReset: function() {
        // Skip reset of nRounds has been set before and key did not change
        if (this._nRounds && this._keyPriorReset === this._key) {
          return
        }

        // Shortcuts
        var key = (this._keyPriorReset = this._key)
        var keyWords = key.words
        var keySize = key.sigBytes / 4

        // Compute number of rounds
        var nRounds = (this._nRounds = keySize + 6)

        // Compute number of key schedule rows
        var ksRows = (nRounds + 1) * 4

        // Compute key schedule
        var keySchedule = (this._keySchedule = [])
        for (var ksRow = 0; ksRow < ksRows; ksRow++) {
          if (ksRow < keySize) {
            keySchedule[ksRow] = keyWords[ksRow]
          } else {
            var t = keySchedule[ksRow - 1]

            if (!(ksRow % keySize)) {
              // Rot word
              t = (t << 8) | (t >>> 24)

              // Sub word
              t =
                (SBOX[t >>> 24] << 24) |
                (SBOX[(t >>> 16) & 0xff] << 16) |
                (SBOX[(t >>> 8) & 0xff] << 8) |
                SBOX[t & 0xff]

              // Mix Rcon
              t ^= RCON[(ksRow / keySize) | 0] << 24
            } else if (keySize > 6 && ksRow % keySize == 4) {
              // Sub word
              t =
                (SBOX[t >>> 24] << 24) |
                (SBOX[(t >>> 16) & 0xff] << 16) |
                (SBOX[(t >>> 8) & 0xff] << 8) |
                SBOX[t & 0xff]
            }

            keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t
          }
        }

        // Compute inv key schedule
        var invKeySchedule = (this._invKeySchedule = [])
        for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
          var ksRow = ksRows - invKsRow

          if (invKsRow % 4) {
            var t = keySchedule[ksRow]
          } else {
            var t = keySchedule[ksRow - 4]
          }

          if (invKsRow < 4 || ksRow <= 4) {
            invKeySchedule[invKsRow] = t
          } else {
            invKeySchedule[invKsRow] =
              INV_SUB_MIX_0[SBOX[t >>> 24]] ^
              INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^
              INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^
              INV_SUB_MIX_3[SBOX[t & 0xff]]
          }
        }
      },

      encryptBlock: function(M, offset) {
        this._doCryptBlock(
          M,
          offset,
          this._keySchedule,
          SUB_MIX_0,
          SUB_MIX_1,
          SUB_MIX_2,
          SUB_MIX_3,
          SBOX
        )
      },

      decryptBlock: function(M, offset) {
        // Swap 2nd and 4th rows
        var t = M[offset + 1]
        M[offset + 1] = M[offset + 3]
        M[offset + 3] = t

        this._doCryptBlock(
          M,
          offset,
          this._invKeySchedule,
          INV_SUB_MIX_0,
          INV_SUB_MIX_1,
          INV_SUB_MIX_2,
          INV_SUB_MIX_3,
          INV_SBOX
        )

        // Inv swap 2nd and 4th rows
        var t = M[offset + 1]
        M[offset + 1] = M[offset + 3]
        M[offset + 3] = t
      },

      _doCryptBlock: function(
        M,
        offset,
        keySchedule,
        SUB_MIX_0,
        SUB_MIX_1,
        SUB_MIX_2,
        SUB_MIX_3,
        SBOX
      ) {
        // Shortcut
        var nRounds = this._nRounds

        // Get input, add round key
        var s0 = M[offset] ^ keySchedule[0]
        var s1 = M[offset + 1] ^ keySchedule[1]
        var s2 = M[offset + 2] ^ keySchedule[2]
        var s3 = M[offset + 3] ^ keySchedule[3]

        // Key schedule row counter
        var ksRow = 4

        // Rounds
        for (var round = 1; round < nRounds; round++) {
          // Shift rows, sub bytes, mix columns, add round key
          var t0 =
            SUB_MIX_0[s0 >>> 24] ^
            SUB_MIX_1[(s1 >>> 16) & 0xff] ^
            SUB_MIX_2[(s2 >>> 8) & 0xff] ^
            SUB_MIX_3[s3 & 0xff] ^
            keySchedule[ksRow++]
          var t1 =
            SUB_MIX_0[s1 >>> 24] ^
            SUB_MIX_1[(s2 >>> 16) & 0xff] ^
            SUB_MIX_2[(s3 >>> 8) & 0xff] ^
            SUB_MIX_3[s0 & 0xff] ^
            keySchedule[ksRow++]
          var t2 =
            SUB_MIX_0[s2 >>> 24] ^
            SUB_MIX_1[(s3 >>> 16) & 0xff] ^
            SUB_MIX_2[(s0 >>> 8) & 0xff] ^
            SUB_MIX_3[s1 & 0xff] ^
            keySchedule[ksRow++]
          var t3 =
            SUB_MIX_0[s3 >>> 24] ^
            SUB_MIX_1[(s0 >>> 16) & 0xff] ^
            SUB_MIX_2[(s1 >>> 8) & 0xff] ^
            SUB_MIX_3[s2 & 0xff] ^
            keySchedule[ksRow++]

          // Update state
          s0 = t0
          s1 = t1
          s2 = t2
          s3 = t3
        }

        // Shift rows, sub bytes, add round key
        var t0 =
          ((SBOX[s0 >>> 24] << 24) |
            (SBOX[(s1 >>> 16) & 0xff] << 16) |
            (SBOX[(s2 >>> 8) & 0xff] << 8) |
            SBOX[s3 & 0xff]) ^
          keySchedule[ksRow++]
        var t1 =
          ((SBOX[s1 >>> 24] << 24) |
            (SBOX[(s2 >>> 16) & 0xff] << 16) |
            (SBOX[(s3 >>> 8) & 0xff] << 8) |
            SBOX[s0 & 0xff]) ^
          keySchedule[ksRow++]
        var t2 =
          ((SBOX[s2 >>> 24] << 24) |
            (SBOX[(s3 >>> 16) & 0xff] << 16) |
            (SBOX[(s0 >>> 8) & 0xff] << 8) |
            SBOX[s1 & 0xff]) ^
          keySchedule[ksRow++]
        var t3 =
          ((SBOX[s3 >>> 24] << 24) |
            (SBOX[(s0 >>> 16) & 0xff] << 16) |
            (SBOX[(s1 >>> 8) & 0xff] << 8) |
            SBOX[s2 & 0xff]) ^
          keySchedule[ksRow++]

        // Set output
        M[offset] = t0
        M[offset + 1] = t1
        M[offset + 2] = t2
        M[offset + 3] = t3
      },

      keySize: 256 / 32
    }))

    /**
     * Shortcut functions to the cipher's object interface.
     *
     * @example
     *
     *     var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);
     *     var plaintext  = CryptoJS.AES.decrypt(ciphertext, key, cfg);
     */
    C.AES = BlockCipher._createHelper(AES)
  })()

  return CryptoJS.AES
})