



"""simple docstring"""





import argparse
import json
import os

import fairseq
import torch
from torch import nn

from transformers import (
    SpeechaTextaConfig,
    SpeechaTextaForCausalLM,
    SpeechaTextaTokenizer,
    SpeechEncoderDecoderConfig,
    SpeechEncoderDecoderModel,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaModel,
    logging,
)


logging.set_verbosity_info()
__lowerCAmelCase       :					Union[str, Any]      					=					logging.get_logger(__name__)

__lowerCAmelCase       :					Optional[Any]      					=					{
    '''post_extract_proj''': '''feature_projection.projection''',
    '''encoder.pos_conv.0''': '''encoder.pos_conv_embed.conv''',
    '''self_attn.k_proj''': '''encoder.layers.*.attention.k_proj''',
    '''self_attn.v_proj''': '''encoder.layers.*.attention.v_proj''',
    '''self_attn.q_proj''': '''encoder.layers.*.attention.q_proj''',
    '''self_attn.out_proj''': '''encoder.layers.*.attention.out_proj''',
    '''self_attn_layer_norm''': '''encoder.layers.*.layer_norm''',
    '''fc1''': '''encoder.layers.*.feed_forward.intermediate_dense''',
    '''fc2''': '''encoder.layers.*.feed_forward.output_dense''',
    '''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''',
}
__lowerCAmelCase       :					Optional[int]      					=					[
    '''lm_head''',
    '''quantizer.weight_proj''',
    '''quantizer.codevectors''',
    '''project_q''',
    '''project_hid''',
]
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Tuple					, __UpperCamelCase      :			List[str]					, __UpperCamelCase      :			int					, __UpperCamelCase      :			Optional[int]					, __UpperCamelCase      :			str    ):


						'''simple docstring'''






						for attribute in key.split("""."""    ):
												snake_case_   : Dict						=			getattr(__UpperCamelCase					, __UpperCamelCase    )

						if weight_type is not None:
												snake_case_   : Optional[Any]						=			getattr(__UpperCamelCase					, __UpperCamelCase    ).shape
						else:
												snake_case_   : Any						=			hf_pointer.shape

						assert hf_shape == value.shape, (
						    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":
												snake_case_   : Any						=			value
						elif weight_type == "weight_g":
												snake_case_   : Optional[int]						=			value
						elif weight_type == "weight_v":
												snake_case_   : Union[str, Any]						=			value
						elif weight_type == "bias":
												snake_case_   : Optional[int]						=			value
						else:
												snake_case_   : List[Any]						=			value

						logger.info(F'{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.'    )
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Any					, __UpperCamelCase      :			Any    ):


						'''simple docstring'''






						snake_case_   : List[Any]						=			[]
						snake_case_   : Dict						=			fairseq_model.state_dict()

						snake_case_   : Any						=			hf_model.feature_extractor

						# if encoder has different dim to decoder -> use proj_weight
						snake_case_   : Tuple						=			None

						for name, value in fairseq_dict.items():
												snake_case_   : List[str]						=			False
												if "conv_layers" in name:
																		load_conv_layer(
																		    __UpperCamelCase					, __UpperCamelCase					, __UpperCamelCase					, __UpperCamelCase					, hf_model.config.feat_extract_norm == """group"""					, )
																		snake_case_   : Dict						=			True
												elif name.split("""."""    )[0] == "proj":
																		snake_case_   : List[Any]						=			fairseq_model.proj
																		snake_case_   : Tuple						=			True
												else:
																		for key, mapped_key in MAPPING.items():
																								if key in name or key.split("""w2v_model."""    )[-1] == name.split("""."""    )[0]:
																														snake_case_   : Union[str, Any]						=			True
																														if "*" in mapped_key:
																																				snake_case_   : Union[str, Any]						=			name.split(__UpperCamelCase    )[0].split("""."""    )[-2]
																																				snake_case_   : Tuple						=			mapped_key.replace("""*"""					, __UpperCamelCase    )
																														if "weight_g" in name:
																																				snake_case_   : Dict						=			"""weight_g"""
																														elif "weight_v" in name:
																																				snake_case_   : List[str]						=			"""weight_v"""
																														elif "bias" in name:
																																				snake_case_   : List[str]						=			"""bias"""
																														elif "weight" in name:
																																				snake_case_   : List[str]						=			"""weight"""
																														else:
																																				snake_case_   : Tuple						=			None
																														set_recursively(__UpperCamelCase					, __UpperCamelCase					, __UpperCamelCase					, __UpperCamelCase					, __UpperCamelCase    )
																								continue
												if not is_used:
																		unused_weights.append(__UpperCamelCase    )

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

						return proj_weight
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Dict					, __UpperCamelCase      :			str					, __UpperCamelCase      :			List[Any]					, __UpperCamelCase      :			List[str]					, __UpperCamelCase      :			str    ):


						'''simple docstring'''






						snake_case_   : Dict						=			full_name.split("""conv_layers."""    )[-1]
						snake_case_   : str						=			name.split("""."""    )
						snake_case_   : Any						=			int(items[0]    )
						snake_case_   : List[Any]						=			int(items[1]    )

						if type_id == 0:
												if "bias" in name:
																		assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
																		    F'{full_name} has size {value.shape}, but'
																		    F' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'
																		)
																		snake_case_   : Dict						=			value
																		logger.info(F'Feat extract conv layer {layer_id} was initialized from {full_name}.'    )
												elif "weight" in name:
																		assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
																		    F'{full_name} has size {value.shape}, but'
																		    F' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'
																		)
																		snake_case_   : Tuple						=			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:
																		assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
																		    F'{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was'
																		    " found."
																		)
																		snake_case_   : Optional[int]						=			value
																		logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'    )
												elif "weight" in name:
																		assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
																		    F'{full_name} has size {value.shape}, but'
																		    F' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.'
																		)
																		snake_case_   : Dict						=			value
																		logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'    )
						else:
												unused_weights.append(__UpperCamelCase    )
def 	__lowerCAmelCase						(		__UpperCamelCase      :			str    ):


						'''simple docstring'''






						snake_case_   : Dict						=			emb.weight.shape
						snake_case_   : List[Any]						=			nn.Linear(__UpperCamelCase					, __UpperCamelCase					, bias=__UpperCamelCase    )
						snake_case_   : Dict						=			emb.weight.data
						return lin_layer
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Union[str, Any]    ):


						'''simple docstring'''






						with open(__UpperCamelCase					, """r"""					, encoding="""utf-8"""    ) as f:
												snake_case_   : Tuple						=			f.readlines()
												snake_case_   : Optional[Any]						=			[line.split(""" """    )[0] for line in lines]

						snake_case_   : Optional[int]						=			len(__UpperCamelCase    )

						snake_case_   : Union[str, Any]						=			{
						    """<s>""": 0,
						    """<pad>""": 1,
						    """</s>""": 2,
						    """<unk>""": 3,
						}

						vocab_dict.update(dict(zip(__UpperCamelCase					, range(4					, num_words + 4    )    )    )    )
						return vocab_dict
@torch.no_grad()
def 	__lowerCAmelCase						(		__UpperCamelCase      :			str					, __UpperCamelCase      :			List[str]					, __UpperCamelCase      :			str					, __UpperCamelCase      :			List[Any]					, __UpperCamelCase      :			Any					, __UpperCamelCase      :			Any					, __UpperCamelCase      :			Tuple					, ):


						'''simple docstring'''






						snake_case_   : List[Any]						=			WavaVecaConfig.from_pretrained(__UpperCamelCase    )
						snake_case_   : Optional[Any]						=			SpeechaTextaConfig.from_pretrained(
						    __UpperCamelCase					, vocab_size=__UpperCamelCase					, decoder_layers=__UpperCamelCase					, do_stable_layer_norm=__UpperCamelCase    )

						snake_case_   : Optional[int]						=			WavaVecaFeatureExtractor(
						    feature_size=1					, sampling_rate=1_6_0_0_0					, padding_value=0					, do_normalize=__UpperCamelCase					, return_attention_mask=__UpperCamelCase					, )

						snake_case_   : List[Any]						=			fairseq.checkpoint_utils.load_model_ensemble_and_task(
						    [checkpoint_path]					, arg_overrides={"""data""": """/""".join(dict_path.split("""/"""    )[:-1]    )}    )
						snake_case_   : Optional[Any]						=			model[0].eval()

						# set weights for wav2vec2 encoder
						snake_case_   : Any						=			WavaVecaModel(__UpperCamelCase    )
						snake_case_   : List[str]						=			recursively_load_weights_wavaveca(model.encoder					, __UpperCamelCase    )

						snake_case_   : List[str]						=			SpeechaTextaForCausalLM(__UpperCamelCase    )
						snake_case_   : Optional[int]						=			hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()					, strict=__UpperCamelCase    )

						# set output linear layer
						unexpected_keys.remove("""embed_out"""    )
						snake_case_   : int						=			nn.Parameter(model.decoder.embed_out.detach()    )

						# layer norm is init to identity matrix so leaving it is fine
						logger.warning(F'The following keys are missing when loading the decoder weights: {missing_keys}'    )
						logger.warning(F'The following keys are unexpected when loading the decoder weights: {unexpected_keys}'    )

						snake_case_   : Any						=			SpeechEncoderDecoderModel(encoder=__UpperCamelCase					, decoder=__UpperCamelCase    )
						snake_case_   : Tuple						=			False

						# add projection layer
						snake_case_   : int						=			nn.Parameter(projection_layer.weight    )
						snake_case_   : Union[str, Any]						=			nn.Parameter(projection_layer.bias    )

						snake_case_   : Dict						=			create_vocab_dict(__UpperCamelCase    )

						with open(os.path.join(__UpperCamelCase					, """vocab.json"""    )					, """w"""    ) as fp:
												json.dump(__UpperCamelCase					, __UpperCamelCase    )

						snake_case_   : str						=			SpeechaTextaTokenizer(os.path.join(__UpperCamelCase					, """vocab.json"""    )    )
						tokenizer.save_pretrained(__UpperCamelCase    )

						snake_case_   : Dict						=			hf_wavavec.config.to_dict()
						snake_case_   : List[str]						=			tokenizer.pad_token_id
						snake_case_   : Union[str, Any]						=			tokenizer.bos_token_id
						snake_case_   : str						=			tokenizer.eos_token_id
						snake_case_   : str						=			"""speech_to_text_2"""
						snake_case_   : Any						=			"""wav2vec2"""

						snake_case_   : Dict						=			SpeechEncoderDecoderConfig.from_dict(__UpperCamelCase    )

						hf_wavavec.save_pretrained(__UpperCamelCase    )
						feature_extractor.save_pretrained(__UpperCamelCase    )


if __name__ == "__main__":
					__lowerCAmelCase       :					Union[str, Any]      					=					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(
					    '''--encoder_config_path''',
					    default='''facebook/wav2vec2-large-lv60''',
					    type=str,
					    help='''Path to hf encoder wav2vec2 checkpoint config''',
					)
					parser.add_argument(
					    '''--decoder_config_path''',
					    default='''facebook/s2t-small-mustc-en-fr-st''',
					    type=str,
					    help='''Path to hf decoder s2t checkpoint config''',
					)
					parser.add_argument('''--vocab_size''', default=1_0224, type=int, help='''Vocab size of decoder''')
					parser.add_argument('''--num_decoder_layers''', default=7, type=int, help='''Number of decoder layers''')

					__lowerCAmelCase       :					Any      					=					parser.parse_args()
					convert_wavaveca_checkpoint(
					    args.checkpoint_path,
					    args.pytorch_dump_folder_path,
					    args.dict_path,
					    encoder_config_path=args.encoder_config_path,
					    decoder_config_path=args.decoder_config_path,
					    vocab_size=args.vocab_size,
					    num_decoder_layers=args.num_decoder_layers,
					)








"""simple docstring"""





from sklearn.metrics import fa_score, matthews_corrcoef

import datasets

from .record_evaluation import evaluate as evaluate_record


__lowerCAmelCase       :					List[str]      					=					'''\
@article{wang2019superglue,
  title={SuperGLUE: A Stickier Benchmark for General-Purpose Language Understanding Systems},
  author={Wang, Alex and Pruksachatkun, Yada and Nangia, Nikita and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R},
  journal={arXiv preprint arXiv:1905.00537},
  year={2019}
}
'''

__lowerCAmelCase       :					Optional[Any]      					=					'''\
SuperGLUE (https://super.gluebenchmark.com/) is a new benchmark styled after
GLUE with a new set of more difficult language understanding tasks, improved
resources, and a new public leaderboard.
'''

__lowerCAmelCase       :					str      					=					'''
Compute SuperGLUE evaluation metric associated to each SuperGLUE dataset.
Args:
    predictions: list of predictions to score. Depending on the SuperGlUE subset:
        - for \'record\': list of question-answer dictionaries with the following keys:
            - \'idx\': index of the question as specified by the dataset
            - \'prediction_text\': the predicted answer text
        - for \'multirc\': list of question-answer dictionaries with the following keys:
            - \'idx\': index of the question-answer pair as specified by the dataset
            - \'prediction\': the predicted answer label
        - otherwise: list of predicted labels
    references: list of reference labels. Depending on the SuperGLUE subset:
        - for \'record\': list of question-answers dictionaries with the following keys:
            - \'idx\': index of the question as specified by the dataset
            - \'answers\': list of possible answers
        - otherwise: list of reference labels
Returns: depending on the SuperGLUE subset:
    - for \'record\':
        - \'exact_match\': Exact match between answer and gold answer
        - \'f1\': F1 score
    - for \'multirc\':
        - \'exact_match\': Exact match between answer and gold answer
        - \'f1_m\': Per-question macro-F1 score
        - \'f1_a\': Average F1 score over all answers
    - for \'axb\':
        \'matthews_correlation\': Matthew Correlation
    - for \'cb\':
        - \'accuracy\': Accuracy
        - \'f1\': F1 score
    - for all others:
        - \'accuracy\': Accuracy
Examples:

    >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'copa\')  # any of ["copa", "rte", "wic", "wsc", "wsc.fixed", "boolq", "axg"]
    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'accuracy\': 1.0}

    >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'cb\')
    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'accuracy\': 1.0, \'f1\': 1.0}

    >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'record\')
    >>> predictions = [{\'idx\': {\'passage\': 0, \'query\': 0}, \'prediction_text\': \'answer\'}]
    >>> references = [{\'idx\': {\'passage\': 0, \'query\': 0}, \'answers\': [\'answer\', \'another_answer\']}]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'exact_match\': 1.0, \'f1\': 1.0}

    >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'multirc\')
    >>> predictions = [{\'idx\': {\'answer\': 0, \'paragraph\': 0, \'question\': 0}, \'prediction\': 0}, {\'idx\': {\'answer\': 1, \'paragraph\': 2, \'question\': 3}, \'prediction\': 1}]
    >>> references = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'exact_match\': 1.0, \'f1_m\': 1.0, \'f1_a\': 1.0}

    >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'axb\')
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'matthews_correlation\': 1.0}
'''
def 	__lowerCAmelCase						(		__UpperCamelCase      :			List[str]					, __UpperCamelCase      :			Any    ):


						'''simple docstring'''






						return float((preds == labels).mean()    )
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Any					, __UpperCamelCase      :			Optional[int]					, __UpperCamelCase      :			str="binary"    ):


						'''simple docstring'''






						snake_case_   : Optional[Any]						=			simple_accuracy(__UpperCamelCase					, __UpperCamelCase    )
						snake_case_   : Dict						=			float(fa_score(y_true=__UpperCamelCase					, y_pred=__UpperCamelCase					, average=__UpperCamelCase    )    )
						return {
						    "accuracy": acc,
						    "f1": fa,
						}
def 	__lowerCAmelCase						(		__UpperCamelCase      :			str					, __UpperCamelCase      :			int    ):


						'''simple docstring'''






						snake_case_   : List[Any]						=			{}
						for id_pred, label in zip(__UpperCamelCase					, __UpperCamelCase    ):
												snake_case_   : Optional[int]						=			F'{id_pred["idx"]["paragraph"]}-{id_pred["idx"]["question"]}'
												snake_case_   : Union[str, Any]						=			id_pred["""prediction"""]
												if question_id in question_map:
																		question_map[question_id].append((pred, label)    )
												else:
																		snake_case_   : str						=			[(pred, label)]
						snake_case_			,		snake_case_   : List[str]						=			[], []
						for question, preds_labels in question_map.items():
												snake_case_			,		snake_case_   : Optional[Any]						=			zip(*__UpperCamelCase    )
												snake_case_   : int						=			fa_score(y_true=__UpperCamelCase					, y_pred=__UpperCamelCase					, average="""macro"""    )
												fas.append(__UpperCamelCase    )
												snake_case_   : Dict						=			int(sum(pred == label for pred, label in preds_labels    ) == len(__UpperCamelCase    )    )
												ems.append(__UpperCamelCase    )
						snake_case_   : Optional[int]						=			float(sum(__UpperCamelCase    ) / len(__UpperCamelCase    )    )
						snake_case_   : Any						=			sum(__UpperCamelCase    ) / len(__UpperCamelCase    )
						snake_case_   : int						=			float(fa_score(y_true=__UpperCamelCase					, y_pred=[id_pred["""prediction"""] for id_pred in ids_preds]    )    )
						return {"exact_match": em, "f1_m": fa_m, "f1_a": fa_a}






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION  ,				_KWARGS_DESCRIPTION		)
class    _lowerCAmelCase    (				datasets.Metric		):





		"""simple docstring"""






		def    UpperCAmelCase__							(					self   ) ->						Optional[int]:







								'''simple docstring'''

								if self.config_name not in [
								    "boolq",
								    "cb",
								    "copa",
								    "multirc",
								    "record",
								    "rte",
								    "wic",
								    "wsc",
								    "wsc.fixed",
								    "axb",
								    "axg",
								]:
														raise KeyError(
														    """You should supply a configuration name selected in """
														    """[\"boolq\", \"cb\", \"copa\", \"multirc\", \"record\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"axb\", \"axg\",]"""   )
								return datasets.MetricInfo(
								    description=_DESCRIPTION							,    citation=_CITATION							,    inputs_description=_KWARGS_DESCRIPTION							,    features=datasets.Features(self._get_feature_types()   )							,    codebase_urls=[]							,    reference_urls=[]							,    format="""numpy""" if not self.config_name == """record""" and not self.config_name == """multirc""" else None							,    )





		def    UpperCAmelCase__							(					self   ) ->						Optional[int]:







								'''simple docstring'''

								if self.config_name == "record":
														return {
														    "predictions": {
														        "idx": {
														            "passage": datasets.Value("""int64"""   ),
														            "query": datasets.Value("""int64"""   ),
														        },
														        "prediction_text": datasets.Value("""string"""   ),
														    },
														    "references": {
														        "idx": {
														            "passage": datasets.Value("""int64"""   ),
														            "query": datasets.Value("""int64"""   ),
														        },
														        "answers": datasets.Sequence(datasets.Value("""string"""   )   ),
														    },
														}
								elif self.config_name == "multirc":
														return {
														    "predictions": {
														        "idx": {
														            "answer": datasets.Value("""int64"""   ),
														            "paragraph": datasets.Value("""int64"""   ),
														            "question": datasets.Value("""int64"""   ),
														        },
														        "prediction": datasets.Value("""int64"""   ),
														    },
														    "references": datasets.Value("""int64"""   ),
														}
								else:
														return {
														    "predictions": datasets.Value("""int64"""   ),
														    "references": datasets.Value("""int64"""   ),
														}





		def    UpperCAmelCase__							(					self							,    _lowercase							,    _lowercase   ) ->						List[str]:







								'''simple docstring'''

								if self.config_name == "axb":
														return {"matthews_correlation": matthews_corrcoef(_lowercase							,    _lowercase   )}
								elif self.config_name == "cb":
														return acc_and_fa(_lowercase							,    _lowercase							,    fa_avg="""macro"""   )
								elif self.config_name == "record":
														snake_case_   : Optional[Any]						=			[
														    {
														        """qas""": [
														            {"""id""": ref["""idx"""]["""query"""], """answers""": [{"""text""": ans} for ans in ref["""answers"""]]}
														            for ref in references
														        ]
														    }
														]
														snake_case_   : Dict						=			{pred["""idx"""]["""query"""]: pred["""prediction_text"""] for pred in predictions}
														return evaluate_record(_lowercase							,    _lowercase   )[0]
								elif self.config_name == "multirc":
														return evaluate_multirc(_lowercase							,    _lowercase   )
								elif self.config_name in ["copa", "rte", "wic", "wsc", "wsc.fixed", "boolq", "axg"]:
														return {"accuracy": simple_accuracy(_lowercase							,    _lowercase   )}
								else:
														raise KeyError(
														    """You should supply a configuration name selected in """
														    """[\"boolq\", \"cb\", \"copa\", \"multirc\", \"record\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"axb\", \"axg\",]"""   )

