





from __future__ import annotations

import math


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     bool:

    if 1 < number < 4:
        # 2 and 3 are primes
        return True
    elif number < 2 or number % 2 == 0 or number % 3 == 0:
        # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
        return False

    # All primes number are in format of 6k +/- 1
    for i in range(5						,	int(math.sqrt(_UpperCAmelCase ) + 1 )						,	6 ):
        if number % i == 0 or number % (i + 2) == 0:
            return False
    return True


_UpperCAmelCase				:       Any	   =				[num for num in range(3, 10_00_01, 2) if not is_prime(num)]


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     list[int]:
    if not isinstance(_UpperCAmelCase						,	_UpperCAmelCase ):
        raise ValueError('n must be an integer' )
    if n <= 0:
        raise ValueError('n must be >= 0' )

    lowerCamelCase__    :      int					 =		[]
    for num in range(len(_UpperCAmelCase ) ):
        lowerCamelCase__    :      Union[str, Any]					 =		0
        while 2 * i * i <= odd_composites[num]:
            lowerCamelCase__    :      Dict					 =		odd_composites[num] - 2 * i * i
            if is_prime(_UpperCAmelCase ):
                break
            i += 1
        else:
            list_nums.append(odd_composites[num] )
            if len(_UpperCAmelCase ) == n:
                return list_nums

    return []


def        SCREAMING_SNAKE_CASE      (       )			->     int:
    return compute_nums(1 )[0]


if __name__ == "__main__":
    print(F"""{solution() = }""")











"""simple docstring"""




import numpy as np
import torch
from torch.utils.data import Dataset, IterableDataset

from ..utils.generic import ModelOutput






class     __magic_name__							(       UpperCAmelCase__				):






				'''simple docstring'''





				def __init__(       self		, _a		, _a		, _a ):





							"""simple docstring"""
							lowerCamelCase			      =					dataset
							lowerCamelCase			      =					process
							lowerCamelCase			      =					params





				def __len__(       self ):





							"""simple docstring"""
							return len(self.dataset )





				def __getitem__(       self		, _a ):





							"""simple docstring"""
							lowerCamelCase			      =					self.dataset[i]
							lowerCamelCase			      =					self.process(_a		, **self.params )
							return processed






class     __magic_name__							(       UpperCAmelCase__				):






				'''simple docstring'''





				def __init__(       self		, _a		, _a		, _a		, _a=None ):





							"""simple docstring"""
							lowerCamelCase			      =					loader
							lowerCamelCase			      =					infer
							lowerCamelCase			      =					params
							if loader_batch_size == 1:
										# Let's spare some time by deactivating altogether
										lowerCamelCase			      =					None
							lowerCamelCase			      =					loader_batch_size

							# Internal bookkeeping
							lowerCamelCase			      =					None
							lowerCamelCase			      =					None





				def __len__(       self ):





							"""simple docstring"""
							return len(self.loader )





				def __iter__(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					iter(self.loader )
							return self





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							if isinstance(self._loader_batch_data		, torch.Tensor ):
										# Batch data is simple tensor, just fetch the slice
										lowerCamelCase			      =					self._loader_batch_data[self._loader_batch_index]
							else:
										# Batch data is assumed to be BaseModelOutput (or dict)
										lowerCamelCase			      =					{}
										for k, element in self._loader_batch_data.items():
													if isinstance(_a		, _a ):
																# Convert ModelOutput to tuple first
																lowerCamelCase			      =					element.to_tuple()
																if isinstance(element[0]		, torch.Tensor ):
																			lowerCamelCase			      =					tuple(el[self._loader_batch_index].unsqueeze(0 ) for el in element )
																elif isinstance(element[0]		, np.ndarray ):
																			lowerCamelCase			      =					tuple(np.expand_dims(el[self._loader_batch_index]		, 0 ) for el in element )
																continue
													if k in {"hidden_states", "past_key_values", "attentions"} and isinstance(_a		, _a ):
																# Those are stored as lists of tensors so need specific unbatching.
																if isinstance(element[0]		, torch.Tensor ):
																			lowerCamelCase			      =					tuple(el[self._loader_batch_index].unsqueeze(0 ) for el in element )
																elif isinstance(element[0]		, np.ndarray ):
																			lowerCamelCase			      =					tuple(np.expand_dims(el[self._loader_batch_index]		, 0 ) for el in element )
																continue
													if element is None:
																# This can happen for optional data that get passed around
																lowerCamelCase			      =					None
													elif isinstance(element[self._loader_batch_index]		, torch.Tensor ):
																# Take correct batch data, but make it looked like batch_size=1
																# For compatibility with other methods within transformers

																lowerCamelCase			      =					element[self._loader_batch_index].unsqueeze(0 )
													elif isinstance(element[self._loader_batch_index]		, np.ndarray ):
																# Take correct batch data, but make it looked like batch_size=1
																# For compatibility with other methods within transformers
																lowerCamelCase			      =					np.expand_dims(element[self._loader_batch_index]		, 0 )
													else:
																# This is typically a list, so no need to `unsqueeze`.
																lowerCamelCase			      =					element[self._loader_batch_index]
            # Recreate the element by reusing the original class to make it look
            # batch_size=1
										lowerCamelCase			      =					self._loader_batch_data.__class__(_a )
							self._loader_batch_index += 1
							return result





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							if self._loader_batch_index is not None and self._loader_batch_index < self.loader_batch_size:
										# We are currently unrolling a batch so we just need to return
										# the current item within a batch
										return self.loader_batch_item()

							# We're out of items within a batch
							lowerCamelCase			      =					next(self.iterator )
							lowerCamelCase			      =					self.infer(_a		, **self.params )
							# We now have a batch of "inferred things".
							if self.loader_batch_size is not None:
										# Try to infer the size of the batch
										if isinstance(_a		, torch.Tensor ):
													lowerCamelCase			      =					processed
										else:
													lowerCamelCase			      =					list(processed.keys() )[0]
													lowerCamelCase			      =					processed[key]
										if isinstance(_a		, _a ):
													lowerCamelCase			      =					len(_a )
										else:
													lowerCamelCase			      =					first_tensor.shape[0]
										if 0 < observed_batch_size < self.loader_batch_size:
													# could be last batch so we can't unroll as many
													# elements.
													lowerCamelCase			      =					observed_batch_size
										# Setting internal index to unwrap the batch
										lowerCamelCase			      =					processed
										lowerCamelCase			      =					0
										return self.loader_batch_item()
							else:
										# We're not unrolling batches
										return processed






class     __magic_name__							(       UpperCAmelCase__				):






				'''simple docstring'''





				def __init__(       self		, _a		, _a		, _a		, _a=None ):





							"""simple docstring"""
							super().__init__(_a		, _a		, _a )





				def __iter__(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					iter(self.loader )
							lowerCamelCase			      =					None
							return self





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							if self.subiterator is None:
										lowerCamelCase			      =					self.infer(next(self.iterator )		, **self.params )
							try:
										# Try to return next item
										lowerCamelCase			      =					next(self.subiterator )
							except StopIteration:
										# When a preprocess iterator ends, we can start lookig at the next item
										# ChunkIterator will keep feeding until ALL elements of iterator
										# all have created their subiterator and have been iterating against.
										#
										# Another way to look at it, is we're basically flattening lists of lists
										# into a single list, but with generators
										lowerCamelCase			      =					self.infer(next(self.iterator )		, **self.params )
										lowerCamelCase			      =					next(self.subiterator )
							return processed






class     __magic_name__							(       UpperCAmelCase__				):






				'''simple docstring'''





				def __iter__(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					iter(self.loader )
							return self





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							# Extremely similar to PipelineIterator in its unpacking mechanism
							# BUT, we have an extra required item which is the presence of `is_last`
							# That is because everything is flattened by `PipelineChunkIterator` we
							# need to keep track of how to regroup here in the original `process`
							# boundaries so that `process` and `postprocess` see the same data.

							# This iterator accumulates items (possibly while unbatching) until it
							# its a `is_last` and then just passes it on to the caller.
							lowerCamelCase			      =					False
							lowerCamelCase			      =					[]
							if self._loader_batch_index is not None and self._loader_batch_index < self.loader_batch_size:
										while self._loader_batch_index < self.loader_batch_size:
													lowerCamelCase			      =					self.loader_batch_item()
													lowerCamelCase			      =					item.pop("""is_last""" )
													accumulator.append(_a )
													if is_last:
																return accumulator

							while not is_last:
										lowerCamelCase			      =					self.infer(next(self.iterator )		, **self.params )
										if self.loader_batch_size is not None:
													if isinstance(_a		, torch.Tensor ):
																lowerCamelCase			      =					processed
													else:
																lowerCamelCase			      =					list(processed.keys() )[0]
																lowerCamelCase			      =					processed[key]
													if isinstance(_a		, _a ):
																lowerCamelCase			      =					len(_a )
													else:
																lowerCamelCase			      =					first_tensor.shape[0]
													if 0 < observed_batch_size < self.loader_batch_size:
																# could be last batch so we can't unroll as many
																# elements.
																lowerCamelCase			      =					observed_batch_size
													lowerCamelCase			      =					processed
													lowerCamelCase			      =					0
													while self._loader_batch_index < self.loader_batch_size:
																lowerCamelCase			      =					self.loader_batch_item()
																lowerCamelCase			      =					item.pop("""is_last""" )
																accumulator.append(_a )
																if is_last:
																			return accumulator
										else:
													lowerCamelCase			      =					processed
													lowerCamelCase			      =					item.pop("""is_last""" )
													accumulator.append(_a )
							return accumulator






class     __magic_name__							(       UpperCAmelCase__				):






				'''simple docstring'''





				def __init__(       self		, _a		, _a ):





							"""simple docstring"""
							lowerCamelCase			      =					dataset
							lowerCamelCase			      =					key





				def __len__(       self ):





							"""simple docstring"""
							return len(self.dataset )





				def __getitem__(       self		, _a ):





							"""simple docstring"""
							return self.dataset[i][self.key]






class     __magic_name__							(       UpperCAmelCase__				):






				'''simple docstring'''





				def __init__(       self		, _a		, _a		, _a ):





							"""simple docstring"""
							lowerCamelCase			      =					dataset
							lowerCamelCase			      =					keya
							lowerCamelCase			      =					keya





				def __len__(       self ):





							"""simple docstring"""
							return len(self.dataset )





				def __getitem__(       self		, _a ):





							"""simple docstring"""
							return {"text": self.dataset[i][self.keya], "text_pair": self.dataset[i][self.keya]}



