/*
 * SPDX-FileCopyrightText: 2020, Google LLC
 * SPDX-FileCopyrightText: 2020, microG Project Team
 * SPDX-License-Identifier: Apache-2.0
 * Notice: Portions of this file are derived from work created and shared by Google and used
 *         according to the terms described in the Apache License, Version 2.0.
 *         See https://github.com/google/exposure-notifications-internals
 */

package org.microg.gms.nearby.exposurenotification;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class TestVectors {

    public static byte[] asBytes(int... ints) {
        byte[] bytes = new byte[ints.length];
        for (int i = 0; i < ints.length; i++) {
            int value = ints[i];
            bytes[i] = (byte) value;
        }
        return bytes;
    }

    /**
     * Class holding a matched pair of RPI and AEM values.
     */
    public static class AdvertisedData {
        private final byte[] rollingProximityIndicator;
        private final byte[] associatedEncryptedMetadata;

        AdvertisedData(byte[] rollingProximityIndicator, byte[] associatedEncryptedMetadata) {
            this.rollingProximityIndicator = rollingProximityIndicator;
            this.associatedEncryptedMetadata = associatedEncryptedMetadata;
        }

        public byte[] get_RPI() {
            return rollingProximityIndicator.clone();
        }

        public byte[] get_AEM() {
            return associatedEncryptedMetadata.clone();
        }

        public byte[] get_merged() {
            byte[] bytes = new byte[rollingProximityIndicator.length + associatedEncryptedMetadata.length];
            System.arraycopy(rollingProximityIndicator, 0, bytes, 0, rollingProximityIndicator.length);
            System.arraycopy(associatedEncryptedMetadata, 0, bytes, rollingProximityIndicator.length, associatedEncryptedMetadata.length);
            return bytes;
        }
    }

    public static byte[] get_TEMPORARY_TRACING_KEY() {
        return TEMPORARY_TRACING_KEY.clone();
    }

    public static byte[] get_RPIK() {
        return RPIK.clone();
    }

    public static byte[] get_AEMK() {
        return AEMK.clone();
    }

    public static byte[] get_BLE_METADATA() {
        return BLE_METADATA.clone();
    }

    public static String get_RPIK_HKDF_INFO_STRING() {
        return "EN-RPIK";
    }

    public static String get_RPI_AES_PADDED_STRING() {
        return "EN-RPI";
    }

    public static String get_AEMK_HKDF_INFO_STRING() {
        return "EN-AEMK";
    }

    // From TestVectors.h.txt
    // ------------------------------------------------------------------------------
    public static final int KEY_GENERATION_NSECONDS = 1585785600;
    public static final int CTINTERVAL_NUMBER_OF_GENERATED_KEY = 2642976;
    public static final int ID_ROLLING_PERIOD_MINUTES = 10;
    public static final int KEY_ROLLING_PERIOD_MULTIPLE_OF_ID_PERIOD = 144;

    private static final byte[] TEMPORARY_TRACING_KEY =
            asBytes(
                    0x75, 0xc7, 0x34, 0xc6, 0xdd, 0x1a, 0x78, 0x2d, 0xe7, 0xa9, 0x65, 0xda, 0x5e, 0xb9, 0x31,
                    0x25);

    private static final byte[] RPIK =
            asBytes(
                    0x18, 0x5a, 0xd9, 0x1d, 0xb6, 0x9e, 0xc7, 0xdd, 0x04, 0x89, 0x60, 0xf1, 0xf3, 0xba, 0x61,
                    0x75);
    private static final byte[] AEMK =
            asBytes(
                    0xd5, 0x7c, 0x46, 0xaf, 0x7a, 0x1d, 0x83, 0x96, 0x5b, 0x9b, 0xed, 0x8b, 0xd1, 0x52, 0x93,
                    0x6a);
    private static final byte[] BLE_METADATA = asBytes(0x40, 0x08, 0x00, 0x00);
    private static final byte[] RPI0 =
            asBytes(
                    0x8b, 0xe6, 0xcd, 0x37, 0x1c, 0x5c, 0x89, 0x16, 0x04, 0xbf, 0xbe, 0x49, 0xdf, 0x84, 0x50,
                    0x96);
    private static final byte[] AEM0 = asBytes(0x72, 0x03, 0x38, 0x74);
    private static final byte[] RPI1 =
            asBytes(
                    0x3c, 0x9a, 0x1d, 0xe5, 0xdd, 0x6b, 0x02, 0xaf, 0xa7, 0xfd, 0xed, 0x7b, 0x57, 0x0b, 0x3e,
                    0x56);
    private static final byte[] AEM1 = asBytes(0xc2, 0x92, 0x11, 0xb1);
    private static final byte[] RPI2 =
            asBytes(
                    0x24, 0x3f, 0xfe, 0x9a, 0x3b, 0x08, 0xbd, 0xed, 0x30, 0x94, 0xba, 0xc8, 0x63, 0x0b, 0xb8,
                    0xad);
    private static final byte[] AEM2 = asBytes(0x6a, 0xdf, 0xad, 0x03);
    private static final byte[] RPI3 =
            asBytes(
                    0xdf, 0xc3, 0xed, 0x26, 0x5e, 0x97, 0xd0, 0xea, 0xbb, 0x63, 0x0e, 0x16, 0x8b, 0x42, 0x14,
                    0xed);
    private static final byte[] AEM3 = asBytes(0xf1, 0xe2, 0xf8, 0x0b);
    private static final byte[] RPI4 =
            asBytes(
                    0xb3, 0xb8, 0x5a, 0x69, 0xeb, 0xae, 0xc7, 0x8d, 0xb7, 0x39, 0x85, 0x2d, 0x1f, 0x34, 0xe0,
                    0xfa);
    private static final byte[] AEM4 = asBytes(0x56, 0x68, 0xc4, 0x74);
    private static final byte[] RPI5 =
            asBytes(
                    0x29, 0x8a, 0xbd, 0x6f, 0xda, 0xd2, 0x9e, 0xfb, 0xf0, 0xf8, 0x5a, 0x63, 0x95, 0x6c, 0xf1,
                    0x88);
    private static final byte[] AEM5 = asBytes(0xf7, 0xb9, 0x7e, 0x84);
    private static final byte[] RPI6 =
            asBytes(
                    0x10, 0x5e, 0x82, 0x21, 0xdd, 0x60, 0x3d, 0x25, 0xb9, 0x4a, 0xba, 0x0c, 0x3c, 0xc8, 0xde,
                    0xe1);
    private static final byte[] AEM6 = asBytes(0xee, 0xab, 0xfd, 0xc7);
    private static final byte[] RPI7 =
            asBytes(
                    0x98, 0x88, 0xca, 0x7e, 0x67, 0x38, 0xec, 0x4b, 0xc6, 0xe4, 0x20, 0xb2, 0x0f, 0x87, 0x8b,
                    0x3a);
    private static final byte[] AEM7 = asBytes(0x9f, 0x84, 0xa9, 0xa6);
    private static final byte[] RPI8 =
            asBytes(
                    0x86, 0x94, 0xa7, 0x9a, 0xe9, 0x96, 0x71, 0xbe, 0x3f, 0x18, 0xaa, 0xf6, 0xb0, 0x90, 0x65,
                    0x7a);
    private static final byte[] AEM8 = asBytes(0xc1, 0x1a, 0xcb, 0x4d);
    private static final byte[] RPI9 =
            asBytes(
                    0xb8, 0xcd, 0xe2, 0x8a, 0xd2, 0x0d, 0x1c, 0xd2, 0xfd, 0xd7, 0x36, 0x9d, 0xc0, 0xc6, 0xf7,
                    0xc8);
    private static final byte[] AEM9 = asBytes(0x1f, 0x8d, 0x53, 0xde);
    private static final byte[] RPI10 =
            asBytes(
                    0xf6, 0x01, 0x23, 0xc6, 0x7b, 0xd2, 0xfc, 0x4b, 0x62, 0x00, 0x2b, 0x4b, 0x7d, 0x59, 0x5b,
                    0xa6);
    private static final byte[] AEM10 = asBytes(0xe0, 0xa7, 0xf9, 0xf2);
    private static final byte[] RPI11 =
            asBytes(
                    0x8a, 0x84, 0xc8, 0x6e, 0x05, 0xf7, 0xa8, 0x77, 0x2a, 0xae, 0x7a, 0x80, 0x68, 0x6e, 0x1a,
                    0x1c);
    private static final byte[] AEM11 = asBytes(0xf4, 0xb7, 0xb0, 0x9d);
    private static final byte[] RPI12 =
            asBytes(
                    0xac, 0x46, 0x1b, 0xf2, 0xb9, 0x3b, 0x0d, 0x90, 0x84, 0x17, 0x46, 0xf5, 0x1a, 0xde, 0xd6,
                    0xc0);
    private static final byte[] AEM12 = asBytes(0x73, 0x91, 0xdd, 0x64);
    private static final byte[] RPI13 =
            asBytes(
                    0xf2, 0x56, 0x7e, 0xed, 0x0a, 0xa1, 0xcd, 0xf2, 0xcd, 0x3d, 0x0b, 0xd2, 0x82, 0x52, 0xf1,
                    0x96);
    private static final byte[] AEM13 = asBytes(0x12, 0x7d, 0xb0, 0x9e);
    private static final byte[] RPI14 =
            asBytes(
                    0xa2, 0x55, 0x22, 0x5b, 0xaa, 0x9e, 0x37, 0xb7, 0x30, 0xa9, 0x5f, 0x99, 0x7a, 0x69, 0x72,
                    0xf5);
    private static final byte[] AEM14 = asBytes(0x43, 0x5e, 0xa5, 0x56);
    private static final byte[] RPI15 =
            asBytes(
                    0x04, 0xcf, 0xae, 0xe4, 0x10, 0x21, 0xcb, 0x7d, 0x4d, 0x02, 0x0b, 0x30, 0x6b, 0x24, 0xbe,
                    0xa8);
    private static final byte[] AEM15 = asBytes(0xdc, 0x1f, 0x19, 0x06);
    private static final byte[] RPI16 =
            asBytes(
                    0xf5, 0x37, 0x2b, 0xbc, 0x92, 0xf7, 0x80, 0x59, 0x64, 0x70, 0x1e, 0x87, 0x9b, 0x48, 0xd4,
                    0x31);
    private static final byte[] AEM16 = asBytes(0xb3, 0xea, 0xaf, 0xdd);
    private static final byte[] RPI17 =
            asBytes(
                    0xf2, 0xc8, 0x11, 0x54, 0x63, 0x82, 0xb1, 0x0d, 0xf1, 0xac, 0x06, 0xc3, 0x2c, 0x61, 0x7b,
                    0xa7);
    private static final byte[] AEM17 = asBytes(0xcd, 0x51, 0x86, 0xf9);
    private static final byte[] RPI18 =
            asBytes(
                    0xf8, 0xf3, 0x44, 0x1f, 0x76, 0x22, 0x3d, 0xac, 0x15, 0xec, 0x6b, 0x35, 0xfd, 0xb2, 0x51,
                    0x40);
    private static final byte[] AEM18 = asBytes(0x7f, 0x38, 0x7e, 0x7f);
    private static final byte[] RPI19 =
            asBytes(
                    0xd0, 0x71, 0x83, 0xdb, 0x3c, 0x80, 0x45, 0x08, 0x7d, 0x61, 0xee, 0x9e, 0x73, 0x0c, 0x93,
                    0x06);
    private static final byte[] AEM19 = asBytes(0x1a, 0x42, 0xa1, 0x5b);
    private static final byte[] RPI20 =
            asBytes(
                    0xc7, 0x42, 0xdd, 0x9c, 0x96, 0xa3, 0xe6, 0xfa, 0x7c, 0x4f, 0x22, 0x62, 0x1d, 0xac, 0xc2,
                    0x4d);
    private static final byte[] AEM20 = asBytes(0x06, 0x39, 0x0d, 0xed);
    private static final byte[] RPI21 =
            asBytes(
                    0x08, 0x23, 0x33, 0xfa, 0xd9, 0xfa, 0x29, 0x2a, 0xb8, 0x99, 0xd6, 0x00, 0x0c, 0x65, 0x97,
                    0x97);
    private static final byte[] AEM21 = asBytes(0x0f, 0x01, 0xbc, 0xd7);
    private static final byte[] RPI22 =
            asBytes(
                    0xbe, 0x43, 0x00, 0xda, 0xfb, 0x8d, 0x07, 0xc8, 0x8c, 0xb2, 0xb5, 0x07, 0x7a, 0x06, 0x11,
                    0x66);
    private static final byte[] AEM22 = asBytes(0xc7, 0xbf, 0xbb, 0x92);
    private static final byte[] RPI23 =
            asBytes(
                    0x5f, 0xed, 0x1b, 0x4d, 0x3b, 0x3a, 0x13, 0x33, 0x2f, 0x05, 0x44, 0x75, 0x60, 0x35, 0x26,
                    0x32);
    private static final byte[] AEM23 = asBytes(0x21, 0x7c, 0x8e, 0x4a);
    private static final byte[] RPI24 =
            asBytes(
                    0xfd, 0x1e, 0xe2, 0xcc, 0x5c, 0x60, 0xe6, 0xee, 0xe6, 0x1f, 0x04, 0x91, 0x9f, 0x67, 0x59,
                    0xa7);
    private static final byte[] AEM24 = asBytes(0xee, 0x63, 0x9b, 0xd6);
    private static final byte[] RPI25 =
            asBytes(
                    0x96, 0xad, 0xf5, 0xb8, 0xdc, 0x7e, 0xe7, 0x5d, 0xf4, 0x6f, 0xbd, 0x8a, 0x1f, 0xc4, 0xad,
                    0x0d);
    private static final byte[] AEM25 = asBytes(0x60, 0x8c, 0x13, 0x0f);
    private static final byte[] RPI26 =
            asBytes(
                    0xfa, 0x4b, 0xa2, 0x20, 0x6d, 0x42, 0xa1, 0xc8, 0x0d, 0x52, 0x48, 0xae, 0x68, 0x83, 0x09,
                    0xa4);
    private static final byte[] AEM26 = asBytes(0x74, 0xb2, 0xc8, 0x73);
    private static final byte[] RPI27 =
            asBytes(
                    0xa5, 0x90, 0xf9, 0x5d, 0xbf, 0x24, 0x02, 0x61, 0xda, 0x10, 0x1a, 0x7c, 0xdb, 0x24, 0xdb,
                    0xba);
    private static final byte[] AEM27 = asBytes(0x95, 0x6a, 0x95, 0xeb);
    private static final byte[] RPI28 =
            asBytes(
                    0x67, 0xe8, 0x1b, 0x91, 0xd1, 0xcf, 0x9e, 0x09, 0x58, 0x13, 0x54, 0x29, 0xda, 0xd0, 0x1e,
                    0x82);
    private static final byte[] AEM28 = asBytes(0xc6, 0xfa, 0x3c, 0x7a);
    private static final byte[] RPI29 =
            asBytes(
                    0x18, 0x3c, 0xac, 0x22, 0x36, 0xc3, 0xe0, 0x53, 0x3b, 0xe4, 0x70, 0x4d, 0x83, 0x6e, 0x47,
                    0x55);
    private static final byte[] AEM29 = asBytes(0xa2, 0xab, 0xc7, 0x03);
    private static final byte[] RPI30 =
            asBytes(
                    0x34, 0x11, 0x62, 0x55, 0x1c, 0x29, 0x31, 0x9b, 0xc5, 0x35, 0x38, 0xed, 0xfc, 0xf2, 0x30,
                    0x40);
    private static final byte[] AEM30 = asBytes(0x80, 0x09, 0xb2, 0xaa);
    private static final byte[] RPI31 =
            asBytes(
                    0x22, 0x51, 0x68, 0x70, 0x18, 0x21, 0x4b, 0x65, 0xdd, 0x8e, 0xe8, 0x3e, 0xae, 0xd3, 0x30,
                    0xab);
    private static final byte[] AEM31 = asBytes(0xcf, 0xe8, 0x04, 0xcb);
    private static final byte[] RPI32 =
            asBytes(
                    0xa4, 0xcf, 0x6e, 0x50, 0x21, 0x5f, 0xe2, 0x78, 0xcc, 0x5c, 0xff, 0x1b, 0x05, 0x34, 0xa3,
                    0xe0);
    private static final byte[] AEM32 = asBytes(0xcb, 0x2a, 0x7e, 0x22);
    private static final byte[] RPI33 =
            asBytes(
                    0xdf, 0x8f, 0x2a, 0xc3, 0x03, 0x23, 0x2b, 0x2e, 0x5b, 0x3e, 0xfd, 0x86, 0x81, 0xaa, 0xa8,
                    0xdd);
    private static final byte[] AEM33 = asBytes(0x65, 0x03, 0xa7, 0x27);
    private static final byte[] RPI34 =
            asBytes(
                    0xba, 0x2e, 0x75, 0xd7, 0xf4, 0x8c, 0xf5, 0x5c, 0x0c, 0x86, 0x8f, 0xd4, 0x5c, 0xf1, 0x6b,
                    0x5c);
    private static final byte[] AEM34 = asBytes(0x8f, 0x29, 0x78, 0x7e);
    private static final byte[] RPI35 =
            asBytes(
                    0xec, 0x6a, 0x40, 0x05, 0x8d, 0xeb, 0xff, 0xff, 0x3c, 0x51, 0x97, 0x7f, 0x24, 0x56, 0x2e,
                    0x21);
    private static final byte[] AEM35 = asBytes(0xb2, 0xad, 0xd3, 0xb7);
    private static final byte[] RPI36 =
            asBytes(
                    0x6a, 0x68, 0xe3, 0x0b, 0x2f, 0xb9, 0x3b, 0x5d, 0xf7, 0x8e, 0xe3, 0xa9, 0xa3, 0x50, 0xa6,
                    0xce);
    private static final byte[] AEM36 = asBytes(0x1b, 0xfb, 0x46, 0x0a);
    private static final byte[] RPI37 =
            asBytes(
                    0x8d, 0x33, 0xa7, 0x05, 0x62, 0x62, 0x99, 0x94, 0xf8, 0xdf, 0x99, 0x05, 0x2b, 0x0e, 0xb6,
                    0x9a);
    private static final byte[] AEM37 = asBytes(0x8e, 0xcf, 0x07, 0x7b);
    private static final byte[] RPI38 =
            asBytes(
                    0x21, 0x05, 0x3c, 0xcb, 0x8f, 0x92, 0x51, 0x11, 0xe2, 0x54, 0xbd, 0x69, 0x4e, 0x97, 0x94,
                    0x6b);
    private static final byte[] AEM38 = asBytes(0x2b, 0xa7, 0x7b, 0x38);
    private static final byte[] RPI39 =
            asBytes(
                    0xe1, 0xc9, 0xcd, 0xf2, 0x0f, 0x90, 0x0a, 0xe6, 0xd2, 0x4b, 0xf7, 0xbc, 0xb4, 0xe6, 0x61,
                    0x35);
    private static final byte[] AEM39 = asBytes(0x8c, 0x12, 0x40, 0xde);
    private static final byte[] RPI40 =
            asBytes(
                    0xba, 0xf7, 0x89, 0xf5, 0x50, 0x94, 0x6b, 0x43, 0x10, 0x64, 0x45, 0x07, 0x71, 0xb2, 0xa1,
                    0x43);
    private static final byte[] AEM40 = asBytes(0x43, 0x89, 0x99, 0xb6);
    private static final byte[] RPI41 =
            asBytes(
                    0xf7, 0xf9, 0x1e, 0xc2, 0x50, 0x85, 0xd0, 0x35, 0x3e, 0x02, 0x78, 0xe5, 0x98, 0xcc, 0x62,
                    0x01);
    private static final byte[] AEM41 = asBytes(0x1d, 0xcb, 0xdc, 0x6e);
    private static final byte[] RPI42 =
            asBytes(
                    0xc8, 0x93, 0x3d, 0x70, 0x22, 0x0b, 0xa9, 0xc8, 0xc1, 0x48, 0x39, 0x3a, 0x39, 0x59, 0xd2,
                    0x56);
    private static final byte[] AEM42 = asBytes(0x63, 0x85, 0xff, 0xda);
    private static final byte[] RPI43 =
            asBytes(
                    0xf2, 0x93, 0x2e, 0x6e, 0x6e, 0xf6, 0x0f, 0x0f, 0x5b, 0xbc, 0xe4, 0x39, 0x10, 0x0a, 0x90,
                    0xe4);
    private static final byte[] AEM43 = asBytes(0x69, 0x6c, 0x0c, 0xdf);
    private static final byte[] RPI44 =
            asBytes(
                    0x18, 0xf5, 0xd8, 0x10, 0x2a, 0x59, 0x30, 0xd8, 0x02, 0x30, 0xf2, 0xc3, 0x9a, 0x42, 0x66,
                    0xd6);
    private static final byte[] AEM44 = asBytes(0x63, 0x84, 0x2b, 0xba);
    private static final byte[] RPI45 =
            asBytes(
                    0xe6, 0x07, 0x5c, 0x28, 0x93, 0x9f, 0xb0, 0xc6, 0x72, 0x46, 0xce, 0x38, 0xc5, 0xff, 0x93,
                    0x8a);
    private static final byte[] AEM45 = asBytes(0xb7, 0xe2, 0x2c, 0x60);
    private static final byte[] RPI46 =
            asBytes(
                    0x66, 0x16, 0x88, 0x62, 0xbc, 0x44, 0x5f, 0x48, 0xe5, 0xb0, 0xed, 0x07, 0xe1, 0xdf, 0x3f,
                    0x5a);
    private static final byte[] AEM46 = asBytes(0xd2, 0xe7, 0xd6, 0xd8);
    private static final byte[] RPI47 =
            asBytes(
                    0x1d, 0x0a, 0x01, 0xc3, 0x8d, 0xa4, 0xac, 0x41, 0xec, 0x7a, 0x63, 0x8f, 0x5d, 0xf7, 0x05,
                    0xa9);
    private static final byte[] AEM47 = asBytes(0x91, 0xbe, 0x92, 0x2c);
    private static final byte[] RPI48 =
            asBytes(
                    0xa7, 0x37, 0x00, 0x1a, 0x2d, 0x2f, 0x80, 0x2c, 0x64, 0x78, 0x9a, 0x99, 0x52, 0xe6, 0xd1,
                    0xa7);
    private static final byte[] AEM48 = asBytes(0x7e, 0x04, 0x21, 0xbb);
    private static final byte[] RPI49 =
            asBytes(
                    0x7c, 0x37, 0x25, 0xb6, 0x08, 0x4e, 0x68, 0x1f, 0xb3, 0x4d, 0x26, 0xc3, 0xa3, 0x94, 0xa6,
                    0x43);
    private static final byte[] AEM49 = asBytes(0x7e, 0xa5, 0x20, 0x9f);
    private static final byte[] RPI50 =
            asBytes(
                    0x26, 0xd1, 0xf8, 0x36, 0x55, 0x7a, 0x25, 0x9a, 0x81, 0xb5, 0xdb, 0x54, 0x19, 0xc6, 0xa7,
                    0x29);
    private static final byte[] AEM50 = asBytes(0x1c, 0x92, 0x06, 0x28);
    private static final byte[] RPI51 =
            asBytes(
                    0xeb, 0xc2, 0xa6, 0x06, 0x28, 0x54, 0xd1, 0xec, 0x62, 0x7b, 0x1f, 0x6e, 0x84, 0x32, 0xe1,
                    0x66);
    private static final byte[] AEM51 = asBytes(0x4a, 0x76, 0x46, 0x32);
    private static final byte[] RPI52 =
            asBytes(
                    0x11, 0x32, 0x74, 0xe8, 0x0c, 0x31, 0xcf, 0xcd, 0x81, 0xc2, 0xad, 0x08, 0x64, 0x44, 0x51,
                    0x78);
    private static final byte[] AEM52 = asBytes(0x69, 0xa7, 0x49, 0xb6);
    private static final byte[] RPI53 =
            asBytes(
                    0x45, 0x67, 0x97, 0x6c, 0x48, 0xbe, 0x72, 0x59, 0x06, 0x24, 0x7d, 0x0b, 0xd8, 0x1b, 0xb8,
                    0x11);
    private static final byte[] AEM53 = asBytes(0x6f, 0x94, 0x85, 0xdb);
    private static final byte[] RPI54 =
            asBytes(
                    0x74, 0x81, 0x54, 0xba, 0x52, 0x3a, 0x1a, 0xa8, 0x10, 0xb7, 0x06, 0x2a, 0x13, 0xe5, 0xaa,
                    0x68);
    private static final byte[] AEM54 = asBytes(0x74, 0x78, 0x07, 0x23);
    private static final byte[] RPI55 =
            asBytes(
                    0x30, 0xbc, 0xeb, 0x33, 0x45, 0x74, 0x51, 0x53, 0x35, 0x23, 0x65, 0x99, 0x85, 0x87, 0xcd,
                    0x10);
    private static final byte[] AEM55 = asBytes(0x89, 0x17, 0xda, 0x61);
    private static final byte[] RPI56 =
            asBytes(
                    0x8f, 0x2d, 0x7b, 0x87, 0x00, 0xa8, 0x2f, 0xd4, 0x51, 0x4d, 0xfa, 0x42, 0x02, 0xee, 0x29,
                    0x8f);
    private static final byte[] AEM56 = asBytes(0xfe, 0xc4, 0xf8, 0xb1);
    private static final byte[] RPI57 =
            asBytes(
                    0x0e, 0x66, 0x49, 0x53, 0x70, 0x0c, 0xdf, 0xc0, 0xd2, 0x79, 0x2f, 0xad, 0xf0, 0x73, 0x29,
                    0xeb);
    private static final byte[] AEM57 = asBytes(0x78, 0x1a, 0x3e, 0xaf);
    private static final byte[] RPI58 =
            asBytes(
                    0xf4, 0x49, 0x58, 0xc4, 0xdd, 0x70, 0xd9, 0x96, 0x8a, 0x26, 0xfd, 0x60, 0xba, 0x92, 0x72,
                    0x90);
    private static final byte[] AEM58 = asBytes(0xb9, 0x75, 0x9b, 0x61);
    private static final byte[] RPI59 =
            asBytes(
                    0x55, 0xfd, 0x2f, 0x6c, 0xbd, 0xe0, 0xe1, 0x3f, 0xd2, 0x2c, 0x0b, 0x3d, 0xb1, 0x62, 0x28,
                    0xe5);
    private static final byte[] AEM59 = asBytes(0x48, 0x3c, 0x94, 0x10);
    private static final byte[] RPI60 =
            asBytes(
                    0x49, 0xf3, 0xf9, 0xd1, 0x24, 0x69, 0xdc, 0xc9, 0xed, 0x35, 0x63, 0x64, 0xc3, 0x00, 0x66,
                    0xe4);
    private static final byte[] AEM60 = asBytes(0x2d, 0xa6, 0xeb, 0xac);
    private static final byte[] RPI61 =
            asBytes(
                    0xc5, 0x7d, 0x2d, 0x6e, 0x0d, 0x25, 0xa0, 0x65, 0x1c, 0xd7, 0x27, 0x86, 0xf8, 0xc9, 0x51,
                    0xce);
    private static final byte[] AEM61 = asBytes(0x43, 0xea, 0xcf, 0x34);
    private static final byte[] RPI62 =
            asBytes(
                    0x88, 0xef, 0x25, 0x63, 0x51, 0xac, 0x49, 0xdf, 0xd1, 0x5a, 0xb5, 0xa2, 0xde, 0x97, 0xc0,
                    0x13);
    private static final byte[] AEM62 = asBytes(0xb9, 0xa1, 0x36, 0x53);
    private static final byte[] RPI63 =
            asBytes(
                    0xd0, 0xfb, 0x6f, 0xd6, 0xdb, 0x89, 0xda, 0x52, 0x36, 0x1f, 0x1a, 0x30, 0xfb, 0x43, 0x6c,
                    0xe7);
    private static final byte[] AEM63 = asBytes(0x35, 0x6d, 0xea, 0x55);
    private static final byte[] RPI64 =
            asBytes(
                    0x8a, 0x42, 0xa3, 0x30, 0xf0, 0x19, 0x28, 0xe5, 0x16, 0x31, 0x23, 0x19, 0x81, 0x60, 0x3f,
                    0xd5);
    private static final byte[] AEM64 = asBytes(0x35, 0x05, 0xb7, 0xf3);
    private static final byte[] RPI65 =
            asBytes(
                    0x6e, 0x51, 0xb2, 0xa2, 0xae, 0xcb, 0xab, 0x1d, 0xf8, 0x08, 0x26, 0xef, 0x6d, 0x1e, 0x19,
                    0x58);
    private static final byte[] AEM65 = asBytes(0x5c, 0x05, 0xcd, 0x94);
    private static final byte[] RPI66 =
            asBytes(
                    0x3c, 0xe6, 0x81, 0xa2, 0x8b, 0x1b, 0xe1, 0x9c, 0x9e, 0x36, 0xb9, 0xc5, 0x80, 0xb1, 0x23,
                    0xab);
    private static final byte[] AEM66 = asBytes(0x98, 0x47, 0x45, 0xd6);
    private static final byte[] RPI67 =
            asBytes(
                    0x1e, 0x95, 0x8e, 0xd8, 0x9b, 0x86, 0xb9, 0x89, 0x77, 0xf7, 0x9e, 0x1b, 0x83, 0xf3, 0xd0,
                    0x5f);
    private static final byte[] AEM67 = asBytes(0x93, 0xfd, 0xf7, 0x08);
    private static final byte[] RPI68 =
            asBytes(
                    0x1d, 0x66, 0x7b, 0x01, 0xd6, 0x63, 0x4b, 0x5f, 0x3b, 0x6f, 0x33, 0xac, 0x4b, 0x15, 0x0d,
                    0x23);
    private static final byte[] AEM68 = asBytes(0xd7, 0x0f, 0x74, 0x4c);
    private static final byte[] RPI69 =
            asBytes(
                    0x67, 0xf2, 0x22, 0x15, 0x6c, 0x51, 0x7d, 0xeb, 0xc0, 0x70, 0x68, 0xcb, 0xc5, 0xee, 0xc1,
                    0xdd);
    private static final byte[] AEM69 = asBytes(0x60, 0x57, 0x8c, 0x31);
    private static final byte[] RPI70 =
            asBytes(
                    0xa8, 0x45, 0x4b, 0x9c, 0x94, 0x7d, 0x16, 0x25, 0xee, 0x3f, 0xba, 0x26, 0x07, 0xc2, 0x3a,
                    0xff);
    private static final byte[] AEM70 = asBytes(0x79, 0x00, 0xee, 0xad);
    private static final byte[] RPI71 =
            asBytes(
                    0x41, 0x6f, 0xfc, 0x7a, 0x32, 0xfc, 0xfd, 0xa9, 0xa3, 0x16, 0xd0, 0x17, 0x90, 0xe3, 0x19,
                    0x45);
    private static final byte[] AEM71 = asBytes(0xc1, 0x22, 0xad, 0x68);
    private static final byte[] RPI72 =
            asBytes(
                    0xc1, 0x9a, 0x30, 0xc3, 0x9c, 0x9c, 0x3a, 0x08, 0x9b, 0xca, 0xdd, 0xe1, 0xc6, 0x69, 0x94,
                    0x47);
    private static final byte[] AEM72 = asBytes(0x34, 0x0a, 0xa3, 0x82);
    private static final byte[] RPI73 =
            asBytes(
                    0x78, 0x6d, 0xdf, 0xae, 0x6f, 0xc7, 0x7c, 0x4c, 0x41, 0x0c, 0x4e, 0xc3, 0x2d, 0x34, 0x24,
                    0x7d);
    private static final byte[] AEM73 = asBytes(0x67, 0xc6, 0x0d, 0xfb);
    private static final byte[] RPI74 =
            asBytes(
                    0xef, 0x0f, 0xd3, 0xa9, 0x5b, 0x96, 0x61, 0xe1, 0xfc, 0xcb, 0x4e, 0x30, 0xcd, 0xe3, 0x2c,
                    0x51);
    private static final byte[] AEM74 = asBytes(0x45, 0x56, 0xb6, 0x73);
    private static final byte[] RPI75 =
            asBytes(
                    0xfc, 0x1f, 0x8a, 0x66, 0xf4, 0x05, 0xcc, 0xb6, 0x3d, 0xc3, 0xe4, 0x82, 0x07, 0xda, 0x77,
                    0x88);
    private static final byte[] AEM75 = asBytes(0x9e, 0x4f, 0x1d, 0xb4);
    private static final byte[] RPI76 =
            asBytes(
                    0x0e, 0xac, 0xc2, 0x86, 0x31, 0xb1, 0x0f, 0x44, 0x98, 0x36, 0x86, 0x66, 0x13, 0x0f, 0xf0,
                    0xc9);
    private static final byte[] AEM76 = asBytes(0x5b, 0xe0, 0x4e, 0x9d);
    private static final byte[] RPI77 =
            asBytes(
                    0xe8, 0xdb, 0x4a, 0x46, 0x26, 0x38, 0x5a, 0xe6, 0xe3, 0xb2, 0x45, 0x1d, 0x0a, 0x66, 0xed,
                    0xbf);
    private static final byte[] AEM77 = asBytes(0x80, 0x6a, 0xf2, 0xf9);
    private static final byte[] RPI78 =
            asBytes(
                    0xc6, 0x00, 0x67, 0x8d, 0x4f, 0xbe, 0x92, 0x45, 0xad, 0x49, 0x73, 0xb1, 0xc8, 0x97, 0x1b,
                    0xc5);
    private static final byte[] AEM78 = asBytes(0x7a, 0xf8, 0xd4, 0xfd);
    private static final byte[] RPI79 =
            asBytes(
                    0x08, 0x19, 0x26, 0xc3, 0x61, 0x83, 0x4c, 0x5c, 0x1d, 0x43, 0x19, 0xb8, 0x40, 0xf3, 0x15,
                    0xae);
    private static final byte[] AEM79 = asBytes(0xfc, 0x8d, 0xdd, 0xd0);
    private static final byte[] RPI80 =
            asBytes(
                    0x1d, 0x82, 0x9e, 0xaf, 0xa0, 0x42, 0x32, 0xa6, 0xbb, 0x4d, 0x3c, 0x20, 0x22, 0xac, 0x3d,
                    0x0f);
    private static final byte[] AEM80 = asBytes(0xda, 0x88, 0x15, 0x68);
    private static final byte[] RPI81 =
            asBytes(
                    0x79, 0x8a, 0xbc, 0xe8, 0xc8, 0xf6, 0x25, 0x10, 0xde, 0x59, 0x5a, 0x99, 0x73, 0xfb, 0x21,
                    0x8e);
    private static final byte[] AEM81 = asBytes(0x13, 0x95, 0xcf, 0x7b);
    private static final byte[] RPI82 =
            asBytes(
                    0x61, 0xfc, 0x0d, 0xeb, 0x47, 0x08, 0x4f, 0xda, 0xf1, 0x48, 0x3e, 0x34, 0x2d, 0x73, 0xb1,
                    0x48);
    private static final byte[] AEM82 = asBytes(0xd9, 0xe2, 0x5d, 0xb6);
    private static final byte[] RPI83 =
            asBytes(
                    0x49, 0x69, 0xed, 0xd4, 0x0f, 0x3e, 0xab, 0x46, 0x8b, 0x8a, 0x8d, 0x49, 0x68, 0x5a, 0x4e,
                    0xdd);
    private static final byte[] AEM83 = asBytes(0xc1, 0xb2, 0x05, 0x97);
    private static final byte[] RPI84 =
            asBytes(
                    0x1d, 0x69, 0xd6, 0xd4, 0x15, 0x8a, 0x31, 0x8f, 0x1d, 0x9c, 0xaf, 0xba, 0x13, 0x58, 0x70,
                    0x17);
    private static final byte[] AEM84 = asBytes(0xeb, 0x53, 0x91, 0x99);
    private static final byte[] RPI85 =
            asBytes(
                    0xab, 0x7c, 0x61, 0xf1, 0xcc, 0xa8, 0x13, 0xfd, 0x36, 0xe8, 0xf1, 0xb1, 0xe5, 0xdf, 0x6a,
                    0x0f);
    private static final byte[] AEM85 = asBytes(0xc8, 0x1a, 0xb8, 0x54);
    private static final byte[] RPI86 =
            asBytes(
                    0x94, 0xf2, 0x4f, 0xde, 0xc1, 0x7a, 0xa3, 0x1f, 0x74, 0xf2, 0x02, 0xae, 0x4a, 0x68, 0x74,
                    0xbe);
    private static final byte[] AEM86 = asBytes(0x46, 0xee, 0x82, 0xdc);
    private static final byte[] RPI87 =
            asBytes(
                    0x6e, 0x5d, 0xe0, 0x25, 0x79, 0xd3, 0xdf, 0xb1, 0x94, 0xcc, 0x7b, 0xd4, 0x92, 0x70, 0x25,
                    0x3d);
    private static final byte[] AEM87 = asBytes(0x8a, 0x05, 0x28, 0xbd);
    private static final byte[] RPI88 =
            asBytes(
                    0xfe, 0x3e, 0x1e, 0x36, 0x21, 0x77, 0x3f, 0x18, 0x80, 0x40, 0xaa, 0x5d, 0xb3, 0xff, 0x1d,
                    0x4e);
    private static final byte[] AEM88 = asBytes(0x28, 0x03, 0x3a, 0xae);
    private static final byte[] RPI89 =
            asBytes(
                    0xd7, 0x37, 0x6e, 0x0d, 0x77, 0x25, 0x5d, 0xe2, 0x3d, 0x54, 0x0f, 0x02, 0x71, 0x83, 0xf1,
                    0xba);
    private static final byte[] AEM89 = asBytes(0xa0, 0x1c, 0xe7, 0x12);
    private static final byte[] RPI90 =
            asBytes(
                    0x64, 0xa7, 0x1e, 0x48, 0xa5, 0x0e, 0x7b, 0x5a, 0x37, 0xac, 0x91, 0x81, 0x6e, 0x2b, 0x0f,
                    0x53);
    private static final byte[] AEM90 = asBytes(0xc9, 0xcb, 0x8c, 0x70);
    private static final byte[] RPI91 =
            asBytes(
                    0x0f, 0x22, 0xa2, 0xc0, 0xb6, 0x99, 0xe1, 0x89, 0xd5, 0x9e, 0x30, 0xd1, 0x74, 0x5d, 0x67,
                    0xd3);
    private static final byte[] AEM91 = asBytes(0xdb, 0xe6, 0x8f, 0x47);
    private static final byte[] RPI92 =
            asBytes(
                    0xde, 0x87, 0x6b, 0xaf, 0x31, 0x22, 0x8e, 0x3b, 0x7f, 0xe0, 0xf0, 0x8e, 0x1f, 0x38, 0xea,
                    0x7b);
    private static final byte[] AEM92 = asBytes(0x4c, 0xb1, 0xd9, 0x4f);
    private static final byte[] RPI93 =
            asBytes(
                    0x8c, 0x69, 0x27, 0xbc, 0xf5, 0xf7, 0xae, 0xe1, 0xee, 0xd8, 0xab, 0xbe, 0x43, 0xe2, 0xe2,
                    0xd1);
    private static final byte[] AEM93 = asBytes(0x27, 0x74, 0x06, 0x32);
    private static final byte[] RPI94 =
            asBytes(
                    0xbc, 0x96, 0x83, 0x0f, 0x18, 0x2a, 0x72, 0xc8, 0x9e, 0x65, 0xce, 0xa9, 0xc4, 0x7d, 0x88,
                    0xc0);
    private static final byte[] AEM94 = asBytes(0xe8, 0xad, 0xeb, 0x6d);
    private static final byte[] RPI95 =
            asBytes(
                    0x7b, 0x2f, 0xbe, 0x74, 0x6d, 0xd2, 0xda, 0x86, 0xe9, 0x86, 0x6a, 0x0e, 0x6a, 0xad, 0xbc,
                    0x4d);
    private static final byte[] AEM95 = asBytes(0xe5, 0x3a, 0x5a, 0xc7);
    private static final byte[] RPI96 =
            asBytes(
                    0x93, 0xe2, 0x0f, 0x14, 0xa1, 0x3d, 0x56, 0x56, 0x75, 0x94, 0xaa, 0x96, 0x23, 0x50, 0xf1,
                    0x70);
    private static final byte[] AEM96 = asBytes(0x94, 0x32, 0x42, 0xa4);
    private static final byte[] RPI97 =
            asBytes(
                    0x9e, 0x38, 0x14, 0xf9, 0x51, 0xfa, 0x03, 0x79, 0x6b, 0x9a, 0x66, 0xf8, 0x9a, 0x9f, 0x40,
                    0x0d);
    private static final byte[] AEM97 = asBytes(0x06, 0x48, 0xdc, 0x89);
    private static final byte[] RPI98 =
            asBytes(
                    0x95, 0xfa, 0x09, 0x84, 0x5a, 0xa8, 0xd4, 0xb6, 0x00, 0x47, 0xfa, 0xf9, 0x9a, 0xeb, 0xca,
                    0x0c);
    private static final byte[] AEM98 = asBytes(0x85, 0x5e, 0x31, 0xb3);
    private static final byte[] RPI99 =
            asBytes(
                    0xef, 0x0a, 0x75, 0x79, 0x33, 0x18, 0x53, 0xb9, 0xeb, 0xc2, 0x50, 0xb4, 0xd6, 0xf3, 0xeb,
                    0xcc);
    private static final byte[] AEM99 = asBytes(0x9c, 0x1f, 0x07, 0xc2);
    private static final byte[] RPI100 =
            asBytes(
                    0x7f, 0xe9, 0xa9, 0x0d, 0xe0, 0x0c, 0x9f, 0x07, 0x37, 0xd3, 0xb4, 0x5f, 0xda, 0x65, 0x11,
                    0x15);
    private static final byte[] AEM100 = asBytes(0x98, 0x4e, 0x1f, 0xf3);
    private static final byte[] RPI101 =
            asBytes(
                    0x44, 0x3b, 0x7b, 0x5a, 0xb9, 0xa8, 0x6a, 0x1f, 0xee, 0x67, 0xe1, 0x8c, 0xb8, 0xc4, 0x07,
                    0x64);
    private static final byte[] AEM101 = asBytes(0xb3, 0xfb, 0xa7, 0xe1);
    private static final byte[] RPI102 =
            asBytes(
                    0xe8, 0xa6, 0xfa, 0x9a, 0x5c, 0xa9, 0xfb, 0x06, 0x1c, 0x4c, 0xdb, 0xe2, 0x17, 0xc6, 0x1d,
                    0x59);
    private static final byte[] AEM102 = asBytes(0x3b, 0x6d, 0x9d, 0xe8);
    private static final byte[] RPI103 =
            asBytes(
                    0x08, 0x7a, 0x08, 0x04, 0x06, 0x86, 0xfd, 0x63, 0x5e, 0xf3, 0x89, 0x75, 0x27, 0x41, 0xcc,
                    0x1f);
    private static final byte[] AEM103 = asBytes(0xf0, 0x85, 0x55, 0x1c);
    private static final byte[] RPI104 =
            asBytes(
                    0x58, 0x7c, 0x04, 0x86, 0x64, 0x4c, 0xeb, 0x2d, 0x0b, 0x7e, 0xbd, 0xd3, 0x9d, 0xd3, 0xa8,
                    0x60);
    private static final byte[] AEM104 = asBytes(0x0a, 0x6b, 0x32, 0x6e);
    private static final byte[] RPI105 =
            asBytes(
                    0xdd, 0x82, 0x7b, 0xa6, 0x0f, 0x8a, 0x35, 0xb1, 0xdd, 0x4e, 0x4c, 0xdf, 0xe4, 0x9c, 0x42,
                    0x63);
    private static final byte[] AEM105 = asBytes(0x81, 0xeb, 0x20, 0xe2);
    private static final byte[] RPI106 =
            asBytes(
                    0xcf, 0x23, 0x40, 0x00, 0x08, 0x0a, 0x4e, 0x8d, 0xa8, 0xfe, 0xb5, 0x33, 0xaa, 0x59, 0x04,
                    0xd3);
    private static final byte[] AEM106 = asBytes(0x34, 0xd8, 0x6e, 0xe5);
    private static final byte[] RPI107 =
            asBytes(
                    0xc5, 0x0f, 0xb1, 0xec, 0x3e, 0xf5, 0x4e, 0x91, 0x61, 0x78, 0xca, 0x9d, 0x56, 0xee, 0x4f,
                    0x5c);
    private static final byte[] AEM107 = asBytes(0xea, 0xea, 0xc3, 0xd2);
    private static final byte[] RPI108 =
            asBytes(
                    0xd4, 0x5f, 0xde, 0x46, 0xf4, 0x67, 0xd7, 0x6e, 0xd2, 0x8d, 0xd4, 0xd2, 0x49, 0x6d, 0xcb,
                    0x7f);
    private static final byte[] AEM108 = asBytes(0xea, 0xa6, 0x4a, 0x8e);
    private static final byte[] RPI109 =
            asBytes(
                    0xe9, 0xba, 0xf8, 0x1c, 0x96, 0x1f, 0x51, 0x0d, 0x08, 0xa6, 0x63, 0xc7, 0x52, 0x4f, 0x36,
                    0xdf);
    private static final byte[] AEM109 = asBytes(0x1e, 0x2c, 0xa3, 0x7b);
    private static final byte[] RPI110 =
            asBytes(
                    0xe3, 0xb0, 0x2c, 0xc0, 0x31, 0xe1, 0x44, 0xfa, 0xe6, 0x1a, 0x38, 0x99, 0x50, 0x1b, 0x49,
                    0x21);
    private static final byte[] AEM110 = asBytes(0x44, 0xc0, 0xd7, 0x06);
    private static final byte[] RPI111 =
            asBytes(
                    0xa7, 0x5e, 0xea, 0x58, 0x23, 0x2e, 0x73, 0x66, 0xce, 0xa1, 0xa0, 0xe7, 0x2d, 0xa0, 0xce,
                    0xc5);
    private static final byte[] AEM111 = asBytes(0x5a, 0x8c, 0x79, 0xb7);
    private static final byte[] RPI112 =
            asBytes(
                    0x6a, 0xd7, 0x62, 0x1f, 0xe1, 0xda, 0x01, 0x39, 0xff, 0x8b, 0xad, 0x7f, 0x37, 0x9c, 0xab,
                    0xf6);
    private static final byte[] AEM112 = asBytes(0x27, 0x9f, 0x16, 0xb1);
    private static final byte[] RPI113 =
            asBytes(
                    0x6f, 0xe2, 0xac, 0x45, 0xf6, 0x5c, 0x8a, 0xc6, 0x9f, 0xdc, 0x5e, 0xf7, 0xfa, 0x9f, 0xf7,
                    0xf0);
    private static final byte[] AEM113 = asBytes(0x4b, 0xd9, 0x07, 0xaa);
    private static final byte[] RPI114 =
            asBytes(
                    0x2f, 0xbe, 0xc6, 0x8f, 0xd2, 0x7d, 0xdd, 0xdb, 0x42, 0x23, 0x04, 0x4e, 0xfc, 0x77, 0x98,
                    0x51);
    private static final byte[] AEM114 = asBytes(0x2d, 0xf6, 0xc5, 0xeb);
    private static final byte[] RPI115 =
            asBytes(
                    0x32, 0xbf, 0x68, 0x8a, 0x7c, 0x83, 0x4b, 0xe1, 0xbf, 0xab, 0x7c, 0x8e, 0x0e, 0x58, 0x0a,
                    0xdb);
    private static final byte[] AEM115 = asBytes(0x66, 0x85, 0x2d, 0x43);
    private static final byte[] RPI116 =
            asBytes(
                    0xda, 0xe3, 0xa7, 0xd8, 0xc6, 0x24, 0x27, 0xb0, 0x9c, 0x0e, 0x7b, 0xbf, 0x48, 0x9d, 0x34,
                    0xbd);
    private static final byte[] AEM116 = asBytes(0x83, 0x6d, 0x3b, 0x95);
    private static final byte[] RPI117 =
            asBytes(
                    0x3c, 0x4b, 0x02, 0xbd, 0x5e, 0xd2, 0x8c, 0x67, 0x82, 0x9c, 0x97, 0x79, 0x10, 0x79, 0xaf,
                    0xd2);
    private static final byte[] AEM117 = asBytes(0x27, 0x35, 0xb9, 0x97);
    private static final byte[] RPI118 =
            asBytes(
                    0xe2, 0xfa, 0xea, 0xc3, 0xdb, 0xd1, 0x50, 0xec, 0x8e, 0xa8, 0xe7, 0xb3, 0xe5, 0xbb, 0x84,
                    0x54);
    private static final byte[] AEM118 = asBytes(0xd7, 0x1f, 0x97, 0xc2);
    private static final byte[] RPI119 =
            asBytes(
                    0x69, 0x94, 0x2a, 0x72, 0x13, 0xea, 0xf3, 0xc1, 0x4a, 0x69, 0x99, 0x6b, 0xa6, 0xc6, 0xbf,
                    0xeb);
    private static final byte[] AEM119 = asBytes(0x53, 0xbc, 0x4d, 0xb5);
    private static final byte[] RPI120 =
            asBytes(
                    0x1c, 0x5c, 0x4d, 0xd2, 0x54, 0x52, 0xe9, 0x7d, 0xd1, 0x87, 0xdd, 0x7c, 0xe1, 0xd1, 0xee,
                    0x81);
    private static final byte[] AEM120 = asBytes(0x48, 0xa4, 0xd3, 0x79);
    private static final byte[] RPI121 =
            asBytes(
                    0xfb, 0xf5, 0x60, 0x7a, 0x7c, 0x61, 0x2a, 0xce, 0xd1, 0x60, 0xe7, 0x55, 0xa9, 0x87, 0x26,
                    0x2d);
    private static final byte[] AEM121 = asBytes(0xb7, 0x8d, 0xc1, 0xf5);
    private static final byte[] RPI122 =
            asBytes(
                    0x3e, 0x2d, 0xe1, 0x30, 0x70, 0xf2, 0x74, 0x43, 0xd9, 0xba, 0x3e, 0xb4, 0x3f, 0x9a, 0x71,
                    0xea);
    private static final byte[] AEM122 = asBytes(0x58, 0x21, 0x70, 0xca);
    private static final byte[] RPI123 =
            asBytes(
                    0x8a, 0x12, 0xd2, 0x5f, 0x00, 0x6f, 0xab, 0x5a, 0x27, 0x07, 0xda, 0x9e, 0x6c, 0x4e, 0x96,
                    0xbe);
    private static final byte[] AEM123 = asBytes(0x93, 0x95, 0x94, 0xcc);
    private static final byte[] RPI124 =
            asBytes(
                    0x6f, 0xd9, 0x8c, 0x22, 0xe2, 0x27, 0x83, 0x8e, 0x6f, 0x67, 0x36, 0x97, 0x64, 0x43, 0x77,
                    0x25);
    private static final byte[] AEM124 = asBytes(0xc1, 0x4f, 0x5b, 0x11);
    private static final byte[] RPI125 =
            asBytes(
                    0x3d, 0xa2, 0x12, 0xae, 0xbd, 0xb7, 0x8b, 0xa8, 0x19, 0x80, 0x9d, 0x03, 0xc6, 0xcf, 0x56,
                    0xe2);
    private static final byte[] AEM125 = asBytes(0x30, 0x09, 0x12, 0xda);
    private static final byte[] RPI126 =
            asBytes(
                    0x8c, 0x48, 0xda, 0x73, 0xe2, 0x9e, 0xff, 0xc9, 0xb7, 0x4b, 0xb0, 0x97, 0x09, 0x6e, 0x0a,
                    0x0a);
    private static final byte[] AEM126 = asBytes(0xce, 0x79, 0xc5, 0x0a);
    private static final byte[] RPI127 =
            asBytes(
                    0xe5, 0x3c, 0x68, 0xb4, 0xb0, 0x1c, 0x68, 0xf3, 0x7e, 0x65, 0xa0, 0xdc, 0x8e, 0x67, 0xf4,
                    0x5d);
    private static final byte[] AEM127 = asBytes(0xe0, 0x4f, 0x38, 0x67);
    private static final byte[] RPI128 =
            asBytes(
                    0x83, 0x31, 0xdd, 0xe6, 0x36, 0x4b, 0x11, 0x95, 0x27, 0xaf, 0x76, 0xfe, 0xe1, 0x7a, 0xab,
                    0xcf);
    private static final byte[] AEM128 = asBytes(0x64, 0x18, 0x7b, 0xdf);
    private static final byte[] RPI129 =
            asBytes(
                    0x8c, 0x14, 0x47, 0x1f, 0x55, 0x71, 0x92, 0x63, 0x96, 0xdd, 0xe6, 0xf7, 0xb7, 0xb3, 0x5b,
                    0x56);
    private static final byte[] AEM129 = asBytes(0xe8, 0x7c, 0x05, 0xfd);
    private static final byte[] RPI130 =
            asBytes(
                    0x4e, 0xb6, 0xb2, 0xde, 0xb4, 0x0e, 0x5e, 0xc9, 0xbc, 0x39, 0x83, 0x81, 0x02, 0xa4, 0xf4,
                    0xf9);
    private static final byte[] AEM130 = asBytes(0x4e, 0x70, 0x83, 0x25);
    private static final byte[] RPI131 =
            asBytes(
                    0x77, 0xf2, 0x14, 0x1c, 0xef, 0xfd, 0x0a, 0xa3, 0xbe, 0xe4, 0xb6, 0x7c, 0x45, 0x0d, 0x9a,
                    0xa6);
    private static final byte[] AEM131 = asBytes(0xa1, 0x57, 0xeb, 0x59);
    private static final byte[] RPI132 =
            asBytes(
                    0x04, 0x3d, 0x78, 0xe2, 0x0c, 0xb5, 0x9c, 0x0b, 0xcb, 0x15, 0x78, 0xff, 0x93, 0xea, 0x54,
                    0x4a);
    private static final byte[] AEM132 = asBytes(0x8d, 0x30, 0x43, 0x2a);
    private static final byte[] RPI133 =
            asBytes(
                    0x65, 0xb8, 0xec, 0xc4, 0x56, 0x1c, 0x1c, 0xca, 0x05, 0x3d, 0x81, 0x4f, 0xfd, 0x89, 0x61,
                    0xd4);
    private static final byte[] AEM133 = asBytes(0x5b, 0x24, 0x38, 0x90);
    private static final byte[] RPI134 =
            asBytes(
                    0x32, 0xf2, 0x5a, 0x17, 0x24, 0xf2, 0xbd, 0xca, 0xd0, 0x5a, 0xbc, 0x14, 0x82, 0xe1, 0x32,
                    0x9e);
    private static final byte[] AEM134 = asBytes(0x74, 0x90, 0xd2, 0x11);
    private static final byte[] RPI135 =
            asBytes(
                    0x20, 0x3b, 0xa3, 0xf3, 0xf7, 0x23, 0x02, 0x66, 0xb9, 0x93, 0xb3, 0xee, 0x7b, 0x2d, 0x86,
                    0x08);
    private static final byte[] AEM135 = asBytes(0x1f, 0x01, 0x9d, 0xf2);
    private static final byte[] RPI136 =
            asBytes(
                    0xe5, 0xe7, 0xa4, 0x70, 0x69, 0x21, 0x6e, 0x1a, 0x88, 0x7b, 0x90, 0xef, 0x03, 0x94, 0xa3,
                    0x5c);
    private static final byte[] AEM136 = asBytes(0x99, 0xe6, 0x12, 0xb7);
    private static final byte[] RPI137 =
            asBytes(
                    0x3f, 0xfc, 0x8b, 0xb9, 0x1d, 0xbc, 0xd8, 0xee, 0x92, 0x49, 0x48, 0xf5, 0x08, 0x0b, 0x19,
                    0x0d);
    private static final byte[] AEM137 = asBytes(0x26, 0x4a, 0x57, 0x7e);
    private static final byte[] RPI138 =
            asBytes(
                    0x32, 0x37, 0x53, 0x91, 0x07, 0x7f, 0xbf, 0x76, 0x86, 0xba, 0xfa, 0x7d, 0xc1, 0x56, 0xbe,
                    0x1c);
    private static final byte[] AEM138 = asBytes(0xa8, 0x11, 0xba, 0x62);
    private static final byte[] RPI139 =
            asBytes(
                    0xa8, 0x90, 0x49, 0x65, 0xae, 0xc5, 0xdd, 0xb6, 0x55, 0xe9, 0x70, 0x07, 0xd2, 0x23, 0xdb,
                    0x48);
    private static final byte[] AEM139 = asBytes(0x2b, 0x48, 0x33, 0x21);
    private static final byte[] RPI140 =
            asBytes(
                    0x41, 0x5c, 0xf7, 0xaf, 0x1d, 0xc9, 0xfe, 0xac, 0xb3, 0x97, 0x84, 0x88, 0xf5, 0x04, 0x68,
                    0x93);
    private static final byte[] AEM140 = asBytes(0xe2, 0xef, 0x53, 0x7e);
    private static final byte[] RPI141 =
            asBytes(
                    0x86, 0xf8, 0xdd, 0xc0, 0xc9, 0x3e, 0x53, 0xe3, 0xa5, 0x82, 0xe6, 0x1f, 0x01, 0xf7, 0xdf,
                    0x2f);
    private static final byte[] AEM141 = asBytes(0x71, 0x1d, 0xbf, 0x6d);
    private static final byte[] RPI142 =
            asBytes(
                    0xa6, 0x5e, 0xf7, 0xba, 0x97, 0x52, 0xc4, 0x17, 0x3b, 0xa4, 0x8a, 0x33, 0x84, 0x9c, 0x5e,
                    0x52);
    private static final byte[] AEM142 = asBytes(0x59, 0x2d, 0xbc, 0xa8);
    private static final byte[] RPI143 =
            asBytes(
                    0xf4, 0x31, 0xb6, 0x2e, 0xcf, 0x44, 0x31, 0x02, 0xce, 0x4e, 0xd0, 0x40, 0x7d, 0xe5, 0x4b,
                    0xd4);
    private static final byte[] AEM143 = asBytes(0x12, 0x15, 0xe5, 0x7e);
    // ------------------------------------------------------------------------------

    public static final List<AdvertisedData> ADVERTISED_DATA =
            Collections.unmodifiableList(Arrays.asList(
                    new AdvertisedData(RPI0, AEM0),
                    new AdvertisedData(RPI1, AEM1),
                    new AdvertisedData(RPI2, AEM2),
                    new AdvertisedData(RPI3, AEM3),
                    new AdvertisedData(RPI4, AEM4),
                    new AdvertisedData(RPI5, AEM5),
                    new AdvertisedData(RPI6, AEM6),
                    new AdvertisedData(RPI7, AEM7),
                    new AdvertisedData(RPI8, AEM8),
                    new AdvertisedData(RPI9, AEM9),
                    new AdvertisedData(RPI10, AEM10),
                    new AdvertisedData(RPI11, AEM11),
                    new AdvertisedData(RPI12, AEM12),
                    new AdvertisedData(RPI13, AEM13),
                    new AdvertisedData(RPI14, AEM14),
                    new AdvertisedData(RPI15, AEM15),
                    new AdvertisedData(RPI16, AEM16),
                    new AdvertisedData(RPI17, AEM17),
                    new AdvertisedData(RPI18, AEM18),
                    new AdvertisedData(RPI19, AEM19),
                    new AdvertisedData(RPI20, AEM20),
                    new AdvertisedData(RPI21, AEM21),
                    new AdvertisedData(RPI22, AEM22),
                    new AdvertisedData(RPI23, AEM23),
                    new AdvertisedData(RPI24, AEM24),
                    new AdvertisedData(RPI25, AEM25),
                    new AdvertisedData(RPI26, AEM26),
                    new AdvertisedData(RPI27, AEM27),
                    new AdvertisedData(RPI28, AEM28),
                    new AdvertisedData(RPI29, AEM29),
                    new AdvertisedData(RPI30, AEM30),
                    new AdvertisedData(RPI31, AEM31),
                    new AdvertisedData(RPI32, AEM32),
                    new AdvertisedData(RPI33, AEM33),
                    new AdvertisedData(RPI34, AEM34),
                    new AdvertisedData(RPI35, AEM35),
                    new AdvertisedData(RPI36, AEM36),
                    new AdvertisedData(RPI37, AEM37),
                    new AdvertisedData(RPI38, AEM38),
                    new AdvertisedData(RPI39, AEM39),
                    new AdvertisedData(RPI40, AEM40),
                    new AdvertisedData(RPI41, AEM41),
                    new AdvertisedData(RPI42, AEM42),
                    new AdvertisedData(RPI43, AEM43),
                    new AdvertisedData(RPI44, AEM44),
                    new AdvertisedData(RPI45, AEM45),
                    new AdvertisedData(RPI46, AEM46),
                    new AdvertisedData(RPI47, AEM47),
                    new AdvertisedData(RPI48, AEM48),
                    new AdvertisedData(RPI49, AEM49),
                    new AdvertisedData(RPI50, AEM50),
                    new AdvertisedData(RPI51, AEM51),
                    new AdvertisedData(RPI52, AEM52),
                    new AdvertisedData(RPI53, AEM53),
                    new AdvertisedData(RPI54, AEM54),
                    new AdvertisedData(RPI55, AEM55),
                    new AdvertisedData(RPI56, AEM56),
                    new AdvertisedData(RPI57, AEM57),
                    new AdvertisedData(RPI58, AEM58),
                    new AdvertisedData(RPI59, AEM59),
                    new AdvertisedData(RPI60, AEM60),
                    new AdvertisedData(RPI61, AEM61),
                    new AdvertisedData(RPI62, AEM62),
                    new AdvertisedData(RPI63, AEM63),
                    new AdvertisedData(RPI64, AEM64),
                    new AdvertisedData(RPI65, AEM65),
                    new AdvertisedData(RPI66, AEM66),
                    new AdvertisedData(RPI67, AEM67),
                    new AdvertisedData(RPI68, AEM68),
                    new AdvertisedData(RPI69, AEM69),
                    new AdvertisedData(RPI70, AEM70),
                    new AdvertisedData(RPI71, AEM71),
                    new AdvertisedData(RPI72, AEM72),
                    new AdvertisedData(RPI73, AEM73),
                    new AdvertisedData(RPI74, AEM74),
                    new AdvertisedData(RPI75, AEM75),
                    new AdvertisedData(RPI76, AEM76),
                    new AdvertisedData(RPI77, AEM77),
                    new AdvertisedData(RPI78, AEM78),
                    new AdvertisedData(RPI79, AEM79),
                    new AdvertisedData(RPI80, AEM80),
                    new AdvertisedData(RPI81, AEM81),
                    new AdvertisedData(RPI82, AEM82),
                    new AdvertisedData(RPI83, AEM83),
                    new AdvertisedData(RPI84, AEM84),
                    new AdvertisedData(RPI85, AEM85),
                    new AdvertisedData(RPI86, AEM86),
                    new AdvertisedData(RPI87, AEM87),
                    new AdvertisedData(RPI88, AEM88),
                    new AdvertisedData(RPI89, AEM89),
                    new AdvertisedData(RPI90, AEM90),
                    new AdvertisedData(RPI91, AEM91),
                    new AdvertisedData(RPI92, AEM92),
                    new AdvertisedData(RPI93, AEM93),
                    new AdvertisedData(RPI94, AEM94),
                    new AdvertisedData(RPI95, AEM95),
                    new AdvertisedData(RPI96, AEM96),
                    new AdvertisedData(RPI97, AEM97),
                    new AdvertisedData(RPI98, AEM98),
                    new AdvertisedData(RPI99, AEM99),
                    new AdvertisedData(RPI100, AEM100),
                    new AdvertisedData(RPI101, AEM101),
                    new AdvertisedData(RPI102, AEM102),
                    new AdvertisedData(RPI103, AEM103),
                    new AdvertisedData(RPI104, AEM104),
                    new AdvertisedData(RPI105, AEM105),
                    new AdvertisedData(RPI106, AEM106),
                    new AdvertisedData(RPI107, AEM107),
                    new AdvertisedData(RPI108, AEM108),
                    new AdvertisedData(RPI109, AEM109),
                    new AdvertisedData(RPI110, AEM110),
                    new AdvertisedData(RPI111, AEM111),
                    new AdvertisedData(RPI112, AEM112),
                    new AdvertisedData(RPI113, AEM113),
                    new AdvertisedData(RPI114, AEM114),
                    new AdvertisedData(RPI115, AEM115),
                    new AdvertisedData(RPI116, AEM116),
                    new AdvertisedData(RPI117, AEM117),
                    new AdvertisedData(RPI118, AEM118),
                    new AdvertisedData(RPI119, AEM119),
                    new AdvertisedData(RPI120, AEM120),
                    new AdvertisedData(RPI121, AEM121),
                    new AdvertisedData(RPI122, AEM122),
                    new AdvertisedData(RPI123, AEM123),
                    new AdvertisedData(RPI124, AEM124),
                    new AdvertisedData(RPI125, AEM125),
                    new AdvertisedData(RPI126, AEM126),
                    new AdvertisedData(RPI127, AEM127),
                    new AdvertisedData(RPI128, AEM128),
                    new AdvertisedData(RPI129, AEM129),
                    new AdvertisedData(RPI130, AEM130),
                    new AdvertisedData(RPI131, AEM131),
                    new AdvertisedData(RPI132, AEM132),
                    new AdvertisedData(RPI133, AEM133),
                    new AdvertisedData(RPI134, AEM134),
                    new AdvertisedData(RPI135, AEM135),
                    new AdvertisedData(RPI136, AEM136),
                    new AdvertisedData(RPI137, AEM137),
                    new AdvertisedData(RPI138, AEM138),
                    new AdvertisedData(RPI139, AEM139),
                    new AdvertisedData(RPI140, AEM140),
                    new AdvertisedData(RPI141, AEM141),
                    new AdvertisedData(RPI142, AEM142),
                    new AdvertisedData(RPI143, AEM143)));

    private TestVectors() {
    }
}

