def _first_call_op_prepare_before_hook_create_subgraphs(
        self,
        op: Callable,
        args: Tuple[Any, ...],
        kwargs: Dict[str, Any],
        qtensor_id: List[int],
        fqn: str,
        root_module: torch.nn.Module,
        op_quantizeability_type: OpQuantizeabilityType,
    ) -> Tuple[Tuple[Any, ...], Dict[str, Any]]:
        """
        Given an op, args, kwargs about to be executed, records the subgraph
        of this op in `self`.
        """
        arg_tensor_infos: List[Optional[QTensorInfo]] = []
        arg_tensor_force_inf_dtype: List[Optional[torch.dtype]] = []
        for arg in args:
            if isinstance(arg, (list, tuple)):
                for inner_arg in arg:
                    self._first_call_op_prepare_before_hook_create_subgraphs_tensor(
                        op,
                        inner_arg,
                        arg_tensor_infos,
                        arg_tensor_force_inf_dtype,
                        qtensor_id,
                    )
            else:
                self._first_call_op_prepare_before_hook_create_subgraphs_tensor(
                    op, arg, arg_tensor_infos, arg_tensor_force_inf_dtype, qtensor_id
                )

        if op_quantizeability_type is OpQuantizeabilityType.NOT_QUANTIZEABLE:
            op_type_is_module = isinstance(op, torch.nn.Module)
            op_type: Callable = type(op) if op_type_is_module else op  # type: ignore[assignment]
            self.seen_nonq_op_infos.append(
                SeenNonQOpInfo(str(op_type), fqn, arg_tensor_infos, [])
            )
            return args, kwargs

        if self.idx not in self.idx_to_seen_q_op_infos:
            op_type_is_module = isinstance(op, torch.nn.Module)
            op_type = type(op) if op_type_is_module else op  # type: ignore[assignment]
            weight_tensor_infos = []
            weight_idx = 0
            if type(op) in quantized_modules_has_weights:
                if isinstance(op, (torch.nn.LSTM, MergedEmbeddingBagWithCat)):
                    if isinstance(op, torch.nn.LSTM):
                        weights = op._flat_weights
                    else:
                        weights = op.weights
                    for i in range(len(weights)):
                        weight_tensor_infos.append(
                            QTensorInfo(
                                weight_idx,
                                weights[weight_idx].dtype,
                                weights[weight_idx].dtype,
                            )
                        )
                        weight_idx += 1
                else:
                    weight_tensor_infos.append(
                        QTensorInfo(weight_idx, op.weight.dtype, op.weight.dtype)
                    )
            self.idx_to_seen_q_op_infos[self.idx] = SeenQOpInfo(
                self.idx,
                str(op_type),
                op_type_is_module,
                fqn,
                arg_tensor_infos,
                arg_tensor_force_inf_dtype,
                [],
                [],
                weight_tensor_infos,
                self.qconfig,
            )
        return args, kwargs

        Given an op, args, kwargs about to be executed, records the subgraph
        of this op in `self`.
        
intel_extension_for_pytorch/quantization/_quantization_state.py