# TORCH IMPORTS ONLY - EXTRACTED FROM PYTORCH TEST SUITE
# ========================================================

# MAIN TORCH IMPORTS
# ------------------
import torch
import torch.amp.grad_scaler
import torch.ao
import torch.ao.nn.intrinsic
import torch.ao.nn.intrinsic.modules.fused
import torch.ao.nn.intrinsic.qat
import torch.ao.nn.intrinsic.quantized
import torch.ao.nn.intrinsic.quantized.dynamic
import torch.ao.nn.qat
import torch.ao.nn.qat.dynamic
import torch.ao.nn.quantized
import torch.ao.nn.quantized.dynamic
import torch.ao.nn.quantized.functional
import torch.ao.nn.quantized.modules.utils
import torch.ao.nn.quantized.reference
import torch.ao.nn.sparse.quantized.dynamic.linear
import torch.ao.ns._numeric_suite
import torch.ao.ns._numeric_suite_fx
import torch.ao.ns.fx.graph_matcher
import torch.ao.ns.fx.mappings
import torch.ao.ns.fx.pattern_utils
import torch.ao.ns.fx.qconfig_multi_mapping
import torch.ao.ns.fx.utils
import torch.ao.ns.fx.weight_utils
import torch.ao.pruning
import torch.ao.pruning._experimental.activation_sparsifier.activation_sparsifier
import torch.ao.pruning._experimental.data_scheduler
import torch.ao.pruning._experimental.data_sparsifier
import torch.ao.pruning._experimental.data_sparsifier.quantization_utils
import torch.ao.pruning._experimental.pruner
import torch.ao.pruning.sparsifier
import torch.ao.pruning.sparsifier.utils
import torch.ao.quantization
import torch.ao.quantization._correct_bias
import torch.ao.quantization._equalize
import torch.ao.quantization._learnable_fake_quantize
import torch.ao.quantization.backend_config
import torch.ao.quantization.backend_config.native
import torch.ao.quantization.experimental.adaround_optimization
import torch.ao.quantization.experimental.fake_quantize
import torch.ao.quantization.experimental.fake_quantize_function
import torch.ao.quantization.experimental.linear
import torch.ao.quantization.experimental.observer
import torch.ao.quantization.experimental.qconfig
import torch.ao.quantization.experimental.quantization_helper
import torch.ao.quantization.experimental.quantizer
import torch.ao.quantization.fake_quantize
import torch.ao.quantization.fuse_modules
import torch.ao.quantization.fuser_method_mappings
import torch.ao.quantization.fx._decomposed
import torch.ao.quantization.fx._equalize
import torch.ao.quantization.fx._model_report.detector
import torch.ao.quantization.fx._model_report.model_report
import torch.ao.quantization.fx._model_report.model_report_observer
import torch.ao.quantization.fx._model_report.model_report_visualizer
import torch.ao.quantization.fx.custom_config
import torch.ao.quantization.fx.lstm_utils
import torch.ao.quantization.fx.match_utils
import torch.ao.quantization.fx.pattern_utils
import torch.ao.quantization.fx.qconfig_mapping_utils
import torch.ao.quantization.fx.quantize_handler
import torch.ao.quantization.fx.utils
import torch.ao.quantization.observer
import torch.ao.quantization.pt2e._affine_quantization
import torch.ao.quantization.pt2e._numeric_debugger
import torch.ao.quantization.pt2e.graph_utils
import torch.ao.quantization.pt2e.lowering
import torch.ao.quantization.qconfig
import torch.ao.quantization.qconfig_mapping
import torch.ao.quantization.quant_type
import torch.ao.quantization.quantization_mappings
import torch.ao.quantization.quantize
import torch.ao.quantization.quantize_fx
import torch.ao.quantization.quantize_jit
import torch.ao.quantization.quantize_pt2e
import torch.ao.quantization.quantizer
import torch.ao.quantization.quantizer.composable_quantizer
import torch.ao.quantization.quantizer.embedding_quantizer
import torch.ao.quantization.quantizer.x86_inductor_quantizer
import torch.ao.quantization.quantizer.xnnpack_quantizer
import torch.ao.quantization.quantizer.xnnpack_quantizer_utils
import torch.ao.quantization.utils
import torch.autograd
import torch.autograd._functions
import torch.autograd.forward_ad
import torch.autograd.function
import torch.autograd.functional
import torch.autograd.grad_mode
import torch.autograd.gradcheck
import torch.autograd.graph
import torch.autograd.profiler
import torch.autograd.profiler_legacy
import torch.autograd.profiler_util
import torch.backends._nnapi.prepare
import torch.backends.cuda
import torch.backends.cudnn
import torch.backends.mkldnn
import torch.backends.mps
import torch.backends.opt_einsum
import torch.backends.quantized
import torch.backends.xeon.run_cpu
import torch.backends.xnnpack
import torch.compiler
import torch.compiler._cache
import torch.compiler.config
import torch.cuda
import torch.cuda._gpu_trace
import torch.cuda._memory_viz
import torch.cuda._sanitizer
import torch.cuda._utils
import torch.cuda.amp
import torch.cuda.amp.common
import torch.cuda.comm
import torch.cuda.jiterator
import torch.cuda.nccl
import torch.distributed
import torch.distributed._composable
import torch.distributed._composable.contract
import torch.distributed._composable.fsdp
import torch.distributed._composable.fsdp.fully_shard
import torch.distributed._composable.replicate
import torch.distributed._composable.replicate_with_fsdp
import torch.distributed._dist2
import torch.distributed._functional_collectives
import torch.distributed._pycute
import torch.distributed._serialization
import torch.distributed._shard
import torch.distributed._shard.api
import torch.distributed._shard.sharded_optim
import torch.distributed._shard.sharded_tensor
import torch.distributed._shard.sharded_tensor.api
import torch.distributed._shard.sharded_tensor.logger
import torch.distributed._shard.sharded_tensor.metadata
import torch.distributed._shard.sharded_tensor.utils
import torch.distributed._shard.sharder
import torch.distributed._shard.sharding_plan
import torch.distributed._shard.sharding_spec
import torch.distributed._shard.sharding_spec._internals
import torch.distributed._shard.sharding_spec.api
import torch.distributed._state_dict_utils
import torch.distributed._symmetric_memory
import torch.distributed._symmetric_memory._nvshmem_triton
import torch.distributed._tensor
import torch.distributed._tensor.experimental
import torch.distributed._tensor.placement_types
import torch.distributed._tools
import torch.distributed._tools.fake_collectives
import torch.distributed._tools.fsdp2_mem_tracker
import torch.distributed._tools.ilp_utils
import torch.distributed._tools.mem_tracker
import torch.distributed._tools.mod_tracker
import torch.distributed._tools.runtime_estimator
import torch.distributed._tools.sac_estimator
import torch.distributed._tools.sac_ilp
import torch.distributed.algorithms._checkpoint.checkpoint_wrapper
import torch.distributed.algorithms._comm_hooks
import torch.distributed.algorithms._quantization.quantization
import torch.distributed.algorithms.ddp_comm_hooks
import torch.distributed.algorithms.ddp_comm_hooks.ddp_zero_hook
import torch.distributed.algorithms.ddp_comm_hooks.default_hooks
import torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook
import torch.distributed.algorithms.join
import torch.distributed.argparse_util
import torch.distributed.c10d_logger
import torch.distributed.checkpoint
import torch.distributed.checkpoint._async_process_executor
import torch.distributed.checkpoint._consolidate_hf_safetensors
import torch.distributed.checkpoint._dedup_save_plans
import torch.distributed.checkpoint._dedup_tensors
import torch.distributed.checkpoint._experimental.barriers
import torch.distributed.checkpoint._experimental.builder
import torch.distributed.checkpoint._experimental.checkpoint_process
import torch.distributed.checkpoint._experimental.checkpoint_reader
import torch.distributed.checkpoint._experimental.checkpoint_writer
import torch.distributed.checkpoint._experimental.checkpointer
import torch.distributed.checkpoint._experimental.config
import torch.distributed.checkpoint._experimental.staging
import torch.distributed.checkpoint._experimental.types
import torch.distributed.checkpoint._extension
import torch.distributed.checkpoint._fsspec_filesystem
import torch.distributed.checkpoint._hf_utils
import torch.distributed.checkpoint._nested_dict
import torch.distributed.checkpoint._pg_transport
import torch.distributed.checkpoint._state_dict_stager
import torch.distributed.checkpoint._traverse
import torch.distributed.checkpoint.api
import torch.distributed.checkpoint.default_planner
import torch.distributed.checkpoint.filesystem
import torch.distributed.checkpoint.format_utils
import torch.distributed.checkpoint.hf_storage
import torch.distributed.checkpoint.logger
import torch.distributed.checkpoint.metadata
import torch.distributed.checkpoint.optimizer
import torch.distributed.checkpoint.planner
import torch.distributed.checkpoint.planner_helpers
import torch.distributed.checkpoint.quantized_hf_storage
import torch.distributed.checkpoint.staging
import torch.distributed.checkpoint.state_dict
import torch.distributed.checkpoint.state_dict_loader
import torch.distributed.checkpoint.state_dict_saver
import torch.distributed.checkpoint.stateful
import torch.distributed.checkpoint.storage
import torch.distributed.checkpoint.utils
import torch.distributed.collective_utils
import torch.distributed.device_mesh
import torch.distributed.distributed_c10d
import torch.distributed.elastic.agent.server.api
import torch.distributed.elastic.agent.server.local_elastic_agent
import torch.distributed.elastic.control_plane
import torch.distributed.elastic.events
import torch.distributed.elastic.metrics.api
import torch.distributed.elastic.multiprocessing
import torch.distributed.elastic.multiprocessing.api
import torch.distributed.elastic.multiprocessing.errors
import torch.distributed.elastic.multiprocessing.errors.error_handler
import torch.distributed.elastic.multiprocessing.errors.handlers
import torch.distributed.elastic.multiprocessing.redirects
import torch.distributed.elastic.multiprocessing.subprocess_handler
import torch.distributed.elastic.multiprocessing.tail_log
import torch.distributed.elastic.rendezvous
import torch.distributed.elastic.rendezvous.api
import torch.distributed.elastic.rendezvous.c10d_rendezvous_backend
import torch.distributed.elastic.rendezvous.dynamic_rendezvous
import torch.distributed.elastic.rendezvous.etcd_rendezvous
import torch.distributed.elastic.rendezvous.etcd_rendezvous_backend
import torch.distributed.elastic.rendezvous.etcd_server
import torch.distributed.elastic.rendezvous.etcd_store
import torch.distributed.elastic.rendezvous.registry
import torch.distributed.elastic.rendezvous.static_tcp_rendezvous
import torch.distributed.elastic.rendezvous.utils
import torch.distributed.elastic.timer
import torch.distributed.elastic.timer.api
import torch.distributed.elastic.timer.local_timer
import torch.distributed.elastic.utils
import torch.distributed.elastic.utils.data
import torch.distributed.elastic.utils.distributed
import torch.distributed.elastic.utils.logging
import torch.distributed.elastic.utils.store
import torch.distributed.fsdp
import torch.distributed.fsdp._common_utils
import torch.distributed.fsdp._flat_param
import torch.distributed.fsdp._fully_shard._fsdp_api
import torch.distributed.fsdp._fully_shard._fsdp_collectives
import torch.distributed.fsdp._fully_shard._fsdp_common
import torch.distributed.fsdp._fully_shard._fsdp_init
import torch.distributed.fsdp._fully_shard._fsdp_param
import torch.distributed.fsdp._fully_shard._fsdp_param_group
import torch.distributed.fsdp._fully_shard._fully_shard
import torch.distributed.fsdp._init_utils
import torch.distributed.fsdp._runtime_utils
import torch.distributed.fsdp._shard_utils
import torch.distributed.fsdp._trace_utils
import torch.distributed.fsdp._traversal_utils
import torch.distributed.fsdp._unshard_param_utils
import torch.distributed.fsdp._wrap_utils
import torch.distributed.fsdp.api
import torch.distributed.fsdp.fully_sharded_data_parallel
import torch.distributed.fsdp.sharded_grad_scaler
import torch.distributed.fsdp.wrap
import torch.distributed.launch
import torch.distributed.launcher.api
import torch.distributed.nn
import torch.distributed.nn.jit
import torch.distributed.optim
import torch.distributed.optim.utils
import torch.distributed.optim.zero_redundancy_optimizer
import torch.distributed.pipelining
import torch.distributed.pipelining._backward
import torch.distributed.pipelining._utils
import torch.distributed.pipelining.microbatch
import torch.distributed.pipelining.schedules
import torch.distributed.pipelining.stage
import torch.distributed.remote_device
import torch.distributed.rpc
import torch.distributed.rpc.api
import torch.distributed.rpc.backend_registry
import torch.distributed.rpc.internal
import torch.distributed.run
import torch.distributed.tensor
import torch.distributed.tensor._api
import torch.distributed.tensor._collective_utils
import torch.distributed.tensor._dtensor_spec
import torch.distributed.tensor._op_schema
import torch.distributed.tensor._ops._common_rules
import torch.distributed.tensor._ops._einsum_strategy
import torch.distributed.tensor._ops._embedding_ops
import torch.distributed.tensor._ops._matrix_ops
import torch.distributed.tensor._ops._view_ops
import torch.distributed.tensor._ops.utils
import torch.distributed.tensor._random
import torch.distributed.tensor._redistribute
import torch.distributed.tensor._utils
import torch.distributed.tensor.debug
import torch.distributed.tensor.debug._op_coverage
import torch.distributed.tensor.experimental
import torch.distributed.tensor.experimental._attention
import torch.distributed.tensor.experimental._tp_transform
import torch.distributed.tensor.parallel
import torch.distributed.tensor.parallel.api
import torch.distributed.tensor.parallel.ddp
import torch.distributed.tensor.parallel.fsdp
import torch.distributed.tensor.parallel.input_reshard
import torch.distributed.tensor.parallel.style
import torch.distributed.tensor.placement_types
import torch.distributed.utils
import torch.distributions
import torch.distributions.binomial
import torch.distributions.constraint_registry
import torch.distributions.constraints
import torch.distributions.dirichlet
import torch.distributions.kl
import torch.distributions.transforms
import torch.distributions.utils
import torch.export
import torch.export._draft_export
import torch.export._remove_auto_functionalized_pass
import torch.export._remove_effect_tokens_pass
import torch.export._swap
import torch.export._trace
import torch.export._tree_utils
import torch.export._unlift
import torch.export.dynamic_shapes
import torch.export.experimental
import torch.export.exported_program
import torch.export.graph_signature
import torch.export.passes
import torch.export.pt2_archive._package
import torch.export.pt2_archive.constants
import torch.export.unflatten
import torch.func
import torch.functorch
import torch.futures
import torch.fx
import torch.fx._compatibility
import torch.fx._graph_pickler
import torch.fx._lazy_graph_module
import torch.fx._pytree
import torch.fx._symbolic_trace
import torch.fx.annotate
import torch.fx.experimental
import torch.fx.experimental._config
import torch.fx.experimental._dynamism
import torch.fx.experimental.accelerator_partitioner
import torch.fx.experimental.graph_gradual_typechecker
import torch.fx.experimental.meta_tracer
import torch.fx.experimental.migrate_gradual_types.constraint
import torch.fx.experimental.migrate_gradual_types.constraint_generator
import torch.fx.experimental.migrate_gradual_types.constraint_transformation
import torch.fx.experimental.migrate_gradual_types.operation
import torch.fx.experimental.migrate_gradual_types.transform_to_z3
import torch.fx.experimental.migrate_gradual_types.z3_types
import torch.fx.experimental.normalize
import torch.fx.experimental.optimization
import torch.fx.experimental.partitioner_utils
import torch.fx.experimental.proxy_tensor
import torch.fx.experimental.recording
import torch.fx.experimental.refinement_types
import torch.fx.experimental.rewriter
import torch.fx.experimental.schema_type_annotation
import torch.fx.experimental.shape_inference.infer_shape
import torch.fx.experimental.shape_inference.infer_symbol_values
import torch.fx.experimental.sym_node
import torch.fx.experimental.symbolic_shapes
import torch.fx.experimental.unify_refinements
import torch.fx.experimental.validator
import torch.fx.graph
import torch.fx.graph_module
import torch.fx.immutable_collections
import torch.fx.node
import torch.fx.operator_schemas
import torch.fx.passes
import torch.fx.passes.annotate_getitem_nodes
import torch.fx.passes.dialect.common.cse_pass
import torch.fx.passes.fake_tensor_prop
import torch.fx.passes.graph_transform_observer
import torch.fx.passes.infra.partitioner
import torch.fx.passes.infra.pass_base
import torch.fx.passes.infra.pass_manager
import torch.fx.passes.net_min_base
import torch.fx.passes.operator_support
import torch.fx.passes.param_fetch
import torch.fx.passes.reinplace
import torch.fx.passes.runtime_assert
import torch.fx.passes.shape_prop
import torch.fx.passes.split_module
import torch.fx.passes.split_utils
import torch.fx.passes.splitter_base
import torch.fx.passes.tools_common
import torch.fx.passes.utils.fuser_utils
import torch.fx.passes.utils.matcher_utils
import torch.fx.passes.utils.matcher_with_name_node_map_utils
import torch.fx.passes.utils.source_matcher_utils
import torch.fx.proxy
import torch.fx.tensor_type
import torch.fx.traceback
import torch.hub
import torch.jit
import torch.jit._logging
import torch.jit._monkeytype_config
import torch.jit._passes
import torch.jit._passes._property_propagation
import torch.jit._pickle
import torch.jit._recursive
import torch.jit.annotations
import torch.jit.frontend
import torch.jit.generate_bytecode
import torch.jit.mobile
import torch.jit.quantized
import torch.library
import torch.masked
import torch.masked.maskedtensor._ops_refs
import torch.masked.maskedtensor.binary
import torch.masked.maskedtensor.core
import torch.masked.maskedtensor.reductions
import torch.masked.maskedtensor.unary
import torch.monitor
import torch.multiprocessing
import torch.multiprocessing.reductions
import torch.nativert.backends._lower_utils
import torch.nested
import torch.nested._internal.nested_int
import torch.nested._internal.nested_tensor
import torch.nn
import torch.nn.attention
import torch.nn.attention.bias
import torch.nn.attention.experimental._paged_attention
import torch.nn.attention.flex_attention
import torch.nn.common_types
import torch.nn.functional
import torch.nn.init
import torch.nn.modules.batchnorm
import torch.nn.modules.lazy
import torch.nn.modules.linear
import torch.nn.modules.loss
import torch.nn.modules.utils
import torch.nn.parallel
import torch.nn.parallel._functions
import torch.nn.parallel.distributed
import torch.nn.parallel.scatter_gather
import torch.nn.parameter
import torch.nn.utils
import torch.nn.utils._expanded_weights
import torch.nn.utils._expanded_weights.expanded_weights_utils
import torch.nn.utils._per_sample_grad
import torch.nn.utils.fusion
import torch.nn.utils.parametrize
import torch.nn.utils.prune
import torch.nn.utils.rnn
import torch.nn.utils.stateless
import torch.numa.binding
import torch.onnx
import torch.onnx._internal._lazy_import
import torch.onnx._internal.exporter
import torch.onnx._internal.exporter._torchlib.ops
import torch.onnx._internal.fx.passes
import torch.onnx._internal.torchscript_exporter
import torch.onnx._internal.torchscript_exporter._globals
import torch.onnx._internal.torchscript_exporter._type_utils
import torch.onnx._internal.torchscript_exporter.utils
import torch.onnx.operators
import torch.onnx.ops
import torch.onnx.symbolic_helper
import torch.onnx.symbolic_opset11
import torch.ops
import torch.optim
import torch.optim.lr_scheduler
import torch.optim.optimizer
import torch.optim.swa_utils
import torch.overrides
import torch.package
import torch.package._digraph
import torch.package._mangling
import torch.package.package_exporter
import torch.profiler
import torch.profiler._pattern_matcher
import torch.quantization._quantized_conversions
import torch.quantization.observer
import torch.return_types
import torch.serialization
import torch.sparse
import torch.sparse._semi_structured_conversions
import torch.sparse._triton_ops
import torch.sparse._triton_ops_meta
import torch.torch_version
import torch.types
import torch.utils
import torch.utils._appending_byte_serializer
import torch.utils._config_module
import torch.utils._content_store
import torch.utils._cxx_pytree
import torch.utils._debug_mode
import torch.utils._device
import torch.utils._dtype_abbrs
import torch.utils._filelock
import torch.utils._get_clean_triton
import torch.utils._import_utils
import torch.utils._mode_utils
import torch.utils._ordered_set
import torch.utils._python_dispatch
import torch.utils._pytree
import torch.utils._sympy.functions
import torch.utils._sympy.interp
import torch.utils._sympy.numbers
import torch.utils._sympy.reference
import torch.utils._sympy.singleton_int
import torch.utils._sympy.solve
import torch.utils._sympy.symbol
import torch.utils._sympy.value_ranges
import torch.utils._traceback
import torch.utils._triton
import torch.utils._typing_utils
import torch.utils.benchmark
import torch.utils.benchmark.utils.compile
import torch.utils.benchmark.utils.valgrind_wrapper.timer_interface
import torch.utils.bundled_inputs
import torch.utils.checkpoint
import torch.utils.collect_env
import torch.utils.cpp_extension
import torch.utils.data
import torch.utils.data._utils
import torch.utils.data._utils.worker
import torch.utils.data.datapipes
import torch.utils.data.datapipes._hook_iterator
import torch.utils.data.datapipes._typing
import torch.utils.data.datapipes.dataframe
import torch.utils.data.datapipes.iter
import torch.utils.data.datapipes.iter.sharding
import torch.utils.data.datapipes.utils.common
import torch.utils.data.datapipes.utils.decoder
import torch.utils.data.datapipes.utils.snapshot
import torch.utils.data.dataset
import torch.utils.data.distributed
import torch.utils.data.graph
import torch.utils.data.graph_settings
import torch.utils.dlpack
import torch.utils.flop_counter
import torch.utils.hipify
import torch.utils.hooks
import torch.utils.mobile_optimizer
import torch.utils.module_tracker
import torch.utils.serialization
import torch.utils.show_pickle
import torch.utils.tensorboard
import torch.utils.tensorboard._convert_np
import torch.utils.tensorboard._pytorch_graph
import torch.utils.tensorboard._utils
import torch.utils.tensorboard.summary
import torch.utils.viz._cycles
import torch.utils.weak
import torch.version
import torch.xpu._gpu_trace
import torch_geometric
import torch_openreg
import torch_openreg._C
import torch_openreg.openreg
import torch_package_importer
import torch_test_cpp_extension
import torch_test_cpp_extension.cpp
import torch_test_cpp_extension.cuda
import torch_test_cpp_extension.maia
import torch_test_cpp_extension.mps
import torch_test_cpp_extension.rng
import torch_test_cpp_extension.sycl
import torch_test_cpp_extension.torch_library
import torch_xla
import torch_xla.core.xla_model
import torch_xla.runtime
import torchdim.magic_trace
import torchdistx
import torchgen.gen_schema_utils
import torchgen.model
import torchgen.operator_versions.gen_mobile_upgraders
import torchgen.yaml_utils
import torchrec.datasets.random
import torchrec.sparse.jagged_tensor
import torchvision
import torchvision.models
import torchvision.models.alexnet
import torchvision.models.densenet
import torchvision.models.detection
import torchvision.models.detection.roi_heads
import torchvision.models.googlenet
import torchvision.models.inception
import torchvision.models.mnasnet
import torchvision.models.mobilenet
import torchvision.models.quantization
import torchvision.models.quantization.resnet
import torchvision.models.quantization.utils
import torchvision.models.resnet
import torchvision.models.segmentation
import torchvision.models.vgg
import torchvision.models.video
import torchvision.transforms.transforms
import torchvision_models
import torch.testing
import torch.testing._comparison
import torch.testing._internal
import torch.testing._internal.autocast_test_lists
import torch.testing._internal.autograd_function_db
import torch.testing._internal.check_kernel_launches
import torch.testing._internal.common_cuda
import torch.testing._internal.common_device_type
import torch.testing._internal.common_dist_composable
import torch.testing._internal.common_distributed
import torch.testing._internal.common_dtype
import torch.testing._internal.common_fsdp
import torch.testing._internal.common_jit
import torch.testing._internal.common_methods_invocations
import torch.testing._internal.common_mkldnn
import torch.testing._internal.common_modules
import torch.testing._internal.common_mps
import torch.testing._internal.common_nn
import torch.testing._internal.common_optimizers
import torch.testing._internal.common_pruning
import torch.testing._internal.common_quantization
import torch.testing._internal.common_quantized
import torch.testing._internal.common_subclass
import torch.testing._internal.common_utils
import torch.testing._internal.custom_op_db
import torch.testing._internal.custom_tensor
import torch.testing._internal.data
import torch.testing._internal.distributed._shard.sharded_tensor
import torch.testing._internal.distributed._shard.sharded_tensor._test_ops_common
import torch.testing._internal.distributed._shard.sharded_tensor._test_st_common
import torch.testing._internal.distributed._shard.test_common
import torch.testing._internal.distributed._tensor.common_dtensor
import torch.testing._internal.distributed.checkpoint_utils
import torch.testing._internal.distributed.common_state_dict
import torch.testing._internal.distributed.distributed_test
import torch.testing._internal.distributed.distributed_utils
import torch.testing._internal.distributed.fake_pg
import torch.testing._internal.distributed.rpc.faulty_rpc_agent_test_fixture
import torch.testing._internal.distributed.rpc.tensorpipe_rpc_agent_test_fixture
import torch.testing._internal.distributed.rpc_utils
import torch.testing._internal.generated.annotated_fn_args
import torch.testing._internal.hop_db
import torch.testing._internal.hypothesis_utils
import torch.testing._internal.inductor_utils
import torch.testing._internal.jit_metaprogramming_utils
import torch.testing._internal.jit_utils
import torch.testing._internal.logging_tensor
import torch.testing._internal.logging_utils
import torch.testing._internal.opinfo
import torch.testing._internal.opinfo.core
import torch.testing._internal.opinfo.definitions.linalg
import torch.testing._internal.opinfo.definitions.nested
import torch.testing._internal.opinfo.definitions.sparse
import torch.testing._internal.opinfo.refs
import torch.testing._internal.optests
import torch.testing._internal.optests.aot_autograd
import torch.testing._internal.optests.generate_tests
import torch.testing._internal.quantization_torch_package_models
import torch.testing._internal.static_module
import torch.testing._internal.subclasses
import torch.testing._internal.test_module.future_div
import torch.testing._internal.test_module.no_future_div
import torch.testing._internal.torchbind_impls
import torch.testing._internal.triton_utils
import torch.testing._internal.two_tensor

# TORCH INTERNAL IMPORTS (torch._*)
# ---------------------------------
import torch._C
import torch._C._aoti
import torch._C._autograd
import torch._C._distributed_c10d
import torch._C._dynamo
import torch._C._dynamo.eval_frame
import torch._C._dynamo.guards
import torch._C._functorch
import torch._C._nativert
import torch._C._profiler
import torch._C._te
import torch.__future__
import torch._awaits
import torch._custom_op
import torch._custom_op.impl
import torch._custom_ops
import torch._decomp
import torch._dispatch.python
import torch._dynamo
import torch._dynamo._trace_wrapped_higher_order_op
import torch._dynamo.aot_compile
import torch._dynamo.backends
import torch._dynamo.backends.common
import torch._dynamo.backends.debugging
import torch._dynamo.backends.distributed
import torch._dynamo.backends.tvm
import torch._dynamo.bytecode_transformation
import torch._dynamo.callback
import torch._dynamo.comptime
import torch._dynamo.config
import torch._dynamo.convert_frame
import torch._dynamo.debug_utils
import torch._dynamo.decorators
import torch._dynamo.device_interface
import torch._dynamo.eval_frame
import torch._dynamo.exc
import torch._dynamo.funcname_cache
import torch._dynamo.functional_export
import torch._dynamo.graph_deduplication
import torch._dynamo.graph_region_tracker
import torch._dynamo.graph_utils
import torch._dynamo.guards
import torch._dynamo.hooks
import torch._dynamo.logging
import torch._dynamo.metrics_context
import torch._dynamo.mutation_guard
import torch._dynamo.output_graph
import torch._dynamo.package
import torch._dynamo.pgo
import torch._dynamo.polyfills
import torch._dynamo.precompile_context
import torch._dynamo.repro.after_aot
import torch._dynamo.repro.aoti
import torch._dynamo.resume_execution
import torch._dynamo.source
import torch._dynamo.symbolic_convert
import torch._dynamo.test_case
import torch._dynamo.test_dont_skip_tracing_functions
import torch._dynamo.test_minifier_common
import torch._dynamo.testing
import torch._dynamo.trace_rules
import torch._dynamo.types
import torch._dynamo.utils
import torch._dynamo.variables
import torch._dynamo.variables.builtin
import torch._dynamo.variables.higher_order_ops
import torch._dynamo.variables.lists
import torch._dynamo.variables.misc
import torch._dynamo.variables.torch_function
import torch._environment
import torch._export
import torch._export.converter
import torch._export.db.case
import torch._export.db.examples
import torch._export.non_strict_utils
import torch._export.pass_base
import torch._export.passes.lift_constants_pass
import torch._export.passes.replace_set_grad_with_hop_pass
import torch._export.passes.replace_view_ops_with_view_copy_ops_pass
import torch._export.serde.dynamic_shapes
import torch._export.serde.schema
import torch._export.serde.schema_check
import torch._export.serde.serialize
import torch._export.tools
import torch._export.utils
import torch._export.verifier
import torch._export.wrappers
import torch._functorch
import torch._functorch._activation_checkpointing.ac_logging_utils
import torch._functorch._activation_checkpointing.graph_info_provider
import torch._functorch._activation_checkpointing.knapsack_evaluator
import torch._functorch._aot_autograd
import torch._functorch._aot_autograd.autograd_cache
import torch._functorch._aot_autograd.descriptors
import torch._functorch._aot_autograd.fx_utils
import torch._functorch._aot_autograd.schemas
import torch._functorch._aot_autograd.subclass_parametrization
import torch._functorch._aot_autograd.utils
import torch._functorch.aot_autograd
import torch._functorch.compile_utils
import torch._functorch.compilers
import torch._functorch.config
import torch._functorch.deprecated
import torch._functorch.eager_transforms
import torch._functorch.make_functional
import torch._functorch.partitioners
import torch._functorch.top_operators_github_usage
import torch._functorch.utils
import torch._functorch.vmap
import torch._guards
import torch._higher_order_ops
import torch._higher_order_ops.associative_scan
import torch._higher_order_ops.auto_functionalize
import torch._higher_order_ops.cond
import torch._higher_order_ops.effects
import torch._higher_order_ops.flat_apply
import torch._higher_order_ops.flex_attention
import torch._higher_order_ops.hints_wrap
import torch._higher_order_ops.invoke_subgraph
import torch._higher_order_ops.map
import torch._higher_order_ops.out_dtype
import torch._higher_order_ops.scan
import torch._higher_order_ops.schema
import torch._higher_order_ops.torchbind
import torch._higher_order_ops.triton_kernel_wrap
import torch._higher_order_ops.utils
import torch._higher_order_ops.while_loop
import torch._higher_order_ops.wrap
import torch._inductor
import torch._inductor.analysis.profile_analysis
import torch._inductor.aoti_eager
import torch._inductor.async_compile
import torch._inductor.autoheuristic.autoheuristic
import torch._inductor.autoheuristic.autoheuristic_utils
import torch._inductor.autotune_process
import torch._inductor.bounds
import torch._inductor.choices
import torch._inductor.codecache
import torch._inductor.codegen
import torch._inductor.codegen.aoti_hipify_utils
import torch._inductor.codegen.block_analysis
import torch._inductor.codegen.common
import torch._inductor.codegen.cpp
import torch._inductor.codegen.cpp_wrapper_gpu
import torch._inductor.codegen.cuda.cuda_env
import torch._inductor.codegen.cuda.cuda_kernel
import torch._inductor.codegen.cuda.cutlass_lib_extensions.evt_extensions
import torch._inductor.codegen.cuda.cutlass_python_evt
import torch._inductor.codegen.cuda.cutlass_utils
import torch._inductor.codegen.cuda.gemm_template
import torch._inductor.codegen.cuda.serialization
import torch._inductor.codegen.cutedsl.cutedsl_kernel
import torch._inductor.codegen.cutedsl.cutedsl_op_overrides
import torch._inductor.codegen.cutedsl.cutedsl_template
import torch._inductor.codegen.halide
import torch._inductor.codegen.mps
import torch._inductor.codegen.multi_kernel
import torch._inductor.codegen.segmented_tree
import torch._inductor.codegen.simd_kernel_features
import torch._inductor.codegen.triton
import torch._inductor.codegen.wrapper
import torch._inductor.codegen.wrapper_fxir
import torch._inductor.comm_analysis
import torch._inductor.comms
import torch._inductor.compile_fx
import torch._inductor.compile_fx_async
import torch._inductor.compile_worker.subproc_pool
import torch._inductor.compiler_bisector
import torch._inductor.config
import torch._inductor.constant_folding
import torch._inductor.cpp_builder
import torch._inductor.cpu_vec_isa
import torch._inductor.cudagraph_trees
import torch._inductor.cudagraph_utils
import torch._inductor.custom_graph_pass
import torch._inductor.debug
import torch._inductor.decomposition
import torch._inductor.dependencies
import torch._inductor.exc
import torch._inductor.fuzzer
import torch._inductor.fx_passes
import torch._inductor.fx_passes.decompose_mem_bound_mm
import torch._inductor.fx_passes.group_batch_fusion
import torch._inductor.fx_passes.joint_graph
import torch._inductor.fx_passes.micro_pipeline_tp
import torch._inductor.fx_passes.misc_patterns
import torch._inductor.fx_passes.pad_mm
import torch._inductor.fx_passes.post_grad
import torch._inductor.fx_passes.pre_grad
import torch._inductor.fx_passes.reinplace
import torch._inductor.fx_utils
import torch._inductor.graph
import torch._inductor.index_propagation
import torch._inductor.inductor_prims
import torch._inductor.ir
import torch._inductor.kernel.mm
import torch._inductor.kernel.mm_common
import torch._inductor.kernel.mm_plus_mm
import torch._inductor.lowering
import torch._inductor.metrics
import torch._inductor.mock_cache
import torch._inductor.ops_handler
import torch._inductor.output_code
import torch._inductor.package
import torch._inductor.pattern_matcher
import torch._inductor.remote_cache
import torch._inductor.runtime
import torch._inductor.runtime.benchmarking
import torch._inductor.runtime.coordinate_descent_tuner
import torch._inductor.runtime.hints
import torch._inductor.runtime.runtime_utils
import torch._inductor.runtime.static_cuda_launcher
import torch._inductor.runtime.triton_compat
import torch._inductor.runtime.triton_helpers
import torch._inductor.runtime.triton_heuristics
import torch._inductor.scheduler
import torch._inductor.select_algorithm
import torch._inductor.sizevars
import torch._inductor.template_heuristics.base
import torch._inductor.template_heuristics.registry
import torch._inductor.template_heuristics.triton
import torch._inductor.test_case
import torch._inductor.test_operators
import torch._inductor.utils
import torch._inductor.virtualized
import torch._inductor.wrapper_benchmark
import torch._jit_internal
import torch._lazy
import torch._lazy.config
import torch._lazy.extract_compiled_graph
import torch._lazy.ir_cache
import torch._lazy.metrics
import torch._lazy.ts_backend
import torch._library
import torch._library.fake_class_registry
import torch._library.fake_profile
import torch._library.infer_schema
import torch._library.opaque_object
import torch._library.utils
import torch._linalg_utils
import torch._lobpcg
import torch._logging
import torch._logging._internal
import torch._logging.structured
import torch._meta_registrations
import torch._numpy
import torch._numpy._ufuncs
import torch._numpy._util
import torch._numpy.linalg
import torch._numpy.random
import torch._numpy.testing
import torch._ops
import torch._prims
import torch._prims.context
import torch._prims.debug_prims
import torch._prims.executor
import torch._prims.rng_prims
import torch._prims_common
import torch._prims_common.wrappers
import torch._python_dispatcher
import torch._refs
import torch._refs.linalg
import torch._strobelight.cli_function_profiler
import torch._strobelight.compile_time_profiler
import torch._subclasses
import torch._subclasses.fake_impls
import torch._subclasses.fake_tensor
import torch._subclasses.fake_utils
import torch._subclasses.functional_tensor
import torch._subclasses.meta_utils
import torch._subclasses.schema_check_mode
import torch._torch_docs
import torch._utils
import torch._utils_internal
import torch._vmap_internals

# SUMMARY
# -------
Main torch imports: 659
Torch internal imports: 275
Total torch imports: 934