





'''simple docstring'''

import argparse
import json
import os
from collections import OrderedDict

import numpy as np
import tensorflow as tf
import torch





def lowerCamelCase						(     __lowerCamelCase :    str    )						->Union[str, Any]:
    _SCREAMING_SNAKE_CASE									=			os.path.join(args.tf_model_dir					,       """parameters.json"""    )
    _SCREAMING_SNAKE_CASE									=			json.loads(open(__lowerCamelCase    ).read()    )
    if not params:
        raise ValueError(
            F'It seems that the json file at {parameter_file} is empty. Make sure you have a correct json file.'    )
    if not args.output.endswith(""".pt"""    ):
        _SCREAMING_SNAKE_CASE									=			args.output + """.pt"""
    _SCREAMING_SNAKE_CASE									=			OrderedDict()
    with tf.device("""/CPU:0"""    ):
        _SCREAMING_SNAKE_CASE									=			tf.train.load_checkpoint(args.tf_model_dir    )
        _SCREAMING_SNAKE_CASE									=			reader.get_variable_to_shape_map()
        for key_name in shapes.keys():
            _SCREAMING_SNAKE_CASE									=			reader.get_tensor(__lowerCamelCase    ).astype(np.floataa    )
            if key_name.endswith("""/adam_m"""    ) or key_name.endswith("""/adam_v"""    ):
                continue
            if key_name.startswith("""pasts/"""    ):
                if key_name.startswith("""pasts/mlp"""    ):
                    _SCREAMING_SNAKE_CASE									=			int(key_name[9]    )
                elif key_name.startswith("""pasts/out"""    ):
                    _SCREAMING_SNAKE_CASE									=			8
                _SCREAMING_SNAKE_CASE									=			"""model.sqout.%d.weight""" % (player * 2)  # enter to nn.Sequencial with Tanh, so 2 at a time
                _SCREAMING_SNAKE_CASE									=			vnp.transpose([1, 0]    ).copy()  # Mesh-Tensorflow is a diagonal matrix
                _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
            elif key_name.startswith("""model/moe"""    ):
                _SCREAMING_SNAKE_CASE									=			int(key_name[9:].split("""/"""    )[0]    )
                if key_name.endswith("""/switch_gating/kernel"""    ):
                    _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.feed_forward.mlp.router.classifier.weight""" % player
                    _SCREAMING_SNAKE_CASE									=			vnp.transpose([1, 0]    ).copy()  # Mesh-Tensorflow is a diagonal matrix
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
                elif key_name.endswith("""/softmlp/kernel"""    ):
                    _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.feed_forward.soft_bypass_mlp.weight""" % player
                    _SCREAMING_SNAKE_CASE									=			vnp.transpose([1, 0]    ).copy()  # Mesh-Tensorflow is a diagonal matrix
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
                elif key_name.endswith("""/wo/kernel"""    ) or key_name.endswith("""/wi/kernel"""    ):
                    _SCREAMING_SNAKE_CASE									=			key_name[-9:-7]
                    for i in range(16    ):
                        _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.feed_forward.mlp.experts.expert_%d.%s.weight""" % (player, i, nlayer)
                        _SCREAMING_SNAKE_CASE									=			(
                            vnp[i].transpose([1, 0]    ).copy()
                        )  # In Mesh-Tensorflow, it is one array, so it is divided
                        _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
            elif key_name.startswith("""model/mlp"""    ):
                _SCREAMING_SNAKE_CASE									=			int(key_name[9:].split("""/"""    )[0]    )
                if key_name.endswith("""/p1/kernel"""    ):
                    _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.feed_forward.mlp.wi.weight""" % player
                    _SCREAMING_SNAKE_CASE									=			vnp.transpose([1, 0]    ).copy()  # Mesh-Tensorflow is a diagonal matrix
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
                elif key_name.endswith("""/p1/bias"""    ):
                    _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.feed_forward.mlp.wi.bias""" % player
                    _SCREAMING_SNAKE_CASE									=			vnp.copy()  # same because it is one dimensional
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
                elif key_name.endswith("""/p2/kernel"""    ):
                    _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.feed_forward.mlp.wo.weight""" % player
                    _SCREAMING_SNAKE_CASE									=			vnp.transpose([1, 0]    ).copy()  # Mesh-Tensorflow is a diagonal matrix
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
                elif key_name.endswith("""/p2/bias"""    ):
                    _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.feed_forward.mlp.wo.bias""" % player
                    _SCREAMING_SNAKE_CASE									=			vnp.copy()  # same because it is one dimensional
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
            elif key_name.startswith("""model/ln"""    ):
                _SCREAMING_SNAKE_CASE									=			int(key_name[8:].split("""/"""    )[0]    )
                if key_name.endswith("""/b"""    ):
                    _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.feed_forward.norm.bias""" % player
                    _SCREAMING_SNAKE_CASE									=			vnp.copy()  # same because it is one dimensional
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
                elif key_name.endswith("""/g"""    ):
                    _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.feed_forward.norm.weight""" % player
                    _SCREAMING_SNAKE_CASE									=			vnp.copy()  # same because it is one dimensional
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
            elif key_name.startswith("""model/att"""    ):
                _SCREAMING_SNAKE_CASE									=			int(key_name[9:].split("""/"""    )[0]    )
                if key_name.endswith("""/qkv/kernel"""    ):
                    _SCREAMING_SNAKE_CASE									=			vnp.copy()  # Compute same dimension as Mesh-tensorflow using einsum
                    _SCREAMING_SNAKE_CASE									=			state[:, 0, :, :]
                    _SCREAMING_SNAKE_CASE									=			state[:, 1, :, :]
                    _SCREAMING_SNAKE_CASE									=			state[:, 2, :, :]
                    _SCREAMING_SNAKE_CASE									=			(
                        state_q.reshape([state_q.shape[0], state_q.shape[1] * state_q.shape[2]]    )
                        .transpose([1, 0]    )
                        .copy()
                    )  # Mesh-Tensorflow is a diagonal matrix
                    _SCREAMING_SNAKE_CASE									=			(
                        state_k.reshape([state_k.shape[0], state_k.shape[1] * state_k.shape[2]]    )
                        .transpose([1, 0]    )
                        .copy()
                    )  # Mesh-Tensorflow is a diagonal matrix
                    _SCREAMING_SNAKE_CASE									=			(
                        state_v.reshape([state_v.shape[0], state_v.shape[1] * state_v.shape[2]]    )
                        .transpose([1, 0]    )
                        .copy()
                    )  # Mesh-Tensorflow is a diagonal matrix
                    _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.self_attn.self_attn.q_proj.weight""" % player
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
                    _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.self_attn.self_attn.k_proj.weight""" % player
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
                    _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.self_attn.self_attn.v_proj.weight""" % player
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
                elif key_name.endswith("""/o/kernel"""    ):
                    _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.self_attn.self_attn.out_proj.weight""" % player
                    _SCREAMING_SNAKE_CASE									=			(
                        vnp.reshape([vnp.shape[0] * vnp.shape[1], vnp.shape[2]]    ).transpose([1, 0]    ).copy()
                    )  # Mesh-Tensorflow is a diagonal matrix
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
            elif key_name.startswith("""model/an"""    ):
                _SCREAMING_SNAKE_CASE									=			int(key_name[8:].split("""/"""    )[0]    )
                if key_name.endswith("""/b"""    ):
                    _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.self_attn.norm.bias""" % player
                    _SCREAMING_SNAKE_CASE									=			vnp.copy()  # same because it is one dimensional
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
                elif key_name.endswith("""/g"""    ):
                    _SCREAMING_SNAKE_CASE									=			"""model.blocks.%d.self_attn.norm.weight""" % player
                    _SCREAMING_SNAKE_CASE									=			vnp.copy()  # same because it is one dimensional
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
            elif (
                key_name.startswith("""model/wte"""    )
                or key_name.startswith("""model/wpe"""    )
                or key_name.startswith("""model/ete"""    )
            ):
                _SCREAMING_SNAKE_CASE									=			{"""wte""": """embed_tokens""", """wpe""": """position_embeddings""", """ete""": """extra_position_embeddings"""}[
                    key_name[-3:]
                ]
                _SCREAMING_SNAKE_CASE									=			"""model.%s.weight""" % nlayer
                _SCREAMING_SNAKE_CASE									=			vnp.copy()  # same in embedded
                _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
                if key_name.startswith("""model/wte"""    ):
                    _SCREAMING_SNAKE_CASE									=			"""lm_head.weight"""
                    _SCREAMING_SNAKE_CASE									=			vnp.copy()  # same in embedded
                    _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
            elif key_name.startswith("""model/wob"""    ):
                _SCREAMING_SNAKE_CASE									=			"""final_logits_bias"""
                _SCREAMING_SNAKE_CASE									=			vnp.copy()  # same in embedded
                _SCREAMING_SNAKE_CASE									=			state.reshape((1, -1)    )
                _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
            elif key_name == "model/dense/kernel":
                _SCREAMING_SNAKE_CASE									=			"""model.last_project.weight"""
                _SCREAMING_SNAKE_CASE									=			vnp.transpose([1, 0]    ).copy()  # Mesh-Tensorflow is a diagonal matrix
                _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
            elif key_name == "model/dense_1/bias":
                _SCREAMING_SNAKE_CASE									=			"""model.last_project.bias"""
                _SCREAMING_SNAKE_CASE									=			vnp.copy()  # same because it is one dimensional
                _SCREAMING_SNAKE_CASE									=			torch.tensor(__lowerCamelCase    )
    torch.save(__lowerCamelCase					,       args.output    )


if __name__ == "__main__":
      lowercase_					= argparse.ArgumentParser(
          description="""model converter.""", formatter_class=argparse.ArgumentDefaultsHelpFormatter
      )
      parser.add_argument("""--tf_model_dir""", metavar="""PATH""", type=str, required=True, help="""import model""")
      parser.add_argument("""--output""", metavar="""PATH""", type=str, required=True, help="""output model""")
      lowercase_					= parser.parse_args()
      convert_tf_gptsan_to_pt(args)










'''simple docstring'''

from __future__ import annotations

import math





def lowerCamelCase						(     __lowerCamelCase :    int    )						->list[int]:

    if num <= 0:
        _SCREAMING_SNAKE_CASE									=			F'{num}: Invalid input, please enter a positive integer.'
        raise ValueError(__lowerCamelCase    )

    _SCREAMING_SNAKE_CASE									=			[True] * (num + 1)
    _SCREAMING_SNAKE_CASE									=			[]
    _SCREAMING_SNAKE_CASE									=			2
    _SCREAMING_SNAKE_CASE									=			int(math.sqrt(__lowerCamelCase    )    )

    while start <= end:
        # If start is a prime
        if sieve[start] is True:
            prime.append(__lowerCamelCase    )

            # Set multiples of start be False
            for i in range(start * start					,       num + 1					,       __lowerCamelCase    ):
                if sieve[i] is True:
                    _SCREAMING_SNAKE_CASE									=			False

        start += 1

    for j in range(end + 1					,       num + 1    ):
        if sieve[j] is True:
            prime.append(__lowerCamelCase    )

    return prime


if __name__ == "__main__":
      print(prime_sieve(int(input("""Enter a positive integer: """).strip())))



