



'''simple docstring'''





import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    WavaVecaConformerConfig,
    WavaVecaConformerForCTC,
    WavaVecaConformerForPreTraining,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
    logging,
)


logging.set_verbosity_info()
SCREAMING_SNAKE_CASE__          =  logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__          =  {
    "post_extract_proj": "feature_projection.projection",
    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
    "self_attn.linear_k": "encoder.layers.*.self_attn.linear_k",
    "self_attn.linear_v": "encoder.layers.*.self_attn.linear_v",
    "self_attn.linear_q": "encoder.layers.*.self_attn.linear_q",
    "self_attn.pos_bias_u": "encoder.layers.*.self_attn.pos_bias_u",
    "self_attn.pos_bias_v": "encoder.layers.*.self_attn.pos_bias_v",
    "self_attn.linear_out": "encoder.layers.*.self_attn.linear_out",
    "self_attn.linear_pos": "encoder.layers.*.self_attn.linear_pos",
    "self_attn.rotary_emb": "encoder.embed_positions",
    "self_attn_layer_norm": "encoder.layers.*.self_attn_layer_norm",
    "conv_module.pointwise_conv1": "encoder.layers.*.conv_module.pointwise_conv1",
    "conv_module.pointwise_conv2": "encoder.layers.*.conv_module.pointwise_conv2",
    "conv_module.depthwise_conv": "encoder.layers.*.conv_module.depthwise_conv",
    "conv_module.batch_norm": "encoder.layers.*.conv_module.batch_norm",
    "conv_module.layer_norm": "encoder.layers.*.conv_module.layer_norm",
    "ffn1.w_1": "encoder.layers.*.ffn1.intermediate_dense",
    "ffn1.w_2": "encoder.layers.*.ffn1.output_dense",
    "ffn1.layer_norm": "encoder.layers.*.ffn1_layer_norm",
    "ffn2.w_1": "encoder.layers.*.ffn2.intermediate_dense",
    "ffn2.w_2": "encoder.layers.*.ffn2.output_dense",
    "ffn2.layer_norm": "encoder.layers.*.ffn2_layer_norm",
    "final_layer_norm": "encoder.layers.*.final_layer_norm",
    "encoder.layer_norm": "encoder.layer_norm",
    "w2v_model.layer_norm": "feature_projection.layer_norm",
    "quantizer.weight_proj": "quantizer.weight_proj",
    "quantizer.vars": "quantizer.codevectors",
    "project_q": "project_q",
    "final_proj": "project_hid",
    "w2v_encoder.proj": "lm_head",
    "mask_emb": "masked_spec_embed",
}
SCREAMING_SNAKE_CASE__          =  [
    "lm_head",
    "quantizer.weight_proj",
    "quantizer.codevectors",
    "project_q",
    "project_hid",
]




def 							lowerCamelCase	(					_snake_case	:    Any  ,_snake_case	:    Any  ,_snake_case	:    Dict  ,_snake_case	:    Optional[int]  ,_snake_case	:    Union[str, Any]							):





    '''simple docstring'''


    for attribute in key.split("."							):
        lowercase__									=    getattr(_snake_case  ,_snake_case							)

    if weight_type is not None:
        lowercase__									=    getattr(_snake_case  ,_snake_case							).shape
    else:
        lowercase__									=    hf_pointer.shape

    if hf_shape != value.shape:
        raise ValueError(
            f'''Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be'''
            f''' {value.shape} for {full_name}'''							)

    if weight_type == "weight":
        lowercase__									=    value
    elif weight_type == "weight_g":
        lowercase__									=    value
    elif weight_type == "weight_v":
        lowercase__									=    value
    elif weight_type == "bias":
        lowercase__									=    value
    elif weight_type == "running_mean":
        lowercase__									=    value
    elif weight_type == "running_var":
        lowercase__									=    value
    elif weight_type == "num_batches_tracked":
        lowercase__									=    value
    elif weight_type == "inv_freq":
        lowercase__									=    value
    else:
        lowercase__									=    value

    logger.info(f'''{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.'''							)




def 							lowerCamelCase	(					_snake_case	:    List[str]  ,_snake_case	:    int  ,_snake_case	:    Union[str, Any]							):





    '''simple docstring'''


    lowercase__									=    []
    lowercase__									=    fairseq_model.state_dict()

    lowercase__									=    hf_model.wavaveca_conformer.feature_extractor

    for name, value in fairseq_dict.items():
        lowercase__									=    False
        if "conv_layers" in name:
            load_conv_layer(
                _snake_case  ,_snake_case  ,_snake_case  ,_snake_case  ,hf_model.config.feat_extract_norm == "group"  ,)
            lowercase__									=    True
        else:
            for key, mapped_key in MAPPING.items():
                lowercase__									=    "wav2vec2_conformer." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
                if key in name or key.split("w2v_model."							)[-1] == name.split("."							)[0]:
                    lowercase__									=    True
                    if "*" in mapped_key:
                        lowercase__									=    name.split(_snake_case							)[0].split("."							)[-2]
                        lowercase__									=    mapped_key.replace("*"  ,_snake_case							)
                    if "pos_bias_u" in name:
                        lowercase__									=    None
                    elif "pos_bias_v" in name:
                        lowercase__									=    None
                    elif "weight_g" in name:
                        lowercase__									=    "weight_g"
                    elif "weight_v" in name:
                        lowercase__									=    "weight_v"
                    elif "bias" in name:
                        lowercase__									=    "bias"
                    elif "weight" in name:
                        # TODO: don't match quantizer.weight_proj
                        lowercase__									=    "weight"
                    elif "running_mean" in name:
                        lowercase__									=    "running_mean"
                    elif "inv_freq" in name:
                        lowercase__									=    "inv_freq"
                    elif "running_var" in name:
                        lowercase__									=    "running_var"
                    elif "num_batches_tracked" in name:
                        lowercase__									=    "num_batches_tracked"
                    else:
                        lowercase__									=    None
                    set_recursively(_snake_case  ,_snake_case  ,_snake_case  ,_snake_case  ,_snake_case							)
                continue
        if not is_used:
            unused_weights.append(_snake_case							)

    logger.warning(f'''Unused weights: {unused_weights}'''							)




def 							lowerCamelCase	(					_snake_case	:    Optional[Any]  ,_snake_case	:    List[Any]  ,_snake_case	:    str  ,_snake_case	:    Optional[int]  ,_snake_case	:    List[str]							):





    '''simple docstring'''


    lowercase__									=    full_name.split("conv_layers."							)[-1]
    lowercase__									=    name.split("."							)
    lowercase__									=    int(items[0]							)
    lowercase__									=    int(items[1]							)

    if type_id == 0:
        if "bias" in name:
            if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
                raise ValueError(
                    f'''{full_name} has size {value.shape}, but'''
                    f''' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'''							)
            lowercase__									=    value
            logger.info(f'''Feat extract conv layer {layer_id} was initialized from {full_name}.'''							)
        elif "weight" in name:
            if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
                raise ValueError(
                    f'''{full_name} has size {value.shape}, but'''
                    f''' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'''							)
            lowercase__									=    value
            logger.info(f'''Feat extract conv layer {layer_id} was initialized from {full_name}.'''							)
    elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
        if "bias" in name:
            if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
                raise ValueError(
                    f'''{full_name} has size {value.shape}, but'''
                    f''' {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found.'''							)
            lowercase__									=    value
            logger.info(f'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'''							)
        elif "weight" in name:
            if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
                raise ValueError(
                    f'''{full_name} has size {value.shape}, but'''
                    f''' {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found.'''							)
            lowercase__									=    value
            logger.info(f'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'''							)
    else:
        unused_weights.append(_snake_case							)




@torch.no_grad()
def 							lowerCamelCase	(					_snake_case	:    List[Any]  ,_snake_case	:    List[Any]  ,_snake_case	:    str=None  ,_snake_case	:    Optional[int]=None  ,_snake_case	:    str=True							):





    '''simple docstring'''


    if config_path is not None:
        lowercase__									=    WavaVecaConformerConfig.from_pretrained(_snake_case  ,hidden_act="swish"							)
    else:
        lowercase__									=    WavaVecaConformerConfig()

    if "rope" in checkpoint_path:
        lowercase__									=    "rotary"

    if is_finetuned:
        if dict_path:
            lowercase__									=    Dictionary.load(_snake_case							)

            # important change bos & pad token id since CTC symbol is <pad> and
            # not <s> as in fairseq
            lowercase__									=    target_dict.pad_index
            lowercase__									=    target_dict.bos_index
            lowercase__									=    target_dict.eos_index
            lowercase__									=    len(target_dict.symbols							)
            lowercase__									=    os.path.join(_snake_case  ,"vocab.json"							)
            if not os.path.isdir(_snake_case							):
                logger.error("--pytorch_dump_folder_path ({}) should be a directory".format(_snake_case							)							)
                return
            os.makedirs(_snake_case  ,exist_ok=_snake_case							)
            lowercase__									=    target_dict.indices

            # fairseq has the <pad> and <s> switched
            lowercase__									=    0
            lowercase__									=    1
            with open(_snake_case  ,"w"  ,encoding="utf-8"							) as vocab_handle:
                json.dump(_snake_case  ,_snake_case							)
            lowercase__									=    WavaVecaCTCTokenizer(
                _snake_case  ,unk_token=target_dict.unk_word  ,pad_token=target_dict.pad_word  ,bos_token=target_dict.bos_word  ,eos_token=target_dict.eos_word  ,word_delimiter_token="|"  ,do_lower_case=_snake_case  ,)
            lowercase__									=    True if config.feat_extract_norm == "layer" else False
            lowercase__									=    WavaVecaFeatureExtractor(
                feature_size=1  ,sampling_rate=16_000  ,padding_value=0  ,do_normalize=_snake_case  ,return_attention_mask=_snake_case  ,)
            lowercase__									=    WavaVecaProcessor(feature_extractor=_snake_case  ,tokenizer=_snake_case							)
            processor.save_pretrained(_snake_case							)

        lowercase__									=    WavaVecaConformerForCTC(_snake_case							)
    else:
        lowercase__									=    WavaVecaConformerForPreTraining(_snake_case							)

    if is_finetuned:
        lowercase__							,							lowercase__							,							lowercase__									=    fairseq.checkpoint_utils.load_model_ensemble_and_task(
            [checkpoint_path]  ,arg_overrides={"data": "/".join(dict_path.split("/"							)[:-1]							)}							)
    else:
        lowercase__									=    argparse.Namespace(task="audio_pretraining"							)
        lowercase__									=    fairseq.tasks.setup_task(_snake_case							)

        lowercase__							,							lowercase__							,							lowercase__									=    fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]  ,task=_snake_case							)

    lowercase__									=    model[0].eval()

    recursively_load_weights(_snake_case  ,_snake_case  ,not is_finetuned							)

    hf_wavavec.save_pretrained(_snake_case							)


if __name__ == "__main__":
 SCREAMING_SNAKE_CASE__          =  argparse.ArgumentParser()
 parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
 parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
 parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
 parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
 parser.add_argument(
     "--not_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not"
 )
 SCREAMING_SNAKE_CASE__          =  parser.parse_args()
 convert_wavaveca_conformer_checkpoint(
     args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
 )









'''simple docstring'''





import unittest

from transformers import JukeboxTokenizer
from transformers.testing_utils import require_torch


class 					snake_case			(unittest.TestCase ):
       lowerCAmelCase__	:Dict     =       JukeboxTokenizer
       lowerCAmelCase__	:List[str]     =       {
           "artist": "Zac Brown Band",
           "genres": "Country",
           "lyrics": "I met a traveller from an antique land,\n        Who said \"Two vast and trunkless legs of stone\n        Stand in the desert. . . . Near them, on the sand,\n        Half sunk a shattered visage lies, whose frown,\n        And wrinkled lip, and sneer of cold command,\n        Tell that its sculptor well those passions read\n        Which yet survive, stamped on these lifeless things,\n        The hand that mocked them, and the heart that fed;\n        And on the pedestal, these words appear:\n        My name is Ozymandias, King of Kings;\n        Look on my Works, ye Mighty, and despair!\n        Nothing beside remains. Round the decay\n        Of that colossal Wreck, boundless and bare\n        The lone and level sands stretch far away\n        ",
       }



       @require_torch
       def 				_a   (					self   )	->				Dict:
           import torch

           lowercase__									=    JukeboxTokenizer.from_pretrained("openai/jukebox-1b-lyrics"   )
           lowercase__									=    tokenizer(**self.metas   )["input_ids"]
           # fmt: off
           lowercase__									=    [
               torch.tensor([[
                   0, 0, 0, 7_169, 507, 9, 76, 39, 31, 46, 76, 27,
                   76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32,
                   44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43,
                   47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76,
                   76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35,
                   30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76,
                   27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45,
                   45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46,
                   41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76,
                   19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31,
                   76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63,
                   76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39,
                   64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40,
                   30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8,
                   27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45,
                   34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45,
                   27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34,
                   41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76,
                   76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49,
                   44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64,
                   76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41,
                   32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27,
                   40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76,
                   20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46,
                   45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49,
                   31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27,
                   45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78,
                   76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29,
                   34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48,
                   31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41,
                   40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31,
                   38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64,
                   78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31,
                   76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39,
                   41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76,
                   27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44,
                   46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78,
                   76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76,
                   41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45,
                   46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49,
                   41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65,
                   78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76,
                   40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39,
                   27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33,
                   76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76,
                   76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76,
                   41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64,
                   76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76,
                   27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67,
                   78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46,
                   34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76,
                   44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47,
                   40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51,
                   78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76,
                   46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27,
                   38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47,
                   40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28,
                   27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76,
                   20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30,
                   76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45,
                   76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44,
                   76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76,
                   76, 76]]   ),
               torch.tensor([[0, 0, 0, 1_069, 11]]   ),
               torch.tensor([[0, 0, 0, 1_069, 11]]   ),
           ]
           # fmt: on
           self.assertTrue(torch.allclose(tokens[0]  ,EXPECTED_OUTPUT[0]   )   )
           self.assertTrue(torch.allclose(tokens[1]  ,EXPECTED_OUTPUT[1]   )   )
           self.assertTrue(torch.allclose(tokens[2]  ,EXPECTED_OUTPUT[2]   )   )







       @require_torch
       def 				_a   (					self   )	->				Optional[Any]:
           import torch

           lowercase__									=    JukeboxTokenizer.from_pretrained("openai/jukebox-5b-lyrics"   )
           lowercase__									=    tokenizer(**self.metas   )["input_ids"]
           # fmt: off
           lowercase__									=    [
               torch.tensor([[
                   0, 0, 0, 1_069, 11, -1, -1, -1, -1, 9, 77, 39,
                   31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38,
                   31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27,
                   40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64,
                   79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41,
                   77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48,
                   27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40,
                   37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41,
                   32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77,
                   77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40,
                   77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63,
                   77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77,
                   46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31,
                   77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77,
                   77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37,
                   77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30,
                   77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45,
                   64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49,
                   40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1,
                   40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77,
                   38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31,
                   31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29,
                   41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77,
                   77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27,
                   46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46,
                   41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45,
                   31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44,
                   31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77,
                   23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47,
                   44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42,
                   31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77,
                   38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35,
                   40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77,
                   77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34,
                   27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34,
                   31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77,
                   34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32,
                   31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77,
                   1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42,
                   31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31,
                   45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42,
                   31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77,
                   77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77,
                   15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77,
                   11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33,
                   45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12,
                   41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41,
                   44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34,
                   46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42,
                   27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77,
                   77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45,
                   35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63,
                   77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30,
                   31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77,
                   77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38,
                   41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64,
                   77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27,
                   40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77,
                   77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31,
                   77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45,
                   27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34,
                   77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77,
                   77, 77, 77, 77, 77, 77]]   ),
               torch.tensor([[0, 0, 0, 1_069, 11, -1, -1, -1, -1]]   ),
               torch.tensor([[0, 0, 0, 1_069, 11, -1, -1, -1, -1]]   ),
           ]
           # fmt: on
           self.assertTrue(torch.allclose(tokens[0]  ,EXPECTED_OUTPUT[0]   )   )
           self.assertTrue(torch.allclose(tokens[1]  ,EXPECTED_OUTPUT[1]   )   )
           self.assertTrue(torch.allclose(tokens[2]  ,EXPECTED_OUTPUT[2]   )   )




