Trivium stream cipher with test vectors

trivium.js

"use strict"

/** Class representing the Trivium stream cipher. */
module.exports = class Trivium {
  #state      // Trivium 288-bit state.
  #keystream  // Trivium keystream.

  /**
   * Initialize Trivium with key and IV.
   * @param {Uint8Array} key - An 8-bit array of 10 unsigned integers.
   * @param {Uint8Array} iv - An 8-bit array of 10 unsigned integers.
   * @throws {Error}
   */
  constructor(key, iv) {
    if (typeof key === "undefined") {
      key = new Uint8Array([
        0x53, 0x65, 0x74, 0x20, 0x54, 0x72, 0x69, 0x76, 0x69, 0x75 // "Set Triviu"
      ])
    }

    if (typeof iv === "undefined") {
      iv = new Uint8Array([
        0x6d, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x26, 0x20, 0x49, 0x56 // "m key & IV"
      ])
    }

    if (!(key instanceof Uint8Array) || key.length !== 10) {
      throw new Error("Key should be a 10-element Uint8Array.")
    }

    if (!(iv instanceof Uint8Array) || iv.length !== 10) {
      throw new Error("IV should be a 10-element Uint8Array.")
    }

    this.#state = new Array(288).fill(0)

    const keyBits = []
    const ivBits = []

    for (let i = 0; i < 10; i++) {
      let tmpBits = this.#byteToBits(key[i])
      tmpBits.reverse()

      for (let j = 0; j < 8; j++) {
        keyBits.push(tmpBits[j])
      }

      tmpBits = this.#byteToBits(iv[i])
      tmpBits.reverse()

      for (let j = 0; j < 8; j++) {
        ivBits.push(tmpBits[j])
      }
    }

    keyBits.reverse()
    ivBits.reverse()

    for (let i = 0; i < 80; i++) {
      this.#state[i] = keyBits[i]
      this.#state[i + 93] = ivBits[i]
    }

    this.#state[285] = 1
    this.#state[286] = 1
    this.#state[287] = 1

    for (let i = 0; i < (288 << 2); i++) {
      this.#genKeyStream()
    }
  }

  /**
   * Generates a keystream bit and manipulates the Trivium state. The Trivium
   * state is defined with three non-linear feedback shift registers: s1 (93
   * bits), s2 (84 bits), and s3 (111 bits). Each state is modified
   * independently and each state depends on a single bit from the other,
   * creating a circular dependency on itself.
   * @returns {number} z - A single keystream bit.
   */
  #genKeyStream() {
    let t1 = this.#state[65] ^ this.#state[92]
    let t2 = this.#state[161] ^ this.#state[176]
    let t3 = this.#state[242] ^ this.#state[287]

    let z = t1 ^ t2 ^ t3

    t1 ^= (this.#state[90] & this.#state[91]) ^ this.#state[170]
    t2 ^= (this.#state[174] & this.#state[175]) ^ this.#state[263]
    t3 ^= (this.#state[285] & this.#state[286]) ^ this.#state[68]

    this.#state.pop()

    this.#state.unshift(t3)
    this.#state[93] = t1
    this.#state[177] = t2

    return z
  }

  /**
   * Convert an unsigned 8-bit integer to a bit-array.
   * @param{number} byte - An 8-bit unsigned integer.
   * @returns {Uint8Array} bits - An 8-element bit array.
   */
  #byteToBits(byte) {
    const bits = new Uint8Array(8)

    for (let i = 0; i < 8; i++) {
      bits[i] = (byte >> (7 - i)) & 1
    }

    return bits
  }

  /**
   * Convert a bit-array to a an unsigned 8-bit integer.
   * @param{Uint8Array} bits - An 8-element bit array.
   * @returns {number} byte - An 8-bit unsigned integer.
   */
  #bitsToByte(bits) {
    let byte = 0

    for (let i = 0; i < 8; i++) {
      byte |= (bits[i] << (7 - i))
    }

    return byte
  }

  /**
   * Encrypting and decrypting data is done by applying XOR to the data and
   * Trivium keystream.
   * @param {Uint8Array} data - Array of data to XOR with the keystream.
   * @return {Uint8Array} output - Array of plaintext or ciphertext bytes.
   * @throws {Error}
   */
  #update(data) {
    if (!(data instanceof Uint8Array)) {
      throw new Error("Data should be a Uint8Array.")
    }

    const output = new Uint8Array(data.length)

    for (let i = 0; i < data.length; i++) {
      const inputBits = this.#byteToBits(data[i])
      const outputBits = new Uint8Array(8)

      for (let j = 7; j >= 0; j--) {
        outputBits[j] = inputBits[j] ^ this.#genKeyStream()
      }

      output[i] = this.#bitsToByte(outputBits)
    }

    return output
  }

  /**
   * Encryption
   * @param {Uint8Array} data - Array of data to encrypt.
   * @returns {Uint8Array} - Array of ciphertext bytes.
   */
  encrypt(data) {
    return this.#update(data)
  }

  /**
   * Decryption
   * @param {Uint8Array} data - Array of data to decrypt.
   * @returns {Uint8Array} - Array of plaintext bytes.
   */
  decrypt(data) {
    return this.#update(data)
  }
}

vectors.js

const Trivium = require('./trivium.js')
const pt = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
let key = new Uint8Array([0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
let iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
let testVector = new Uint8Array([0x38, 0xEB, 0x86, 0xFF, 0x73, 0x0D, 0x7A, 0x9C, 0xAF, 0x8D, 0xF1, 0x3A, 0x44, 0x20, 0x54, 0x0D, 0xBB, 0x7B, 0x65, 0x14, 0x64, 0xC8, 0x75, 0x01, 0x55, 0x20, 0x41, 0xC2, 0x49, 0xF2, 0x9A, 0x64, 0xD2, 0xFB, 0xF5, 0x15, 0x61, 0x09, 0x21, 0xEB, 0xE0, 0x6C, 0x8F, 0x92, 0xCE, 0xCF, 0x7F, 0x80, 0x98, 0xFF, 0x20, 0xCC, 0xCC, 0x6A, 0x62, 0xB9, 0x7B, 0xE8, 0xEF, 0x74, 0x54, 0xFC, 0x80, 0xF9])
let cipher = new Trivium(key, iv)
let ct = cipher.encrypt(pt)
console.log(1, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x61, 0x20, 0x8D, 0x28, 0x6B, 0xC1, 0xDC, 0x43, 0x11, 0x71, 0xED, 0xA5, 0xCA, 0xF7, 0x9D, 0x95, 0x60, 0xB1, 0x8A, 0xCE, 0xF2, 0x64, 0x84, 0x41, 0x7B, 0x65, 0x1A, 0x47, 0xA3, 0xF7, 0xA8, 0x03, 0x53, 0xF7, 0x9A, 0xF8, 0x65, 0x6D, 0xA4, 0x30, 0x1A, 0x5E, 0x5A, 0x02, 0xE0, 0x42, 0x65, 0xB1, 0x82, 0xC6, 0x7F, 0x58, 0x91, 0x22, 0x03, 0x49, 0xF8, 0xCD, 0x1C, 0xD0, 0x65, 0x97, 0xB7, 0x7E])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(2, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xC8, 0xF9, 0x03, 0x1D, 0xAB, 0xF8, 0xDB, 0x03, 0xFF, 0x12, 0x0D, 0x05, 0x51, 0x2B, 0x5F, 0x24, 0xEA, 0xEA, 0x1B, 0xAB, 0x43, 0x20, 0x1A, 0x5E, 0x93, 0xBF, 0x17, 0xF6, 0x28, 0xE5, 0xB2, 0x16, 0xD5, 0x85, 0x77, 0x11, 0x2F, 0x58, 0x1A, 0x67, 0xDD, 0x5F, 0x96, 0x24, 0x84, 0xED, 0x4A, 0xC5, 0x92, 0x02, 0xBA, 0x35, 0x09, 0xA7, 0x3E, 0x11, 0x96, 0x80, 0xB5, 0x62, 0xF8, 0x6D, 0xF0, 0xDC])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(3, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xF7, 0xE5, 0x23, 0x04, 0x0E, 0x86, 0xEA, 0x2C, 0x46, 0xA2, 0xBE, 0x70, 0x5B, 0xFC, 0x62, 0x59, 0x7F, 0x77, 0xE4, 0x64, 0x9C, 0x0E, 0x71, 0xD5, 0x1B, 0x28, 0x8E, 0xDD, 0x4F, 0xC1, 0x69, 0xBC, 0xD6, 0x81, 0xF4, 0x60, 0x3E, 0x19, 0x2A, 0x79, 0x71, 0xE7, 0x32, 0x90, 0x13, 0x3E, 0x1E, 0x32, 0xF9, 0x16, 0xD9, 0x8B, 0x0D, 0x77, 0xF3, 0x79, 0x27, 0xE1, 0x21, 0x5C, 0x1D, 0x6A, 0xE0, 0x37])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(4, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x4B, 0x43, 0x0B, 0xDE, 0x0F, 0x57, 0x4C, 0x7D, 0xE0, 0x6E, 0x6A, 0x19, 0x18, 0xBF, 0xB4, 0xDE, 0xC0, 0xE2, 0x83, 0x60, 0x71, 0xEB, 0x44, 0x6C, 0x59, 0x3E, 0xE1, 0xF2, 0x59, 0x45, 0x33, 0x27, 0x2E, 0x72, 0x0E, 0x2A, 0x27, 0x99, 0x27, 0x30, 0xE6, 0x7D, 0x50, 0x9E, 0xDF, 0x7B, 0xB0, 0xE6, 0x2A, 0xEA, 0x85, 0xED, 0x87, 0xB9, 0x98, 0xFA, 0x6F, 0x53, 0xA0, 0xB7, 0x7D, 0x26, 0xBB, 0xA2])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(5, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x4E, 0xAC, 0x0C, 0x5C, 0x7A, 0xD3, 0x27, 0x08, 0x4C, 0xFE, 0xD7, 0xEA, 0xF7, 0x2F, 0x6E, 0xB7, 0xFF, 0x20, 0xE1, 0x1C, 0x65, 0xDF, 0xC1, 0x47, 0x0C, 0x1D, 0x2E, 0xFA, 0xFC, 0xE2, 0xB1, 0xFA, 0x3E, 0xD6, 0xAF, 0xBE, 0x7C, 0xBE, 0xB6, 0x77, 0xDB, 0x11, 0x89, 0xCB, 0x68, 0x92, 0xE8, 0x10, 0x93, 0xB1, 0x6F, 0xDC, 0x34, 0x19, 0x9D, 0x0A, 0x26, 0xB8, 0x9F, 0x06, 0xC8, 0x6A, 0xC9, 0xD7])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(6, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x2D, 0x97, 0xF2, 0x27, 0xF2, 0x46, 0x3F, 0x27, 0x1F, 0x85, 0x3B, 0xA1, 0x08, 0x06, 0x88, 0x8F, 0x8B, 0xA5, 0x73, 0x35, 0x64, 0x55, 0x7D, 0x51, 0x74, 0xA1, 0x61, 0x72, 0xBD, 0x89, 0xD7, 0xE3, 0x2A, 0xDF, 0x9C, 0x5B, 0x25, 0x7D, 0xCC, 0x16, 0x93, 0xAB, 0x7C, 0xA6, 0x24, 0x8F, 0x7A, 0x33, 0xD3, 0x11, 0xFA, 0xD4, 0xD8, 0x9D, 0x1C, 0x6E, 0xB7, 0xFC, 0xF8, 0x89, 0x6D, 0x94, 0xE7, 0x9C])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(7, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x9E, 0xB8, 0xF6, 0xBD, 0x37, 0x47, 0x4B, 0x5C, 0x2A, 0xC0, 0x1B, 0xA1, 0xB3, 0xEE, 0xA5, 0xE1, 0xFB, 0xD4, 0xD4, 0xD1, 0xAE, 0x63, 0xEA, 0xFD, 0x81, 0xA4, 0xD2, 0xC9, 0x00, 0xB5, 0x93, 0x12, 0x73, 0xB3, 0x78, 0x20, 0xBC, 0x68, 0xFC, 0xD6, 0x9E, 0xD1, 0x8F, 0x1E, 0xD4, 0xEC, 0x93, 0x34, 0xF3, 0x9F, 0xEB, 0x33, 0x0B, 0xAA, 0xED, 0xEF, 0x2A, 0x1E, 0x51, 0xB2, 0x18, 0xB3, 0x85, 0xC8])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(8, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x5D, 0x49, 0x2E, 0x77, 0xF8, 0xFE, 0x62, 0xD7, 0x69, 0xC6, 0xA1, 0x42, 0x05, 0x6B, 0xE9, 0x36, 0x1F, 0xA0, 0xAD, 0xD8, 0xA5, 0x46, 0x01, 0xDE, 0x61, 0x5E, 0xBC, 0x04, 0xC4, 0xF8, 0xB2, 0xC1, 0x2A, 0x8E, 0xD2, 0xDC, 0x9A, 0xB2, 0x86, 0xA0, 0xF6, 0xC4, 0x9C, 0x7A, 0xB3, 0x19, 0xBA, 0x6A, 0xAF, 0xAA, 0xF0, 0xCD, 0x42, 0xD0, 0xA4, 0x4C, 0x7D, 0xAC, 0xBC, 0x90, 0x79, 0x18, 0x55, 0xD8])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(9, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xFB, 0xE0, 0xBF, 0x26, 0x58, 0x59, 0x05, 0x1B, 0x51, 0x7A, 0x2E, 0x4E, 0x23, 0x9F, 0xC9, 0x7F, 0x56, 0x32, 0x03, 0x16, 0x19, 0x07, 0xCF, 0x2D, 0xE7, 0xA8, 0x79, 0x0F, 0xA1, 0xB2, 0xE9, 0xCD, 0xF7, 0x52, 0x92, 0x03, 0x02, 0x68, 0xB7, 0x38, 0x2B, 0x4C, 0x1A, 0x75, 0x9A, 0xA2, 0x59, 0x9A, 0x28, 0x55, 0x49, 0x98, 0x6E, 0x74, 0x80, 0x59, 0x03, 0x80, 0x1A, 0x4C, 0xB5, 0xA5, 0xD4, 0xF2])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(10, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xAB, 0x97, 0x61, 0x6E, 0x7B, 0xAF, 0x09, 0x21, 0xF4, 0x24, 0xB2, 0x57, 0x3B, 0xFA, 0x15, 0xBD, 0xCA, 0x01, 0x89, 0x8A, 0xBB, 0xE6, 0xAB, 0x77, 0x27, 0x9A, 0xB1, 0xD7, 0x32, 0xAB, 0xD1, 0x05, 0x12, 0x76, 0x9C, 0xC6, 0x9F, 0xAB, 0x34, 0xE0, 0x3B, 0x80, 0x7F, 0x92, 0xC9, 0x66, 0x27, 0xC1, 0x76, 0x56, 0xBC, 0xC9, 0xBD, 0x9D, 0x37, 0x72, 0x40, 0xA2, 0xB6, 0xFD, 0xBD, 0x78, 0x44, 0x53])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(11, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xAD, 0x35, 0xE1, 0x7B, 0x19, 0x71, 0xAF, 0x6B, 0x5B, 0x3E, 0x36, 0x5F, 0xA6, 0x4E, 0xB4, 0xCF, 0x7E, 0xBF, 0x02, 0x3D, 0x52, 0x08, 0x89, 0xAD, 0x71, 0xF1, 0xA0, 0x7A, 0xA2, 0xE0, 0xFF, 0x44, 0xCE, 0xE3, 0x2D, 0x09, 0xCF, 0x77, 0x36, 0x0C, 0x52, 0x43, 0x4D, 0x46, 0x2B, 0x53, 0xA4, 0x05, 0xEF, 0x5A, 0x60, 0xD8, 0x2A, 0x0F, 0x5E, 0x3C, 0xF3, 0x32, 0x1B, 0x37, 0x27, 0xA3, 0xD6, 0x1E])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(12, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x57, 0x5A, 0xC7, 0x7D, 0xCD, 0x54, 0xE7, 0xF4, 0x8D, 0x83, 0x7A, 0xDE, 0x0A, 0x88, 0xC7, 0x0D, 0x77, 0x78, 0x39, 0xB3, 0x10, 0xC2, 0x97, 0x83, 0x5F, 0x5B, 0xB8, 0x8C, 0x1A, 0x5F, 0xFD, 0x15, 0x69, 0xA4, 0xC4, 0x67, 0x6E, 0x7D, 0x7C, 0xEA, 0x86, 0x4F, 0xA1, 0xAD, 0x2F, 0x78, 0xE3, 0xE0, 0x44, 0xE7, 0xD1, 0x45, 0x82, 0x7D, 0xD6, 0xE4, 0x09, 0x5C, 0xB3, 0x08, 0x11, 0x1F, 0x5C, 0x72])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(13, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x55, 0x02, 0xDF, 0x80, 0x70, 0x38, 0x7D, 0x12, 0x37, 0xEF, 0x52, 0x13, 0xB5, 0xF1, 0x9E, 0xB7, 0x9B, 0x9C, 0xC3, 0x08, 0x10, 0xDB, 0x96, 0x6D, 0xD2, 0xB2, 0x5C, 0x92, 0x49, 0xC0, 0x37, 0x8B, 0x17, 0x42, 0x3F, 0x4E, 0x78, 0x8B, 0xC3, 0xE8, 0x2F, 0xBF, 0xC7, 0xFA, 0x3F, 0xED, 0x4A, 0x57, 0x04, 0xBA, 0x35, 0xCF, 0x9C, 0xBD, 0x12, 0xDC, 0xFD, 0x56, 0xCB, 0x6D, 0xD4, 0x31, 0xA4, 0xD5])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(14, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xFC, 0x87, 0x84, 0x96, 0x24, 0x21, 0x75, 0x31, 0x38, 0x58, 0x50, 0xAB, 0xE1, 0xCA, 0x16, 0xD5, 0x79, 0x2A, 0x45, 0xF8, 0xFC, 0x40, 0x63, 0x8B, 0x0B, 0xDF, 0xB7, 0xA3, 0x2D, 0x5B, 0x53, 0xCC, 0x67, 0x51, 0xFE, 0x1C, 0xBE, 0x1B, 0xA6, 0x73, 0xD2, 0x11, 0x3A, 0xB9, 0x00, 0xCF, 0xC9, 0xC3, 0x09, 0x5C, 0xA8, 0x5E, 0xAA, 0xF1, 0x7D, 0xC6, 0x17, 0x24, 0x9F, 0xEB, 0x36, 0x2A, 0x3F, 0x43])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(15, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x1F, 0x9A, 0x14, 0xB9, 0x8C, 0xB4, 0x48, 0xD4, 0x00, 0x2A, 0x37, 0x70, 0x36, 0x14, 0x47, 0xF8, 0xD0, 0xFC, 0xA7, 0xB2, 0xBC, 0xFA, 0x40, 0xD6, 0x18, 0xAB, 0x18, 0x33, 0xFF, 0x19, 0xDF, 0x6F, 0xB9, 0xBE, 0x5D, 0x7A, 0x47, 0xB6, 0x92, 0xFE, 0x64, 0xC7, 0xCA, 0x52, 0x0D, 0x60, 0xDA, 0x1C, 0x35, 0xAC, 0x0B, 0x9E, 0x60, 0x8C, 0x5E, 0x45, 0x90, 0x37, 0xF8, 0xE9, 0xE6, 0x8B, 0x8C, 0xD8])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(16, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xF2, 0xD9, 0x79, 0x2B, 0x78, 0xC2, 0xD3, 0xEC, 0x67, 0xD8, 0xC8, 0x0A, 0x71, 0x0D, 0x19, 0xEA, 0xDB, 0x16, 0x31, 0x99, 0xC6, 0xD9, 0xA1, 0xCB, 0x8F, 0x30, 0x62, 0x4D, 0x4B, 0x30, 0xD9, 0x16, 0xE4, 0xC2, 0x01, 0xE0, 0x13, 0xEF, 0x6F, 0x4E, 0x0B, 0xA5, 0x82, 0x96, 0xBA, 0xB2, 0xC5, 0x61, 0xE7, 0x37, 0xED, 0xAB, 0xD0, 0x55, 0xF5, 0x17, 0xCD, 0x54, 0x6B, 0x2B, 0x22, 0xF2, 0x7C, 0x66])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(17, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x43, 0x5E, 0x47, 0x29, 0x82, 0x0B, 0x9E, 0xF9, 0x67, 0x0D, 0xAC, 0xC0, 0x74, 0x44, 0x21, 0x15, 0x00, 0xC1, 0xF4, 0xA1, 0x81, 0x34, 0xB8, 0xFA, 0x1B, 0x08, 0x06, 0x70, 0x50, 0x69, 0x8D, 0x2F, 0xA1, 0x8B, 0x38, 0x27, 0xF5, 0xBE, 0x7D, 0xD0, 0x6B, 0x75, 0xAF, 0x49, 0xCA, 0x44, 0x27, 0x88, 0x0B, 0x47, 0xFA, 0x46, 0xE7, 0x4D, 0x48, 0xF4, 0x24, 0xED, 0x5C, 0x98, 0x1B, 0xE1, 0xB9, 0xBF])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(18, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x0F, 0xC8, 0x05, 0xC2, 0x82, 0x9B, 0x79, 0xF1, 0x5F, 0x34, 0xAC, 0x30, 0x80, 0x18, 0xC3, 0xE7, 0x34, 0xB1, 0x40, 0x05, 0xBE, 0x04, 0x73, 0xB1, 0x93, 0x78, 0xCE, 0x11, 0x51, 0x46, 0xA0, 0x94, 0x0D, 0xAE, 0x4D, 0xA3, 0x49, 0x90, 0x56, 0x37, 0xC3, 0x98, 0x1F, 0x68, 0xE4, 0x30, 0x04, 0x7A, 0xA3, 0x05, 0x6E, 0xEF, 0x32, 0x17, 0x41, 0x20, 0xD9, 0xDA, 0x49, 0xB2, 0xCF, 0x8C, 0x0E, 0xA7])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(19, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x2C, 0x7F, 0x53, 0xF2, 0xFD, 0x7C, 0xC9, 0x34, 0x2E, 0xBD, 0xB2, 0x6E, 0x82, 0x45, 0xBB, 0x9F, 0x29, 0x8D, 0x54, 0xB7, 0x4A, 0x7E, 0x7C, 0x60, 0x8E, 0x4E, 0xE6, 0xFD, 0x7A, 0x66, 0x08, 0xB6, 0x9E, 0xE7, 0x1B, 0x83, 0xD9, 0x63, 0x5C, 0x45, 0x7D, 0xD9, 0xD0, 0x5F, 0xE9, 0x09, 0x0F, 0xBA, 0x05, 0xE2, 0x49, 0xD4, 0x42, 0x18, 0xE9, 0x7D, 0x1B, 0x90, 0x5E, 0x4F, 0x08, 0x10, 0xA9, 0x12])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(20, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xF6, 0x65, 0x2E, 0x27, 0xAC, 0x1B, 0x27, 0x05, 0xB9, 0x0E, 0xAA, 0xC5, 0x1D, 0x79, 0xFE, 0x00, 0x09, 0x3F, 0xD0, 0xFA, 0x2D, 0xC6, 0x0E, 0x74, 0x37, 0x68, 0xB4, 0x74, 0x77, 0xE0, 0x12, 0x9A, 0x2F, 0xD2, 0x3E, 0x0F, 0xF6, 0x56, 0xF5, 0x6A, 0x39, 0xBA, 0x26, 0x0F, 0xA2, 0xD4, 0x5B, 0xB3, 0x5B, 0xA1, 0x06, 0x50, 0x7C, 0xF6, 0xA0, 0x02, 0x7F, 0x86, 0xC9, 0x2E, 0x01, 0x74, 0xDB, 0x1A])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(21, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x7E, 0x1A, 0x2E, 0x71, 0x19, 0x9A, 0x17, 0xB0, 0xBB, 0x9A, 0x8B, 0x9B, 0x81, 0x02, 0xA9, 0xAD, 0xDA, 0x23, 0xAB, 0x46, 0x42, 0xAA, 0x19, 0x22, 0xB3, 0x34, 0xD0, 0xA6, 0xB5, 0xD6, 0x2F, 0x37, 0x10, 0x00, 0x55, 0xCC, 0xCC, 0x7D, 0x4D, 0x56, 0x94, 0xDE, 0x27, 0x45, 0x22, 0x1B, 0x6B, 0xDF, 0x02, 0xED, 0x1F, 0x56, 0xB8, 0x1B, 0xDD, 0xA0, 0x70, 0xC0, 0xE0, 0x96, 0x43, 0xFB, 0x31, 0xDE])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(22, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xEA, 0xD8, 0xFB, 0xE6, 0x3C, 0x18, 0x29, 0x04, 0xDD, 0x66, 0xED, 0xB3, 0x53, 0x79, 0x15, 0x03, 0x8D, 0xDE, 0xE8, 0xEE, 0xAA, 0xE4, 0x4F, 0x9D, 0xB8, 0x7D, 0xEF, 0x80, 0xD9, 0xDC, 0xFA, 0xA7, 0x10, 0x17, 0x33, 0x32, 0x58, 0xA8, 0xCA, 0xDA, 0x82, 0xD3, 0x52, 0x92, 0xA4, 0x8C, 0xB4, 0x9B, 0x48, 0x38, 0xD8, 0x4E, 0x0C, 0x95, 0xA1, 0x2B, 0xD5, 0xB9, 0x80, 0x5F, 0xE7, 0x26, 0xA8, 0x04])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(23, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x7C, 0xC8, 0x9F, 0xF6, 0xF0, 0xDF, 0x4C, 0x88, 0x34, 0x36, 0x22, 0x53, 0x5F, 0x87, 0x66, 0x88, 0x4F, 0xB2, 0xA2, 0x77, 0x60, 0xEC, 0x4E, 0xA0, 0xAC, 0xA7, 0x5C, 0xC5, 0x90, 0x7D, 0xB2, 0x54, 0xEE, 0x37, 0xDF, 0x12, 0xE5, 0xC8, 0x9C, 0xB0, 0xA7, 0x8A, 0x56, 0x92, 0x79, 0xBB, 0xCD, 0xB1, 0x21, 0xC3, 0x4E, 0xFB, 0xBA, 0xC3, 0x31, 0x10, 0x06, 0xA6, 0xDD, 0x01, 0xDC, 0x28, 0x36, 0xC3])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(24, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x01, 0xDA, 0x3D, 0xC2, 0xC0, 0x2D, 0xF6, 0xFF, 0x26, 0xDB, 0xAE, 0xFA, 0x1A, 0x6C, 0x27, 0x80, 0xA6, 0x6E, 0xCF, 0x53, 0x95, 0x27, 0xB0, 0xFD, 0xC7, 0x3D, 0x44, 0x68, 0x79, 0x8F, 0x7D, 0x80, 0xE1, 0x5E, 0x06, 0x33, 0xC9, 0xB7, 0x1A, 0x8A, 0x5A, 0x33, 0xEB, 0xA9, 0xE2, 0x9F, 0x90, 0x35, 0xE6, 0xBF, 0x12, 0x54, 0x17, 0xBE, 0x00, 0x3D, 0x4D, 0xD5, 0x04, 0x8C, 0x8D, 0xC6, 0x4B, 0xD8])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(25, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x6A, 0xB0, 0x80, 0x26, 0x57, 0x87, 0x6C, 0x8F, 0x72, 0x11, 0xB1, 0x4C, 0xE0, 0x5E, 0x78, 0x02, 0x4A, 0xA6, 0xD1, 0xE5, 0xF9, 0x74, 0x81, 0x5D, 0x39, 0x8D, 0x7B, 0xB9, 0xE1, 0x68, 0x55, 0xC3, 0x2F, 0xB8, 0x89, 0x6F, 0x57, 0xC4, 0x38, 0x28, 0xD1, 0xAE, 0x03, 0x4B, 0xAE, 0x3F, 0x42, 0xD6, 0x1D, 0x00, 0x60, 0x22, 0xC7, 0x11, 0x03, 0xED, 0xD1, 0x12, 0x5C, 0xC5, 0xEB, 0xFD, 0xBC, 0xE0])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(26, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xD6, 0xD2, 0x5A, 0x2B, 0xE8, 0x78, 0x98, 0xCE, 0x1F, 0xEC, 0xAF, 0xCE, 0x87, 0x70, 0xB1, 0x21, 0x4C, 0x71, 0x93, 0x24, 0x09, 0x39, 0xF2, 0x95, 0x45, 0xF7, 0x62, 0x78, 0xFC, 0xB1, 0x96, 0xD5, 0xB7, 0xD9, 0xCD, 0x12, 0xFC, 0x25, 0x3C, 0x49, 0x5B, 0xE6, 0x0E, 0x0E, 0x37, 0x07, 0x43, 0x8E, 0x2C, 0xB5, 0x42, 0x14, 0x89, 0x9B, 0xFA, 0xC8, 0xF5, 0x89, 0x5A, 0xC4, 0x39, 0xD2, 0x9F, 0x25])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(27, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xEA, 0x8B, 0xD0, 0x72, 0x0E, 0x56, 0x91, 0x61, 0xE9, 0xBD, 0x39, 0x96, 0x91, 0x51, 0x8E, 0x7A, 0x54, 0x83, 0x0A, 0x6B, 0x8E, 0xA5, 0x5F, 0xA0, 0x0C, 0x65, 0x1B, 0x00, 0xB1, 0xF1, 0xEA, 0x2E, 0xC6, 0x87, 0x41, 0x91, 0x0B, 0x8F, 0x03, 0x67, 0xB7, 0x98, 0x70, 0x24, 0xD8, 0x07, 0xDB, 0x8E, 0xC7, 0x01, 0x54, 0x62, 0xE6, 0xB5, 0x35, 0x78, 0xEF, 0x12, 0x9E, 0xE6, 0x74, 0x17, 0xBF, 0x01])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(28, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xE2, 0xED, 0x94, 0x61, 0xB7, 0x19, 0x15, 0x8E, 0x3F, 0x48, 0xD2, 0xD8, 0xCD, 0xAC, 0xA1, 0xA1, 0x36, 0x26, 0xA0, 0xBF, 0x92, 0xEC, 0xC9, 0xAB, 0x92, 0x72, 0xDA, 0x04, 0xC2, 0x84, 0xA6, 0x49, 0xA2, 0x28, 0xB3, 0x2C, 0x46, 0x07, 0xC6, 0xD0, 0xFD, 0xA5, 0x18, 0xEC, 0xD5, 0xD9, 0x54, 0x8C, 0x80, 0x44, 0xDC, 0xE2, 0x23, 0x6F, 0x0B, 0x94, 0x15, 0xBE, 0xF8, 0xBB, 0x0E, 0x41, 0x4E, 0xB6])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(29, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x73, 0x66, 0x40, 0xC5, 0x55, 0x21, 0x4B, 0x9D, 0x30, 0xC2, 0x68, 0xB8, 0xB6, 0x51, 0xF6, 0x14, 0xC8, 0x72, 0x43, 0x14, 0x62, 0x4A, 0x4F, 0xDB, 0xA7, 0x5D, 0x6D, 0xC8, 0xC1, 0x5D, 0xF9, 0x3B, 0xEB, 0x80, 0xE8, 0x32, 0x52, 0x18, 0xEA, 0x48, 0x91, 0x28, 0xBB, 0xFD, 0xA1, 0x9A, 0x64, 0x13, 0x95, 0x10, 0xDE, 0x9B, 0x6A, 0xC0, 0x06, 0xDF, 0x3B, 0x29, 0xCF, 0x7A, 0x67, 0x30, 0x16, 0xBF])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(30, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x7F, 0xE2, 0x6D, 0x4E, 0xD7, 0x62, 0xAC, 0x9D, 0x9C, 0x1D, 0x45, 0xDC, 0x11, 0x6A, 0x39, 0x3C, 0x1C, 0x98, 0xF3, 0xF7, 0x18, 0x1A, 0x81, 0x09, 0x47, 0x5C, 0x97, 0xAE, 0x3D, 0x5F, 0xAA, 0x38, 0x1F, 0x82, 0x86, 0xA5, 0x5A, 0x7A, 0x9A, 0x7E, 0xAD, 0x34, 0x9E, 0xB0, 0x35, 0x4E, 0x89, 0x14, 0x90, 0xF7, 0xEE, 0x0C, 0x54, 0x96, 0xE3, 0xFC, 0xF2, 0x17, 0xD1, 0xE7, 0x1A, 0x28, 0x63, 0x8A])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(31, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xCA, 0xCC, 0xB9, 0xA2, 0xE2, 0x8A, 0xA2, 0x2B, 0x80, 0x63, 0x4B, 0xBA, 0x85, 0x72, 0xF2, 0x7E, 0x8B, 0xBF, 0x72, 0xF7, 0x6F, 0x54, 0xFD, 0xF9, 0x3F, 0x66, 0x92, 0x82, 0x4A, 0xEB, 0x1D, 0x35, 0x96, 0x5A, 0xD3, 0x5E, 0xD0, 0x15, 0x71, 0x12, 0x5E, 0x6E, 0xA8, 0xDE, 0xEC, 0xC2, 0x12, 0x90, 0xF5, 0x30, 0x74, 0x8C, 0xB2, 0xB4, 0x3D, 0xF3, 0x40, 0x81, 0xA9, 0x3C, 0x8B, 0xA9, 0xF6, 0x52])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(32, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x91, 0x14, 0x6F, 0x16, 0x05, 0xC9, 0xF8, 0xB0, 0xB1, 0xBA, 0xA7, 0x1E, 0x77, 0xC6, 0x60, 0xBB, 0x77, 0x84, 0x63, 0x61, 0xF4, 0x32, 0x50, 0xC1, 0xF7, 0xAA, 0x9B, 0x56, 0x13, 0xE3, 0x92, 0x8F, 0x4D, 0x3A, 0xFE, 0xDF, 0x6A, 0x48, 0x9C, 0xC4, 0x71, 0xD3, 0x37, 0x54, 0x91, 0x34, 0xFC, 0xCB, 0xB5, 0x60, 0xA9, 0x9F, 0x27, 0x5B, 0xCF, 0x86, 0x04, 0xE0, 0x39, 0xA3, 0x38, 0x56, 0x6E, 0x32])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(33, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x9B, 0x45, 0x2E, 0x88, 0x53, 0x9B, 0x47, 0xCF, 0xE4, 0xAC, 0xC7, 0x71, 0x3C, 0x3C, 0xCB, 0x76, 0xD1, 0x5B, 0xBB, 0xF3, 0x6A, 0x82, 0x80, 0x91, 0x7D, 0x70, 0x1A, 0x9A, 0x51, 0x62, 0x04, 0xFF, 0x0D, 0x0A, 0x21, 0xA3, 0x8E, 0x62, 0x21, 0xE7, 0xE6, 0x4F, 0x41, 0x6A, 0x38, 0x1F, 0xE6, 0xE0, 0x48, 0xFA, 0xDF, 0x96, 0xED, 0x9E, 0x55, 0x99, 0xF5, 0xC0, 0x1D, 0x97, 0xD3, 0xE2, 0xC8, 0xFD])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(34, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x1D, 0x34, 0x75, 0x0D, 0x13, 0xD4, 0xC2, 0x8B, 0xE0, 0x3D, 0x95, 0x68, 0x8A, 0x98, 0xFB, 0x00, 0x0A, 0xE0, 0x65, 0xF9, 0x28, 0x9E, 0x5F, 0x48, 0xE0, 0x70, 0x11, 0x3A, 0x1F, 0xD2, 0xA7, 0xE5, 0x7F, 0xDB, 0xE7, 0x41, 0x0C, 0x40, 0xF4, 0xD3, 0x92, 0x40, 0x32, 0x49, 0x6F, 0x06, 0x9B, 0xD0, 0xFA, 0x9E, 0xD7, 0x24, 0x16, 0x32, 0xAB, 0x07, 0xF3, 0x12, 0xD8, 0xFA, 0xEA, 0xC3, 0x1C, 0x59])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(35, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x14, 0xB1, 0x06, 0x25, 0x91, 0xD3, 0x8C, 0x06, 0xD5, 0x0B, 0x0B, 0xDF, 0x05, 0xBA, 0x59, 0x4B, 0x8A, 0xDF, 0x25, 0x98, 0x14, 0x55, 0x94, 0xFC, 0x06, 0xAE, 0xBB, 0xC3, 0xC1, 0x80, 0x3A, 0x9F, 0x72, 0xB6, 0xD3, 0xA9, 0xBA, 0x54, 0x9B, 0x35, 0xE0, 0x1D, 0xC5, 0x2A, 0x8B, 0x14, 0xEC, 0x66, 0xDC, 0x70, 0xDC, 0xA3, 0xBD, 0xD9, 0x72, 0x8D, 0xFA, 0x03, 0x0E, 0xB1, 0xBC, 0x8C, 0x3E, 0xB8])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(36, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xF3, 0xF3, 0xF3, 0xF3, 0xF3, 0xF3, 0xF3, 0xF3, 0xF3, 0xF3])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x6F, 0x91, 0xE5, 0x0A, 0x18, 0x12, 0xC4, 0x2C, 0x60, 0x71, 0x1F, 0x10, 0x64, 0x4D, 0xF0, 0x0B, 0xC2, 0xC6, 0xD0, 0xEE, 0x78, 0xB1, 0xC0, 0xD8, 0x1E, 0x7F, 0xFD, 0x6A, 0xB4, 0xE2, 0xC6, 0x1F, 0xAC, 0x4A, 0x3E, 0xCF, 0x2C, 0x67, 0x65, 0x69, 0x3C, 0xF4, 0x12, 0xE7, 0x04, 0x35, 0x51, 0x18, 0x69, 0x82, 0xF0, 0x05, 0x1D, 0xD1, 0x82, 0x0B, 0xF9, 0xA8, 0xE5, 0x85, 0x11, 0xB4, 0xF1, 0xB1])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(37, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xFC])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x0F, 0x5E, 0x42, 0x87, 0x67, 0x22, 0xC2, 0x00, 0x40, 0x4C, 0xCF, 0xB4, 0x21, 0xC0, 0xFC, 0x7A, 0xB7, 0x8C, 0xA2, 0x98, 0xFF, 0xA9, 0x24, 0x3F, 0xD7, 0x61, 0x81, 0xFE, 0xE0, 0xC8, 0x06, 0xEC, 0xDB, 0x28, 0xBB, 0x29, 0x6E, 0xEA, 0xAC, 0xA1, 0xAA, 0xAD, 0x27, 0xBC, 0x5B, 0xC5, 0x2A, 0x25, 0x77, 0x79, 0xE1, 0x0A, 0x1F, 0xB2, 0xF6, 0xD1, 0xD6, 0x2D, 0xC8, 0xD9, 0x1B, 0xA6, 0x7F, 0xEA])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(38, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xD2, 0xA8, 0x74, 0x0B, 0xBA, 0x6F, 0xD9, 0x06, 0x70, 0x77, 0xF9, 0xAF, 0xC0, 0xC2, 0x7D, 0x40, 0x32, 0xB6, 0xAE, 0xAE, 0x50, 0xC4, 0x2E, 0xCE, 0xFF, 0x25, 0x5C, 0x58, 0x4C, 0x01, 0x43, 0xE7, 0x8C, 0xFA, 0x4E, 0x3E, 0xBE, 0x03, 0x07, 0x4F, 0x23, 0xD7, 0x62, 0xD0, 0xA7, 0x56, 0x35, 0x21, 0xBE, 0x75, 0x5B, 0x21, 0x66, 0xCD, 0x92, 0x0E, 0xEC, 0xBB, 0x5D, 0xB8, 0x47, 0x37, 0xFA, 0x01])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(39, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x18, 0x49, 0xD8, 0xF8, 0xD0, 0x0D, 0x4F, 0xD4, 0x9C, 0xA8, 0x25, 0xC4, 0x06, 0x54, 0xB4, 0x9A, 0xCD, 0x75, 0xDD, 0x14, 0x36, 0x61, 0xF0, 0x99, 0xA1, 0x29, 0x11, 0xE1, 0x4A, 0xFB, 0x9A, 0x35, 0xE6, 0xA1, 0x93, 0x03, 0x80, 0x9D, 0xE3, 0xB5, 0x95, 0x61, 0x78, 0xA9, 0xCC, 0x6E, 0x29, 0xA8, 0xCC, 0x97, 0xF1, 0xA3, 0xC4, 0x7A, 0xA3, 0x36, 0x0B, 0x48, 0x19, 0xAD, 0xDF, 0x4F, 0xFF, 0x7D])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(40, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xD2, 0x4D, 0x36, 0xA0, 0x7F, 0x26, 0xA0, 0x32, 0x80, 0xCE, 0x4C, 0x2A, 0x67, 0x1F, 0xC7, 0xB6, 0x17, 0xE9, 0x2D, 0x23, 0x1F, 0x64, 0x91, 0x28, 0xEB, 0x4D, 0x17, 0x07, 0x00, 0x03, 0xC8, 0xD3, 0x65, 0xDA, 0x16, 0x66, 0x2E, 0xFF, 0xA8, 0x76, 0x79, 0xE6, 0xC4, 0xE5, 0x57, 0xF8, 0x4E, 0x12, 0xE6, 0x9F, 0xB6, 0x5A, 0x49, 0x63, 0x94, 0xD3, 0x5D, 0xEC, 0xBC, 0x97, 0x14, 0xC1, 0x6B, 0xB1])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(41, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xCC, 0x84, 0xF1, 0x64, 0x80, 0x27, 0x15, 0xC0, 0x20, 0x42, 0x5A, 0x7F, 0xF6, 0x4C, 0x1A, 0x0B, 0x03, 0x3D, 0x52, 0xB9, 0x40, 0xAC, 0x2C, 0xC9, 0x1F, 0x07, 0x37, 0x59, 0x29, 0x51, 0x82, 0x6A, 0x76, 0xD1, 0x90, 0xB9, 0x26, 0x61, 0xE4, 0xFA, 0xD4, 0x75, 0x04, 0x51, 0xD6, 0xE3, 0x65, 0xCE, 0xFF, 0x04, 0x1F, 0xAB, 0x35, 0x8A, 0x09, 0xB5, 0xDD, 0xDA, 0xD4, 0xAA, 0xD6, 0xFA, 0x46, 0x0E])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(42, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x2D, 0xE8, 0xD0, 0xF2, 0xBC, 0x81, 0x76, 0xD6, 0x33, 0xCA, 0x10, 0x52, 0xE1, 0x55, 0x4C, 0x4D, 0x54, 0xA2, 0x11, 0x8E, 0x47, 0x76, 0x44, 0x52, 0x51, 0x19, 0x3C, 0xE6, 0xC1, 0xA4, 0x39, 0x59, 0x4D, 0xAE, 0x11, 0x26, 0xEF, 0x6A, 0x78, 0xE6, 0x2A, 0xA1, 0x9B, 0x84, 0x3B, 0xF6, 0x0D, 0xEC, 0x26, 0x1D, 0x6D, 0xA1, 0xEA, 0x64, 0xC1, 0x44, 0x9D, 0x83, 0xE8, 0x3D, 0x29, 0x26, 0x77, 0x47])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(43, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x0B, 0x4A, 0x17, 0x3B, 0x35, 0xC6, 0x70, 0x5A, 0x4D, 0xB9, 0x8C, 0x4D, 0x0F, 0xC7, 0x0B, 0x8F, 0x4C, 0x1E, 0xB7, 0x7A, 0x82, 0x3B, 0x55, 0x0C, 0x29, 0x67, 0x70, 0xF2, 0xC0, 0xCE, 0xED, 0x87, 0xB4, 0x7B, 0x66, 0xE8, 0x28, 0xCD, 0x39, 0x72, 0x36, 0x63, 0xD6, 0x05, 0x78, 0xC6, 0x76, 0xAB, 0x39, 0xAD, 0x5F, 0x3B, 0xE5, 0xD2, 0x67, 0x6E, 0x68, 0x5C, 0x11, 0x43, 0xBF, 0xF1, 0x9A, 0x52])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(44, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xBE, 0x00, 0x6E, 0xB1, 0x6B, 0x35, 0x54, 0xB2, 0xF3, 0xB4, 0x4E, 0x22, 0xF6, 0xFA, 0x65, 0x7A, 0x35, 0x67, 0xA9, 0xB6, 0x2F, 0x96, 0x13, 0x3F, 0x30, 0x0E, 0xD2, 0x84, 0x3A, 0xE6, 0xE5, 0x24, 0x7B, 0xAB, 0xD8, 0x52, 0x1C, 0x20, 0x99, 0xDF, 0x40, 0x80, 0xA5, 0x1B, 0x02, 0x2B, 0xC5, 0x3D, 0x88, 0x1B, 0xB6, 0x37, 0x66, 0x15, 0x0D, 0x26, 0xEA, 0x52, 0x58, 0xA1, 0xB4, 0x41, 0x2F, 0xBC])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(45, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x6A, 0x3E, 0x21, 0x5F, 0xD1, 0xA2, 0xA5, 0x5A, 0xEC, 0x4C, 0x84, 0xBB, 0x21, 0x64, 0x94, 0xFD, 0x81, 0xC1, 0x72, 0x79, 0xD1, 0x31, 0x52, 0x7A, 0x9F, 0xD4, 0xF3, 0xB0, 0x43, 0x50, 0xB0, 0xC7, 0x36, 0x5B, 0x37, 0x58, 0x27, 0x95, 0x0A, 0xD4, 0x5E, 0xE8, 0x38, 0x8E, 0x00, 0xF8, 0xA8, 0xFC, 0xF0, 0x21, 0xB3, 0xD6, 0x3F, 0xE0, 0x31, 0xA7, 0xCF, 0x4E, 0x8D, 0x0E, 0xB4, 0x6B, 0x01, 0x55])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(46, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x86, 0x3A, 0xFB, 0x90, 0x6F, 0x2A, 0x73, 0xDF, 0xCA, 0xDF, 0xBC, 0x47, 0xEE, 0xEE, 0x20, 0x31, 0xCE, 0xE0, 0xAF, 0x88, 0x47, 0x77, 0x78, 0x25, 0xAF, 0xD1, 0x41, 0xD8, 0x89, 0x7A, 0x9E, 0x96, 0xC5, 0xF9, 0x28, 0x4A, 0x39, 0x1C, 0xCE, 0xC3, 0x4A, 0x19, 0x9E, 0xE8, 0x22, 0x8B, 0x0B, 0x98, 0x1A, 0xDC, 0xC8, 0x59, 0xB9, 0x00, 0x87, 0x54, 0xD3, 0xD0, 0xB9, 0x9F, 0x13, 0x6E, 0xF4, 0xE9])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(47, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x25, 0x2C, 0x40, 0x21, 0xB2, 0xFE, 0x2C, 0x61, 0x76, 0x37, 0x6D, 0x4D, 0x90, 0x5D, 0xCC, 0x59, 0xC5, 0x02, 0x88, 0x4E, 0x87, 0xE2, 0xE2, 0x7F, 0x54, 0xAC, 0x46, 0xF3, 0x7B, 0x62, 0x23, 0x4B, 0x46, 0xC7, 0x86, 0x3F, 0x75, 0x43, 0x88, 0x84, 0xDB, 0x12, 0x4A, 0x3A, 0xAC, 0x25, 0x8D, 0x50, 0x61, 0x12, 0x75, 0xFF, 0xC8, 0xF2, 0x0F, 0xB9, 0x4E, 0x8F, 0xC4, 0x53, 0x06, 0xA7, 0xA8, 0x6E])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(48, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x34, 0xE3, 0x00, 0x06, 0xE6, 0x2A, 0xF3, 0x94, 0xAD, 0xF5, 0x04, 0x2E, 0xAF, 0x6F, 0x85, 0x98, 0x39, 0xF1, 0x3E, 0xD4, 0x51, 0x9A, 0xB0, 0xCE, 0xE2, 0x59, 0x0F, 0x93, 0xD8, 0x02, 0x01, 0x1E, 0x1C, 0x1F, 0x25, 0x78, 0x39, 0x05, 0x40, 0x60, 0xA5, 0x5B, 0x28, 0xBF, 0x15, 0x7E, 0xD8, 0xB5, 0xDD, 0x8E, 0x54, 0xE9, 0x24, 0x15, 0xAB, 0x12, 0x84, 0x4C, 0xAF, 0x90, 0x49, 0x8C, 0x20, 0x23])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(49, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x41, 0xDF, 0x60, 0x61, 0x20, 0xC6, 0x44, 0x78, 0x01, 0xEF, 0x9B, 0xCE, 0x34, 0xC6, 0x59, 0xFB, 0x18, 0x55, 0xA5, 0x9B, 0xF5, 0x75, 0x37, 0x9C, 0x34, 0xCA, 0x36, 0x4D, 0x02, 0x9C, 0x72, 0x2B, 0xDA, 0x10, 0x7F, 0x61, 0x92, 0x95, 0xD2, 0x12, 0xB7, 0xE2, 0x3F, 0x9C, 0xA0, 0x78, 0x8F, 0x85, 0xEB, 0xA7, 0x49, 0xFD, 0x9D, 0xAC, 0x94, 0x90, 0x29, 0x43, 0xAC, 0x65, 0xC7, 0x68, 0xB5, 0x79])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(50, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x4D, 0x0E, 0x81, 0x4E, 0xBB, 0xC4, 0x0E, 0x61, 0xB3, 0x30, 0xC8, 0xA4, 0x67, 0x8D, 0xEB, 0xF9, 0xFC, 0xED, 0x0C, 0x71, 0x29, 0x8E, 0x11, 0x59, 0xCB, 0x90, 0x3D, 0xEE, 0x6E, 0xBD, 0xC2, 0x94, 0xD9, 0xAC, 0x00, 0x44, 0x14, 0x38, 0x44, 0x1D, 0x61, 0xF6, 0x1F, 0xE4, 0x21, 0xC4, 0xF8, 0xA8, 0x39, 0xC7, 0x15, 0xB0, 0xA9, 0x08, 0x2F, 0xE8, 0x92, 0x1D, 0xB5, 0x1E, 0x14, 0xB1, 0x88, 0xDA])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(51, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x89, 0x58, 0xE8, 0xAC, 0xAC, 0x75, 0x56, 0x78, 0xCE, 0x2D, 0x4F, 0x5C, 0x48, 0x2A, 0xD7, 0x1A, 0xC7, 0xAF, 0xE4, 0xCF, 0x8E, 0x50, 0x62, 0x55, 0x59, 0x06, 0xEF, 0x8D, 0xEB, 0xBA, 0x30, 0xA6, 0xEB, 0xF0, 0x9D, 0x9F, 0xDF, 0xD2, 0xAC, 0xBD, 0xC4, 0x61, 0x91, 0x99, 0xBA, 0x95, 0xC6, 0xB6, 0xB1, 0x45, 0xD0, 0x84, 0xE6, 0x1B, 0x4E, 0xDF, 0x02, 0x69, 0x3D, 0xFC, 0x3D, 0xE7, 0x6A, 0x54])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(52, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xCA, 0xE3, 0xF9, 0x79, 0x4B, 0xE6, 0x05, 0x73, 0x9E, 0x8B, 0x13, 0x3E, 0x4D, 0xD9, 0x7A, 0xE0, 0x6D, 0x00, 0x78, 0x0A, 0x66, 0xF1, 0xBD, 0xC3, 0xB8, 0x56, 0xD1, 0x78, 0xD2, 0x63, 0xEC, 0x28, 0x2E, 0xC6, 0x77, 0x5E, 0x89, 0xB1, 0x5A, 0x42, 0x93, 0x07, 0x64, 0x3B, 0xAD, 0x60, 0x42, 0xCF, 0xFC, 0x24, 0x8E, 0x8D, 0x08, 0x24, 0x75, 0xFB, 0x5F, 0xFF, 0xF8, 0x4E, 0xC5, 0xE2, 0xF5, 0xC7])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(53, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xC2, 0x04, 0x86, 0x13, 0x94, 0xC3, 0xB2, 0x73, 0x01, 0xD2, 0xB2, 0x16, 0xAF, 0x74, 0xF0, 0x1B, 0x36, 0xCD, 0x63, 0xEA, 0xCC, 0x07, 0xA6, 0xFB, 0x8F, 0xB6, 0x09, 0x71, 0xF3, 0xC4, 0x16, 0x0C, 0x72, 0xE0, 0x09, 0xD7, 0x95, 0xB7, 0x4B, 0x9F, 0x82, 0x6B, 0x26, 0x4D, 0xFC, 0x1F, 0xFB, 0x9D, 0x33, 0x4C, 0xC9, 0xCA, 0x88, 0xC0, 0x30, 0x09, 0xB6, 0xAC, 0x5E, 0xD5, 0x9F, 0x70, 0xA2, 0x59])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(54, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x09, 0x72, 0xB6, 0xF8, 0xB7, 0xCE, 0xC5, 0x40, 0xEA, 0xF2, 0x30, 0xE2, 0x46, 0x5A, 0xC6, 0xA3, 0x05, 0xD7, 0x8A, 0x9E, 0x5C, 0xCB, 0xB3, 0x8A, 0x01, 0x3F, 0x66, 0x74, 0xA3, 0x6D, 0xFF, 0x22, 0x7E, 0x29, 0x27, 0x60, 0xC6, 0x37, 0x62, 0x9C, 0x3B, 0xEC, 0x82, 0xE5, 0x6A, 0xB5, 0x50, 0x90, 0x3E, 0x3D, 0x55, 0x9D, 0x16, 0x48, 0x46, 0x2B, 0x8E, 0x25, 0x35, 0xE2, 0xB2, 0x13, 0x2E, 0x3A])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(55, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x1C, 0x35, 0xDA, 0x85, 0x26, 0xE8, 0x4D, 0x18, 0xF9, 0xF3, 0x19, 0xDB, 0xC6, 0x48, 0x85, 0x48, 0xFF, 0xB3, 0xA4, 0x60, 0xDE, 0x4C, 0x70, 0xE8, 0xCD, 0x95, 0xEF, 0x7C, 0x0A, 0x34, 0x26, 0x20, 0xD7, 0x61, 0x19, 0xF1, 0x7C, 0x4E, 0x56, 0xB1, 0x72, 0x39, 0xFC, 0x17, 0x85, 0x46, 0x9A, 0x07, 0x0A, 0xE6, 0x8D, 0x91, 0x79, 0x31, 0xF7, 0x3E, 0x19, 0x09, 0x36, 0xD0, 0xB9, 0x18, 0xEE, 0x5B])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(56, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x41, 0x2A, 0xB1, 0xD1, 0x8E, 0x67, 0x5A, 0xE9, 0x62, 0x65, 0x53, 0x23, 0x5C, 0xB4, 0xEB, 0x93, 0x90, 0x69, 0x4F, 0x9E, 0x1B, 0x79, 0x3E, 0xA6, 0x4E, 0xE1, 0xEB, 0xB9, 0xCA, 0x31, 0x52, 0x92, 0xEE, 0x9A, 0xFE, 0x32, 0x82, 0x7F, 0xA7, 0x99, 0x3F, 0x35, 0x5F, 0x02, 0x6C, 0x87, 0x4E, 0xEB, 0x6B, 0x89, 0xEF, 0x05, 0xD0, 0xEB, 0xE2, 0xBC, 0x0D, 0x8C, 0xC7, 0xCC, 0xDF, 0x04, 0xA1, 0x77])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(57, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x01, 0xE7, 0x59, 0xB7, 0x1C, 0x1E, 0xB6, 0x9C, 0x81, 0x58, 0x06, 0x10, 0x00, 0x6B, 0xBA, 0x1A, 0xE6, 0x96, 0x2D, 0x7E, 0xD9, 0xFB, 0x6F, 0x80, 0x46, 0x11, 0xD2, 0x0D, 0xFB, 0xBE, 0x47, 0xF6, 0x25, 0x27, 0xB3, 0xF8, 0x10, 0x28, 0x76, 0xC5, 0x46, 0x7C, 0xB4, 0x84, 0x47, 0x23, 0xC9, 0x79, 0xCA, 0x4A, 0x91, 0xFD, 0xCF, 0xEC, 0x86, 0x37, 0x57, 0x8F, 0x7E, 0x46, 0xB8, 0x30, 0x1F, 0x10])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(58, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xA1, 0xC1, 0xEE, 0x5C, 0x63, 0xAB, 0x5C, 0x06, 0x55, 0xEB, 0x69, 0x57, 0xC4, 0xB6, 0xC8, 0x46, 0x58, 0x5A, 0x43, 0x2D, 0x6E, 0xE6, 0xF4, 0x26, 0x61, 0xB4, 0xEB, 0xDE, 0xA3, 0x63, 0xCA, 0x1E, 0xCB, 0x99, 0x50, 0xBD, 0x1C, 0x59, 0xB8, 0xD7, 0x5C, 0x13, 0x62, 0xE0, 0x76, 0x89, 0x58, 0xCE, 0x00, 0x47, 0x71, 0x53, 0x35, 0xDE, 0x0A, 0xCC, 0x42, 0x28, 0xB8, 0xEB, 0xE4, 0x01, 0x70, 0x36])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(59, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xB7, 0xBE, 0x8B, 0xF5, 0xD0, 0x2E, 0x37, 0x87, 0x1E, 0x62, 0x57, 0x09, 0x22, 0x32, 0xE6, 0xB4, 0x7D, 0xB4, 0x02, 0x6F, 0x9F, 0x52, 0x27, 0xF1, 0x09, 0x67, 0x31, 0xFC, 0x3C, 0xD6, 0x6A, 0xFA, 0x9B, 0x3D, 0x04, 0x52, 0x0B, 0xA8, 0x77, 0x85, 0xC4, 0x3F, 0x40, 0x1F, 0x40, 0x30, 0x27, 0x58, 0x19, 0x4B, 0xE4, 0x9C, 0xA8, 0xCF, 0x00, 0xA5, 0x8D, 0x99, 0x1F, 0x40, 0xB9, 0x66, 0x2F, 0x56])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(60, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x10, 0xFB, 0xD1, 0x33, 0x6E, 0x81, 0xB0, 0xD1, 0x49, 0xA9, 0xFD, 0x88, 0xCC, 0xA7, 0xDA, 0xA9, 0x17, 0xCC, 0xFF, 0x08, 0xB8, 0xB1, 0xD3, 0x67, 0x5C, 0x27, 0xFD, 0x62, 0x70, 0x13, 0x01, 0x34, 0xC2, 0x48, 0x47, 0xEC, 0xF7, 0xEE, 0x5C, 0x1D, 0xC0, 0x2E, 0x6E, 0x66, 0x34, 0xFF, 0x1E, 0xE2, 0xF0, 0x88, 0x9F, 0x60, 0x7F, 0x2A, 0xB0, 0x72, 0xDC, 0x81, 0x79, 0x9B, 0x8B, 0x86, 0x1D, 0x4E])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(61, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x90, 0xB1, 0x47, 0xBB, 0x4C, 0xE3, 0x84, 0x46, 0x64, 0xE7, 0x56, 0x78, 0xB7, 0x8F, 0x02, 0xC2, 0x92, 0x56, 0x87, 0xA9, 0x1C, 0x44, 0x81, 0x91, 0x8E, 0x87, 0x84, 0xEA, 0x4C, 0x51, 0xA6, 0x98, 0xD5, 0x2B, 0x2D, 0x16, 0xC6, 0xC2, 0xA8, 0xB5, 0x8C, 0x61, 0xA7, 0x78, 0x6E, 0x4A, 0x3B, 0xE7, 0x15, 0x68, 0x9B, 0xFE, 0x8E, 0x25, 0x1A, 0x46, 0xEB, 0xEE, 0xE2, 0xE4, 0x22, 0x05, 0x6F, 0x9C])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(62, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x1A, 0xDB, 0x5D, 0x07, 0xC8, 0x85, 0x93, 0x63, 0x94, 0xFD, 0xD0, 0x86, 0x66, 0x83, 0x0F, 0x5E, 0x3F, 0x30, 0xCD, 0xD1, 0xB9, 0x4D, 0x9B, 0x18, 0x04, 0x10, 0x8B, 0x79, 0xE5, 0x94, 0xD3, 0x91, 0x1E, 0x0D, 0x19, 0x5B, 0x80, 0x99, 0xE6, 0x76, 0x62, 0x77, 0xDE, 0x88, 0xA7, 0xC2, 0xB8, 0x10, 0x60, 0x94, 0xB6, 0x43, 0x59, 0xDD, 0xAD, 0x8B, 0x77, 0xE1, 0x99, 0x16, 0x7C, 0xFA, 0x13, 0x43])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(63, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xB6, 0x20, 0x61, 0x4F, 0x87, 0x44, 0x9D, 0xFE, 0x64, 0xBE, 0x90, 0xAE, 0x86, 0xF6, 0x12, 0x16, 0xE3, 0x42, 0x83, 0x84, 0x90, 0xC1, 0x08, 0x38, 0xAC, 0xFE, 0x1B, 0xDD, 0xF6, 0x48, 0x17, 0x63, 0x93, 0x6D, 0xA9, 0xE1, 0xFE, 0xB6, 0xDC, 0xB6, 0x35, 0x60, 0x5C, 0x94, 0xCC, 0xB0, 0xE1, 0x67, 0x96, 0x2B, 0x84, 0x03, 0x7C, 0xC2, 0x74, 0xEE, 0x96, 0x4D, 0xEE, 0xE4, 0x1C, 0xAF, 0x0F, 0x85])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(64, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x8E, 0x9E, 0x13, 0xAE, 0x97, 0xE1, 0x40, 0x98, 0xB9, 0xDF, 0x86, 0x72, 0xAE, 0x24, 0x52, 0x86, 0xCE, 0x43, 0x71, 0x59, 0x90, 0x5F, 0x02, 0x65, 0x15, 0x49, 0x8E, 0xCA, 0x6F, 0x91, 0x22, 0xB5, 0xEE, 0xD9, 0x0A, 0xF2, 0x33, 0x0D, 0xF4, 0x48, 0xD1, 0x8E, 0xE4, 0xD6, 0x38, 0xD8, 0xBE, 0xA3, 0xCB, 0xE9, 0x34, 0x97, 0x31, 0x9C, 0xFC, 0x8E, 0x5D, 0xD3, 0x87, 0xB6, 0x12, 0x91, 0x21, 0xC9])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(65, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xAE, 0xF7, 0x34, 0x17, 0xAE, 0x81, 0x20, 0xFE, 0x8B, 0x78, 0x5E, 0x0C, 0x66, 0x71, 0xC6, 0x89, 0xC5, 0x88, 0x92, 0xD3, 0x94, 0xE8, 0xAB, 0x8E, 0xF6, 0xB9, 0x26, 0x55, 0x8D, 0xCA, 0x31, 0xD0, 0xF9, 0x74, 0xE2, 0x6B, 0x13, 0xEA, 0xA4, 0x17, 0xD9, 0x32, 0xAA, 0x9A, 0x7B, 0xE2, 0x70, 0xFA, 0xF8, 0xAC, 0xCB, 0x4C, 0x0C, 0xBD, 0x39, 0x60, 0x40, 0xDD, 0xE6, 0xC9, 0x12, 0x49, 0x06, 0x43])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(66, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0xFC, 0xFD, 0xFE, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x49, 0x61, 0x91, 0xDC, 0x1E, 0xDC, 0x22, 0xDE, 0x84, 0x8E, 0x61, 0xCA, 0x62, 0x5E, 0x3A, 0x7A, 0xAA, 0x40, 0x7E, 0x45, 0x9D, 0xA4, 0x13, 0xBD, 0x1D, 0x19, 0x40, 0x1D, 0xC1, 0x31, 0x60, 0xAB, 0xF7, 0x4F, 0x38, 0x4A, 0x9D, 0xC9, 0x21, 0x15, 0x72, 0x13, 0x37, 0x3E, 0x26, 0x84, 0x79, 0xB5, 0x70, 0x9A, 0x13, 0x2C, 0x11, 0xC4, 0x79, 0x8C, 0x5B, 0x1D, 0x28, 0x5D, 0x95, 0x30, 0x8E, 0xAC])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(67, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x53, 0xA6, 0xF9, 0x4C, 0x9F, 0xF2, 0x45, 0x98, 0xEB])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xA1, 0x80, 0x96, 0x40, 0xCE, 0x79, 0xC5, 0x40, 0x80, 0x2F, 0x49, 0xD3, 0x20, 0x23, 0xB2, 0xEA, 0x8A, 0x39, 0x84, 0x28, 0xF4, 0xA5, 0xEF, 0xDB, 0x0A, 0x12, 0x4F, 0xDD, 0xF3, 0x9D, 0x23, 0xCE, 0xFE, 0x52, 0x57, 0xEE, 0x1B, 0xCA, 0xDC, 0x09, 0x54, 0x04, 0x91, 0x02, 0x82, 0x6E, 0x14, 0x4C, 0xA9, 0x6E, 0x65, 0xD4, 0xA1, 0x69, 0x82, 0x3F, 0xFF, 0x20, 0xE8, 0x32, 0x88, 0x0B, 0x7B, 0x8E])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(68, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x05, 0x58, 0xAB, 0xFE, 0x51, 0xA4, 0xF7, 0x4A, 0x9D, 0xF0])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x20, 0x36, 0x12, 0xE1, 0xD1, 0xF2, 0x2B, 0xD4, 0x73, 0x14, 0xE9, 0xC0, 0x3D, 0xDA, 0x5B, 0xB7, 0x57, 0x9F, 0x5C, 0x49, 0x99, 0x83, 0xA4, 0x81, 0xF8, 0xFE, 0x21, 0xC9, 0x49, 0x00, 0x93, 0xD5, 0xEC, 0x7C, 0x63, 0xFD, 0xAC, 0x95, 0xAD, 0x95, 0x37, 0xDC, 0x9E, 0x87, 0xCD, 0x14, 0x39, 0x88, 0xD9, 0x7B, 0xBC, 0xCD, 0xB9, 0xE3, 0x48, 0x51, 0x9D, 0x07, 0xDB, 0x0C, 0x43, 0xE4, 0xA0, 0x69])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(69, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x0A, 0x5D, 0xB0, 0x03, 0x56, 0xA9, 0xFC, 0x4F, 0xA2, 0xF5])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x22, 0xE1, 0xC6, 0x92, 0xC7, 0x6E, 0xE1, 0x98, 0x11, 0x3F, 0x84, 0xA3, 0xD7, 0x3B, 0x6C, 0x5A, 0x2E, 0xC7, 0xCB, 0x8B, 0x77, 0x5A, 0xA6, 0x87, 0x59, 0x47, 0x1E, 0xFC, 0x86, 0xB3, 0xFA, 0x32, 0x03, 0xBB, 0xED, 0x11, 0x81, 0x7C, 0xDF, 0xCC, 0x82, 0xFF, 0xDE, 0x2E, 0xA2, 0xFD, 0xE7, 0xD1, 0x46, 0x66, 0x36, 0x96, 0x36, 0xC6, 0x95, 0x8C, 0x89, 0x6B, 0xBA, 0xE5, 0xEB, 0x0C, 0x51, 0xC1])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(70, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x0F, 0x62, 0xB5, 0x08, 0x5B, 0xAE, 0x01, 0x54, 0xA7, 0xFA])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x12, 0x4B, 0x35, 0xE1, 0xF1, 0x61, 0xA9, 0xFF, 0xE3, 0xD6, 0x5A, 0x90, 0x41, 0xD5, 0x23, 0x5F, 0xA3, 0x65, 0x9D, 0xC9, 0xBE, 0x65, 0x9A, 0x47, 0xC1, 0x6A, 0x0C, 0x2E, 0x6A, 0x75, 0x19, 0xCE, 0x88, 0x92, 0x74, 0x4E, 0x88, 0xFD, 0xD4, 0x03, 0x23, 0x95, 0xC0, 0x2A, 0x07, 0xB7, 0xBB, 0xD6, 0xCF, 0x78, 0x0F, 0xCF, 0xAB, 0x6B, 0x17, 0x9E, 0x60, 0x8E, 0xC9, 0xB0, 0x7B, 0x9A, 0xE6, 0x1F])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(71, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xF8, 0x90, 0x17, 0x36, 0x64, 0x05, 0x49, 0xE3, 0xBA, 0x7D, 0x42, 0xEA, 0x2D, 0x07, 0xB9, 0xF4, 0x92, 0x33, 0xC1, 0x8D, 0x77, 0x30, 0x08, 0xBD, 0x75, 0x55, 0x85, 0xB1, 0xA8, 0xCB, 0xAB, 0x86, 0xC1, 0xE9, 0xA9, 0xB9, 0x1F, 0x1A, 0xD3, 0x34, 0x83, 0xFD, 0x6E, 0xE3, 0x69, 0x6D, 0x65, 0x9C, 0x93, 0x74, 0x26, 0x04, 0x56, 0xA3, 0x6A, 0xAE, 0x11, 0xF0, 0x33, 0xA5, 0x19, 0xCB, 0xD5, 0xD7])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(72, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xAC, 0xBB, 0x38, 0x68, 0x76, 0x65, 0x3D, 0x15, 0x01, 0x0D, 0xEF, 0xA7, 0xC6, 0x5B, 0x36, 0xD7, 0x01, 0xCF, 0xAF, 0x92, 0x7B, 0x41, 0x75, 0x50, 0xBE, 0x32, 0xD0, 0x44, 0x4A, 0x24, 0xDE, 0xB5, 0x89, 0x15, 0x9B, 0x96, 0x5C, 0x67, 0x40, 0x82, 0x3F, 0x6B, 0xDF, 0xC3, 0x78, 0x17, 0x4A, 0xE2, 0xF6, 0x64, 0xDC, 0xA0, 0xB6, 0x8C, 0x62, 0x1D, 0x27, 0x75, 0xBD, 0x13, 0xE6, 0xA7, 0x88, 0xDF])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(73, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x88, 0xBD, 0x48, 0x94, 0x5D, 0xEA, 0x0B, 0xEB, 0x94, 0xD1, 0xF1, 0x3F, 0xC5, 0x89, 0xD6, 0x1F, 0x49, 0x61, 0x04, 0x6D, 0x40, 0x54, 0xB2, 0xEC, 0x27, 0x47, 0x09, 0xDB, 0x1D, 0x8C, 0xC5, 0x47, 0x2D, 0x1C, 0xD0, 0x7D, 0x3C, 0xEB, 0xFC, 0x31, 0xE5, 0x6D, 0xFE, 0xD5, 0x80, 0x29, 0xE5, 0x98, 0xFB, 0x45, 0xD1, 0x95, 0x4B, 0x6C, 0x86, 0xC9, 0xCC, 0x5E, 0xF4, 0x22, 0xFF, 0xAD, 0xFE, 0x32])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(74, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x89, 0x07, 0x82, 0x47, 0x1E, 0x32, 0xE0, 0x42, 0xC1, 0x47, 0x67, 0x28, 0x5A, 0x9B, 0xBD, 0x89, 0x60, 0x5F, 0xEE, 0x5E, 0x38, 0xB9, 0xE7, 0x8E, 0x3D, 0x75, 0x08, 0x21, 0xAC, 0x7B, 0x48, 0x64, 0xA2, 0x8D, 0xA2, 0x7E, 0xB2, 0xEB, 0xBD, 0x64, 0x13, 0xCC, 0x6A, 0x50, 0x66, 0xE5, 0x24, 0x05, 0x06, 0xE3, 0xF3, 0x7C, 0x22, 0x87, 0x6A, 0x7E, 0x95, 0x57, 0xC6, 0xB1, 0xBE, 0x1C, 0xE3, 0x00])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(75, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x33, 0x39, 0x4D, 0x41, 0x64, 0x1D, 0x0D, 0x8E, 0x57, 0x78, 0xCB, 0x72, 0x2C, 0x14, 0x36, 0x30, 0x09, 0x23, 0xF4, 0x01, 0x94, 0xB9, 0x51, 0x21, 0x6F, 0xAA, 0x8B, 0xBE, 0x0A, 0x6E, 0xC7, 0xFC, 0x23, 0x72, 0x4F, 0x8D, 0xD4, 0xE4, 0xE9, 0x22, 0xF9, 0xD9, 0xB9, 0x95, 0x79, 0xC5, 0x76, 0x5D, 0xFC, 0x5A, 0x8C, 0x26, 0x8C, 0x1C, 0xAF, 0x0C, 0x11, 0x4C, 0xF8, 0x14, 0xDB, 0x22, 0x39, 0xD8])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(76, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0x27, 0x88, 0x2D, 0xB2, 0x65, 0xB8, 0x9E, 0x59, 0xAD, 0x89, 0x61, 0x18, 0x80, 0xFE, 0x6D, 0x12, 0x5A, 0x4E, 0x98, 0x74, 0x4C, 0x91, 0xCB, 0xFE, 0x17, 0x06, 0xE6, 0x5A, 0x0A, 0x00, 0xA1, 0xEE, 0x3C, 0x02, 0x00, 0x04, 0xAA, 0x28, 0x7E, 0xCC, 0x20, 0x9E, 0xA7, 0x76, 0x50, 0x45, 0x98, 0x40, 0xD7, 0x3B, 0xB2, 0x89, 0x48, 0x2C, 0x73, 0x2A, 0x02, 0x49, 0x41, 0xE7, 0x2E, 0x32, 0x44, 0xF0])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(77, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00])
testVector = new Uint8Array([0xFD, 0xF2, 0x7A, 0x99, 0xD3, 0x14, 0x40, 0x24, 0xD2, 0x36, 0x3B, 0x98, 0x82, 0xD3, 0x6D, 0x82, 0xC5, 0x05, 0xDA, 0x7B, 0x71, 0x34, 0xC0, 0xD9, 0x3E, 0xA0, 0xC3, 0x5B, 0xC9, 0x09, 0xD9, 0x0E, 0xFB, 0x59, 0xB3, 0xE6, 0x31, 0xF7, 0x17, 0x29, 0x7C, 0x7E, 0xBD, 0x7F, 0xE4, 0xF2, 0x0F, 0xC2, 0x4E, 0x83, 0x8C, 0x36, 0x51, 0xB5, 0xB6, 0xAC, 0x38, 0x64, 0x8C, 0x4B, 0x79, 0x22, 0x8B, 0x3A])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(78, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00])
testVector = new Uint8Array([0xAE, 0x7F, 0x06, 0x0A, 0xC8, 0xB0, 0x05, 0x1C, 0x1A, 0xCB, 0xCB, 0xB2, 0xE7, 0xF1, 0x0E, 0x6F, 0xAD, 0x4C, 0x98, 0x0F, 0xB8, 0x6F, 0x62, 0xFE, 0xAF, 0xCD, 0x73, 0x45, 0xD6, 0x24, 0x48, 0x5E, 0xC4, 0xD7, 0x77, 0x3C, 0x1F, 0xA4, 0x5F, 0xFA, 0x52, 0x34, 0xD2, 0x11, 0x4B, 0xD4, 0xC4, 0x8B, 0xC2, 0x57, 0xD7, 0x7B, 0xC5, 0x24, 0x51, 0x9B, 0xF0, 0x0E, 0x1E, 0x93, 0x47, 0xB1, 0x98, 0x58])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(79, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80])
testVector = new Uint8Array([0x82, 0xE7, 0xFC, 0xB2, 0x19, 0x3D, 0xD7, 0xCC, 0xBD, 0xFB, 0x30, 0xE4, 0xA1, 0xBC, 0x74, 0x0E, 0x27, 0x56, 0xEF, 0x94, 0x67, 0x6A, 0x6D, 0x4B, 0x01, 0xB1, 0xDD, 0x2F, 0x2A, 0x33, 0x5B, 0xB6, 0xBC, 0xB8, 0x5B, 0x10, 0x86, 0xD6, 0xA3, 0x6B, 0xBA, 0x4F, 0x98, 0x48, 0x8F, 0x2A, 0x74, 0xB8, 0xF8, 0x5E, 0xFB, 0xFC, 0x80, 0x82, 0x34, 0x7B, 0xB8, 0xC7, 0x1B, 0x1B, 0xD8, 0x68, 0x2D, 0x1D])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(80, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x00, 0x53, 0xA6, 0xF9, 0x4C, 0x9F, 0xF2, 0x45, 0x98, 0xEB])
iv = new Uint8Array([0x0D, 0x74, 0xDB, 0x42, 0xA9, 0x10, 0x77, 0xDE, 0x45, 0xAC])
testVector = new Uint8Array([0xF4, 0xCD, 0x95, 0x4A, 0x71, 0x7F, 0x26, 0xA7, 0xD6, 0x93, 0x08, 0x30, 0xC4, 0xE7, 0xCF, 0x08, 0x19, 0xF8, 0x0E, 0x03, 0xF2, 0x5F, 0x34, 0x2C, 0x64, 0xAD, 0xC6, 0x6A, 0xBA, 0x7F, 0x8A, 0x8E, 0x6E, 0xAA, 0x49, 0xF2, 0x36, 0x32, 0xAE, 0x3C, 0xD4, 0x1A, 0x7B, 0xD2, 0x90, 0xA0, 0x13, 0x2F, 0x81, 0xC6, 0xD4, 0x04, 0x3B, 0x6E, 0x39, 0x7D, 0x73, 0x88, 0xF3, 0xA0, 0x3B, 0x5F, 0xE3, 0x58])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(81, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x05, 0x58, 0xAB, 0xFE, 0x51, 0xA4, 0xF7, 0x4A, 0x9D, 0xF0])
iv = new Uint8Array([0x16, 0x7D, 0xE4, 0x4B, 0xB2, 0x19, 0x80, 0xE7, 0x4E, 0xB5])
testVector = new Uint8Array([0xA8, 0x50, 0xA9, 0x70, 0xAB, 0xCF, 0x5F, 0x73, 0xBC, 0xC5, 0xDB, 0x76, 0xF6, 0xB5, 0xE8, 0x56, 0x36, 0x2F, 0x1B, 0x36, 0xAC, 0x49, 0x8D, 0x05, 0xC2, 0x0F, 0xBE, 0x77, 0x63, 0x59, 0x8D, 0xE1, 0xFD, 0x98, 0xB0, 0x3C, 0xC5, 0x40, 0x60, 0xE8, 0xC9, 0xC1, 0x9B, 0x16, 0x49, 0x0C, 0x66, 0x5C, 0x36, 0x36, 0xA0, 0x3B, 0xAB, 0x46, 0x65, 0x6A, 0x69, 0x5E, 0xD7, 0x5F, 0x0E, 0x65, 0x9F, 0x04])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(82, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x0A, 0x5D, 0xB0, 0x03, 0x56, 0xA9, 0xFC, 0x4F, 0xA2, 0xF5])
iv = new Uint8Array([0x1F, 0x86, 0xED, 0x54, 0xBB, 0x22, 0x89, 0xF0, 0x57, 0xBE])
testVector = new Uint8Array([0xDE, 0x94, 0x10, 0xC5, 0x13, 0x4B, 0xCB, 0xAD, 0xD0, 0xD2, 0xD9, 0x56, 0x84, 0xE8, 0x38, 0x18, 0x3B, 0x91, 0xB0, 0xE8, 0xC1, 0xFA, 0x17, 0x3C, 0x38, 0xF5, 0xB7, 0x51, 0x03, 0xAB, 0xF0, 0xB8, 0x54, 0x6E, 0xDD, 0xE2, 0x2D, 0x6B, 0xFB, 0x3B, 0xF1, 0xC0, 0x75, 0x4C, 0x6C, 0x42, 0x98, 0x2F, 0xAE, 0xA5, 0xA3, 0xBD, 0x03, 0xDA, 0xFC, 0x0D, 0x15, 0x86, 0xE3, 0x89, 0xB7, 0x8C, 0x58, 0x72])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(83, JSON.stringify(ct) === JSON.stringify(testVector))

key = new Uint8Array([0x0F, 0x62, 0xB5, 0x08, 0x5B, 0xAE, 0x01, 0x54, 0xA7, 0xFA])
iv = new Uint8Array([0x28, 0x8F, 0xF6, 0x5D, 0xC4, 0x2B, 0x92, 0xF9, 0x60, 0xC7])
testVector = new Uint8Array([0xA4, 0x38, 0x6C, 0x6D, 0x76, 0x24, 0x98, 0x3F, 0xEA, 0x8D, 0xBE, 0x73, 0x14, 0xE5, 0xFE, 0x1F, 0x9D, 0x10, 0x20, 0x04, 0xC2, 0xCE, 0xC9, 0x9A, 0xC3, 0xBF, 0xBF, 0x00, 0x3A, 0x66, 0x43, 0x3F, 0x30, 0x89, 0xA9, 0x8F, 0xAD, 0x85, 0x12, 0xC4, 0x9D, 0x7A, 0xAB, 0xC0, 0x63, 0x9F, 0x90, 0xC5, 0xFF, 0xED, 0x06, 0xF9, 0xD3, 0x5A, 0xA8, 0xC8, 0x66, 0x30, 0xE7, 0x6A, 0x83, 0x8E, 0x26, 0xD7])
cipher = new Trivium(key, iv)
ct = cipher.encrypt(pt)
console.log(84, JSON.stringify(ct) === JSON.stringify(testVector))