code: def _conv_backward_flop_jit(
      inputs: Tuple[Any], outputs: Tuple[Any]
  ) -> Number:
      grad_out_shape, x_shape, w_shape = [i.shape for i in inputs[:3]]
      output_mask = inputs[-1]
      fwd_transposed = inputs[7]
      flop_count: Number = 0
  
      if output_mask[0]:
          grad_input_shape = outputs[0].shape
          # pyre-ignore [58] this is actually sum of Number and Number
          flop_count = flop_count + _conv_flop_count(
              grad_out_shape,
              w_shape,
              grad_input_shape,
              not fwd_transposed,
          )
      if output_mask[1]:
          grad_weight_shape = outputs[1].shape
          flop_count += _conv_flop_count(
              list(_transpose_shape(x_shape)),
              list(grad_out_shape),
              list(grad_weight_shape),
              fwd_transposed,
          )
  
      return flop_count
  
imports: import logging
  import operator
  from collections import defaultdict
  from functools import reduce
  from numbers import Number
  from typing import Any, Callable, DefaultDict, Dict, List, Tuple
  import torch
  from torch.utils._python_dispatch import TorchDispatchMode
  from torch.utils._pytree import PyTree, tree_map
label_desc: Use image node_id 7 for calling a global function with example usage: _conv_backward_flop_jit(inputs, outputs) and returns: flop_count