We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
🐛 [Bug] Issue in `broadcastable` converter utility
##  Bug Description

Encountered `IndexError` in `broadcastable` utility:

```python
File "~/TensorRT/py/torch_tensorrt/dynamo/conversion/converter_utils.py", line 118, in broadcastable
     greater_tensor[i] != lesser_tensor[j]

IndexError: tuple index out of range

While executing %where_5 : [num_users=1] = call_function[target=torch.ops.aten.where.self](...)
```

## To Reproduce

Steps to reproduce the behavior:

Invoke `aten.where` converter with a 0D tensor.

## Expected behavior

Utility should not error.

## Environment

 - Torch-TensorRT Version (e.g. 1.0.0): 8c62fca7649ac2e8e74ab7d9d66a20a164e2af51
 - PyTorch Version (e.g. 1.0): `2.1.0.dev20230803+cu121`

## Additional context

Blocking compilation of #1697 with torch compile path.


--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `py/torch_tensorrt/dynamo/conversion/converter_utils.py`
Content:
```
1 import logging
2 import re
3 from typing import List, Optional
4 
5 import tensorrt as trt
6 import torch
7 from torch.fx.node import Target
8 from torch_tensorrt.fx.converters.converter_utils import (
9     Frameworks,
10     unified_dtype_converter,
11 )
12 from torch_tensorrt.fx.types import TRTDataType, TRTNetwork, TRTTensor
13 
14 from .._SourceIR import SourceIR
15 from .converter_registry import ConverterRegistry
16 
17 _LOGGER: logging.Logger = logging.getLogger(__name__)
18 
19 
20 def get_node_name(node: torch.fx.Node) -> str:
21     # nn_module_stack preserves the call stack of pytorch nn.modules
22     # The call stack contains a detailed name of the module
23     # which shows exactly where the module is located in the
24     # network architecture.
25     stack_item = node.meta.get("nn_module_stack", None)
26     # The current node is the last item in the stack
27     mod_stack = stack_item.popitem() if stack_item else ""
28     node_name = str(node)
29     if mod_stack:
30         mod_name = str(mod_stack[0]).replace("___", "/")
31         # Clean up the module name
32         mod_name = re.sub("^.*__self", "", mod_name)
33         mod_name = re.sub(r"_(\d+)$", r"/\g<1>", mod_name)
34         node_name = mod_name + "/" + node_name
35     else:
36         # Try an alternative way to get the module info
37         # like the node.meta['source_fn'] attr
38         pass
39 
40     _LOGGER.debug(f"Node meta name {node_name}")
41     return node_name
42 
43 
44 def dynamic_unsupported(node: torch.fx.Node) -> bool:
45     # Validate that none of the inputs to the node have Dynamic shapes
46     assert isinstance(
47         node, torch.fx.Node
48     ), "Inputs to validator functions must be FX Nodes"
49 
50     # Check node value itself
51     if getattr(node.meta["val"], "_has_symbolic_sizes_strides", False):
52         return False
53 
54     # Check node arguments individually
55     if any(
56         getattr(arg.meta["val"], "_has_symbolic_sizes_strides", False)
57         for arg in node.args
58         if isinstance(arg, torch.fx.Node)
59     ):
60         return False
61 
62     # Check node keyword arguments individually
63     if any(
64         getattr(kwarg.meta["val"], "_has_symbolic_sizes_strides", False)
65         for kwarg in node.kwargs.values()
66         if isinstance(kwarg, torch.fx.Node)
67     ):
68         return False
69 
70     return True
71 
72 
73 def cast_trt_tensor(
74     network: TRTNetwork,
75     input_val: TRTTensor,
76     dtype: TRTDataType,
77     name: str,
78     target: Target = "",
79     source_ir: Optional[SourceIR] = None,
80 ) -> TRTTensor:
81     """
82     Given a TRT Tensor, convert that Tensor to the specified dtype
83     Adds an Identity layer to the network which performs the conversion
84     Args:
85         network (TRTNetwork): A TensorRT network
86         input_val (TRTTensor): A TRT Tensor to cast to a new data type
87         dtype (TRTDataType, torch.dtype, np.dtype): The data type to cast the input Tensor to
88         name (str): Name of the calling layer
89         target (Target): Target of calling node
90         source_ir (SourceIR): SourceIR of calling converter
91     Returns:
92         A TensorRT ITensor which has been casted to the specified dtype
93     """
94     trt_dtype = unified_dtype_converter(dtype, Frameworks.TRT)
95 
96     if input_val.dtype != trt_dtype:
97         source_ir = source_ir if source_ir is not None else SourceIR.UNKNOWN
98         target_str = ConverterRegistry.qualified_name_or_str(target)
99         target_name = f"{source_ir}_ops{('.' + target_str) if target_str else ''}"
100 
101         identity_layer = network.add_identity(input_val)
102         identity_layer.set_output_type(0, trt_dtype)
103         identity_layer.name = f"Cast ITensor {input_val.name} from {input_val.dtype} to {trt_dtype} - [{target_name}]-[{name}]"
104         return identity_layer.get_output(0)
105     else:
106         return input_val
107 
108 
109 def cast_int_int_div_trt_tensor(
110     network: TRTNetwork,
111     lhs_val: TRTTensor,
112     rhs_val: TRTTensor,
113     name: str,
114 ) -> List[TRTTensor]:
115     """
116     Given two `int` data type TRT Tensor to div operation, cast the TRT Tensor to float type
117     Args:
118         network (TRTNetwork): A TensorRT network
119         lhs_val (TRTTensor): A TRT Tensor numerator
120         rhs_val (TRTTensor): A TRT Tensor numerator
121         name (str): Name of calling layer
122     Returns:
123         A list of lhs_val and rhs_val casted to the approriate datatype
124     """
125     if (lhs_val.dtype == trt.int8 or lhs_val.dtype == trt.int32) and (
126         rhs_val.dtype == trt.int8 or rhs_val.dtype == trt.int32
127     ):
128         lhs_val = cast_trt_tensor(network, lhs_val, trt.float32, name)
129         rhs_val = cast_trt_tensor(network, rhs_val, trt.float32, name)
130     return [lhs_val, rhs_val]
131 
132 
133 def broadcastable(
134     a: TRTTensor,
135     b: TRTTensor,
136 ) -> bool:
137     "Check if two tensors are broadcastable according to torch rules"
138     a_shape = tuple(a.shape)
139     b_shape = tuple(b.shape)
140     # check from the trailing
141     diff = len(a_shape) - len(b_shape)
142     if diff == 0:
143         return True
144     if diff > 0:
145         max = len(a_shape)
146         min = len(b_shape)
147         greater_tensor = a_shape
148         lesser_tensor = b_shape
149     elif diff < 0:
150         max = len(b_shape)
151         min = len(a_shape)
152         greater_tensor = b_shape
153         lesser_tensor = a_shape
154     j = min - 1
155     for i in range(max - 1, diff - 1, -1):
156         if not (
157             greater_tensor[i] != lesser_tensor[j]
158             and (greater_tensor[i] == 1 or lesser_tensor[i] == 1)
159         ):
160             return False
161     return True
162
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/py/torch_tensorrt/dynamo/conversion/converter_utils.py b/py/torch_tensorrt/dynamo/conversion/converter_utils.py
--- a/py/torch_tensorrt/dynamo/conversion/converter_utils.py
+++ b/py/torch_tensorrt/dynamo/conversion/converter_utils.py
@@ -137,25 +137,23 @@
     "Check if two tensors are broadcastable according to torch rules"
     a_shape = tuple(a.shape)
     b_shape = tuple(b.shape)
+
     # check from the trailing
     diff = len(a_shape) - len(b_shape)
-    if diff == 0:
+
+    # Validate tensors have same rank and shape
+    if diff == 0 and all(a_shape[i] == b_shape[i] for i in range(len(a_shape))):
         return True
+
+    # Left-pad the shorter dimension with ones
     if diff > 0:
-        max = len(a_shape)
-        min = len(b_shape)
-        greater_tensor = a_shape
-        lesser_tensor = b_shape
-    elif diff < 0:
-        max = len(b_shape)
-        min = len(a_shape)
-        greater_tensor = b_shape
-        lesser_tensor = a_shape
-    j = min - 1
-    for i in range(max - 1, diff - 1, -1):
-        if not (
-            greater_tensor[i] != lesser_tensor[j]
-            and (greater_tensor[i] == 1 or lesser_tensor[i] == 1)
-        ):
+        b_shape = (1,) * abs(diff) + b_shape
+    else:
+        a_shape = (1,) * abs(diff) + a_shape
+
+    # Validate one of the following conditions for broadcastability per-dimension
+    # 1. Equal number of dimensions or 2. Dimension has shape 1
+    for i in range(len(a_shape)):
+        if not (a_shape[i] == b_shape[i] or a_shape[i] == 1 or b_shape[i] == 1):
             return False
     return True

{"golden_diff": "diff --git a/py/torch_tensorrt/dynamo/conversion/converter_utils.py b/py/torch_tensorrt/dynamo/conversion/converter_utils.py\n--- a/py/torch_tensorrt/dynamo/conversion/converter_utils.py\n+++ b/py/torch_tensorrt/dynamo/conversion/converter_utils.py\n@@ -137,25 +137,23 @@\n     \"Check if two tensors are broadcastable according to torch rules\"\n     a_shape = tuple(a.shape)\n     b_shape = tuple(b.shape)\n+\n     # check from the trailing\n     diff = len(a_shape) - len(b_shape)\n-    if diff == 0:\n+\n+    # Validate tensors have same rank and shape\n+    if diff == 0 and all(a_shape[i] == b_shape[i] for i in range(len(a_shape))):\n         return True\n+\n+    # Left-pad the shorter dimension with ones\n     if diff > 0:\n-        max = len(a_shape)\n-        min = len(b_shape)\n-        greater_tensor = a_shape\n-        lesser_tensor = b_shape\n-    elif diff < 0:\n-        max = len(b_shape)\n-        min = len(a_shape)\n-        greater_tensor = b_shape\n-        lesser_tensor = a_shape\n-    j = min - 1\n-    for i in range(max - 1, diff - 1, -1):\n-        if not (\n-            greater_tensor[i] != lesser_tensor[j]\n-            and (greater_tensor[i] == 1 or lesser_tensor[i] == 1)\n-        ):\n+        b_shape = (1,) * abs(diff) + b_shape\n+    else:\n+        a_shape = (1,) * abs(diff) + a_shape\n+\n+    # Validate one of the following conditions for broadcastability per-dimension\n+    # 1. Equal number of dimensions or 2. Dimension has shape 1\n+    for i in range(len(a_shape)):\n+        if not (a_shape[i] == b_shape[i] or a_shape[i] == 1 or b_shape[i] == 1):\n             return False\n     return True\n", "issue": "\ud83d\udc1b [Bug] Issue in `broadcastable` converter utility\n##  Bug Description\r\n\r\nEncountered `IndexError` in `broadcastable` utility:\r\n\r\n```python\r\nFile \"~/TensorRT/py/torch_tensorrt/dynamo/conversion/converter_utils.py\", line 118, in broadcastable\r\n     greater_tensor[i] != lesser_tensor[j]\r\n\r\nIndexError: tuple index out of range\r\n\r\nWhile executing %where_5 : [num_users=1] = call_function[target=torch.ops.aten.where.self](...)\r\n```\r\n\r\n## To Reproduce\r\n\r\nSteps to reproduce the behavior:\r\n\r\nInvoke `aten.where` converter with a 0D tensor.\r\n\r\n## Expected behavior\r\n\r\nUtility should not error.\r\n\r\n## Environment\r\n\r\n - Torch-TensorRT Version (e.g. 1.0.0): 8c62fca7649ac2e8e74ab7d9d66a20a164e2af51\r\n - PyTorch Version (e.g. 1.0): `2.1.0.dev20230803+cu121`\r\n\r\n## Additional context\r\n\r\nBlocking compilation of #1697 with torch compile path.\r\n\n", "before_files": [{"content": "import logging\nimport re\nfrom typing import List, Optional\n\nimport tensorrt as trt\nimport torch\nfrom torch.fx.node import Target\nfrom torch_tensorrt.fx.converters.converter_utils import (\n    Frameworks,\n    unified_dtype_converter,\n)\nfrom torch_tensorrt.fx.types import TRTDataType, TRTNetwork, TRTTensor\n\nfrom .._SourceIR import SourceIR\nfrom .converter_registry import ConverterRegistry\n\n_LOGGER: logging.Logger = logging.getLogger(__name__)\n\n\ndef get_node_name(node: torch.fx.Node) -> str:\n    # nn_module_stack preserves the call stack of pytorch nn.modules\n    # The call stack contains a detailed name of the module\n    # which shows exactly where the module is located in the\n    # network architecture.\n    stack_item = node.meta.get(\"nn_module_stack\", None)\n    # The current node is the last item in the stack\n    mod_stack = stack_item.popitem() if stack_item else \"\"\n    node_name = str(node)\n    if mod_stack:\n        mod_name = str(mod_stack[0]).replace(\"___\", \"/\")\n        # Clean up the module name\n        mod_name = re.sub(\"^.*__self\", \"\", mod_name)\n        mod_name = re.sub(r\"_(\\d+)$\", r\"/\\g<1>\", mod_name)\n        node_name = mod_name + \"/\" + node_name\n    else:\n        # Try an alternative way to get the module info\n        # like the node.meta['source_fn'] attr\n        pass\n\n    _LOGGER.debug(f\"Node meta name {node_name}\")\n    return node_name\n\n\ndef dynamic_unsupported(node: torch.fx.Node) -> bool:\n    # Validate that none of the inputs to the node have Dynamic shapes\n    assert isinstance(\n        node, torch.fx.Node\n    ), \"Inputs to validator functions must be FX Nodes\"\n\n    # Check node value itself\n    if getattr(node.meta[\"val\"], \"_has_symbolic_sizes_strides\", False):\n        return False\n\n    # Check node arguments individually\n    if any(\n        getattr(arg.meta[\"val\"], \"_has_symbolic_sizes_strides\", False)\n        for arg in node.args\n        if isinstance(arg, torch.fx.Node)\n    ):\n        return False\n\n    # Check node keyword arguments individually\n    if any(\n        getattr(kwarg.meta[\"val\"], \"_has_symbolic_sizes_strides\", False)\n        for kwarg in node.kwargs.values()\n        if isinstance(kwarg, torch.fx.Node)\n    ):\n        return False\n\n    return True\n\n\ndef cast_trt_tensor(\n    network: TRTNetwork,\n    input_val: TRTTensor,\n    dtype: TRTDataType,\n    name: str,\n    target: Target = \"\",\n    source_ir: Optional[SourceIR] = None,\n) -> TRTTensor:\n    \"\"\"\n    Given a TRT Tensor, convert that Tensor to the specified dtype\n    Adds an Identity layer to the network which performs the conversion\n    Args:\n        network (TRTNetwork): A TensorRT network\n        input_val (TRTTensor): A TRT Tensor to cast to a new data type\n        dtype (TRTDataType, torch.dtype, np.dtype): The data type to cast the input Tensor to\n        name (str): Name of the calling layer\n        target (Target): Target of calling node\n        source_ir (SourceIR): SourceIR of calling converter\n    Returns:\n        A TensorRT ITensor which has been casted to the specified dtype\n    \"\"\"\n    trt_dtype = unified_dtype_converter(dtype, Frameworks.TRT)\n\n    if input_val.dtype != trt_dtype:\n        source_ir = source_ir if source_ir is not None else SourceIR.UNKNOWN\n        target_str = ConverterRegistry.qualified_name_or_str(target)\n        target_name = f\"{source_ir}_ops{('.' + target_str) if target_str else ''}\"\n\n        identity_layer = network.add_identity(input_val)\n        identity_layer.set_output_type(0, trt_dtype)\n        identity_layer.name = f\"Cast ITensor {input_val.name} from {input_val.dtype} to {trt_dtype} - [{target_name}]-[{name}]\"\n        return identity_layer.get_output(0)\n    else:\n        return input_val\n\n\ndef cast_int_int_div_trt_tensor(\n    network: TRTNetwork,\n    lhs_val: TRTTensor,\n    rhs_val: TRTTensor,\n    name: str,\n) -> List[TRTTensor]:\n    \"\"\"\n    Given two `int` data type TRT Tensor to div operation, cast the TRT Tensor to float type\n    Args:\n        network (TRTNetwork): A TensorRT network\n        lhs_val (TRTTensor): A TRT Tensor numerator\n        rhs_val (TRTTensor): A TRT Tensor numerator\n        name (str): Name of calling layer\n    Returns:\n        A list of lhs_val and rhs_val casted to the approriate datatype\n    \"\"\"\n    if (lhs_val.dtype == trt.int8 or lhs_val.dtype == trt.int32) and (\n        rhs_val.dtype == trt.int8 or rhs_val.dtype == trt.int32\n    ):\n        lhs_val = cast_trt_tensor(network, lhs_val, trt.float32, name)\n        rhs_val = cast_trt_tensor(network, rhs_val, trt.float32, name)\n    return [lhs_val, rhs_val]\n\n\ndef broadcastable(\n    a: TRTTensor,\n    b: TRTTensor,\n) -> bool:\n    \"Check if two tensors are broadcastable according to torch rules\"\n    a_shape = tuple(a.shape)\n    b_shape = tuple(b.shape)\n    # check from the trailing\n    diff = len(a_shape) - len(b_shape)\n    if diff == 0:\n        return True\n    if diff > 0:\n        max = len(a_shape)\n        min = len(b_shape)\n        greater_tensor = a_shape\n        lesser_tensor = b_shape\n    elif diff < 0:\n        max = len(b_shape)\n        min = len(a_shape)\n        greater_tensor = b_shape\n        lesser_tensor = a_shape\n    j = min - 1\n    for i in range(max - 1, diff - 1, -1):\n        if not (\n            greater_tensor[i] != lesser_tensor[j]\n            and (greater_tensor[i] == 1 or lesser_tensor[i] == 1)\n        ):\n            return False\n    return True\n", "path": "py/torch_tensorrt/dynamo/conversion/converter_utils.py"}], "after_files": [{"content": "import logging\nimport re\nfrom typing import List, Optional\n\nimport tensorrt as trt\nimport torch\nfrom torch.fx.node import Target\nfrom torch_tensorrt.fx.converters.converter_utils import (\n    Frameworks,\n    unified_dtype_converter,\n)\nfrom torch_tensorrt.fx.types import TRTDataType, TRTNetwork, TRTTensor\n\nfrom .._SourceIR import SourceIR\nfrom .converter_registry import ConverterRegistry\n\n_LOGGER: logging.Logger = logging.getLogger(__name__)\n\n\ndef get_node_name(node: torch.fx.Node) -> str:\n    # nn_module_stack preserves the call stack of pytorch nn.modules\n    # The call stack contains a detailed name of the module\n    # which shows exactly where the module is located in the\n    # network architecture.\n    stack_item = node.meta.get(\"nn_module_stack\", None)\n    # The current node is the last item in the stack\n    mod_stack = stack_item.popitem() if stack_item else \"\"\n    node_name = str(node)\n    if mod_stack:\n        mod_name = str(mod_stack[0]).replace(\"___\", \"/\")\n        # Clean up the module name\n        mod_name = re.sub(\"^.*__self\", \"\", mod_name)\n        mod_name = re.sub(r\"_(\\d+)$\", r\"/\\g<1>\", mod_name)\n        node_name = mod_name + \"/\" + node_name\n    else:\n        # Try an alternative way to get the module info\n        # like the node.meta['source_fn'] attr\n        pass\n\n    _LOGGER.debug(f\"Node meta name {node_name}\")\n    return node_name\n\n\ndef dynamic_unsupported(node: torch.fx.Node) -> bool:\n    # Validate that none of the inputs to the node have Dynamic shapes\n    assert isinstance(\n        node, torch.fx.Node\n    ), \"Inputs to validator functions must be FX Nodes\"\n\n    # Check node value itself\n    if getattr(node.meta[\"val\"], \"_has_symbolic_sizes_strides\", False):\n        return False\n\n    # Check node arguments individually\n    if any(\n        getattr(arg.meta[\"val\"], \"_has_symbolic_sizes_strides\", False)\n        for arg in node.args\n        if isinstance(arg, torch.fx.Node)\n    ):\n        return False\n\n    # Check node keyword arguments individually\n    if any(\n        getattr(kwarg.meta[\"val\"], \"_has_symbolic_sizes_strides\", False)\n        for kwarg in node.kwargs.values()\n        if isinstance(kwarg, torch.fx.Node)\n    ):\n        return False\n\n    return True\n\n\ndef cast_trt_tensor(\n    network: TRTNetwork,\n    input_val: TRTTensor,\n    dtype: TRTDataType,\n    name: str,\n    target: Target = \"\",\n    source_ir: Optional[SourceIR] = None,\n) -> TRTTensor:\n    \"\"\"\n    Given a TRT Tensor, convert that Tensor to the specified dtype\n    Adds an Identity layer to the network which performs the conversion\n    Args:\n        network (TRTNetwork): A TensorRT network\n        input_val (TRTTensor): A TRT Tensor to cast to a new data type\n        dtype (TRTDataType, torch.dtype, np.dtype): The data type to cast the input Tensor to\n        name (str): Name of the calling layer\n        target (Target): Target of calling node\n        source_ir (SourceIR): SourceIR of calling converter\n    Returns:\n        A TensorRT ITensor which has been casted to the specified dtype\n    \"\"\"\n    trt_dtype = unified_dtype_converter(dtype, Frameworks.TRT)\n\n    if input_val.dtype != trt_dtype:\n        source_ir = source_ir if source_ir is not None else SourceIR.UNKNOWN\n        target_str = ConverterRegistry.qualified_name_or_str(target)\n        target_name = f\"{source_ir}_ops{('.' + target_str) if target_str else ''}\"\n\n        identity_layer = network.add_identity(input_val)\n        identity_layer.set_output_type(0, trt_dtype)\n        identity_layer.name = f\"Cast ITensor {input_val.name} from {input_val.dtype} to {trt_dtype} - [{target_name}]-[{name}]\"\n        return identity_layer.get_output(0)\n    else:\n        return input_val\n\n\ndef cast_int_int_div_trt_tensor(\n    network: TRTNetwork,\n    lhs_val: TRTTensor,\n    rhs_val: TRTTensor,\n    name: str,\n) -> List[TRTTensor]:\n    \"\"\"\n    Given two `int` data type TRT Tensor to div operation, cast the TRT Tensor to float type\n    Args:\n        network (TRTNetwork): A TensorRT network\n        lhs_val (TRTTensor): A TRT Tensor numerator\n        rhs_val (TRTTensor): A TRT Tensor numerator\n        name (str): Name of calling layer\n    Returns:\n        A list of lhs_val and rhs_val casted to the approriate datatype\n    \"\"\"\n    if (lhs_val.dtype == trt.int8 or lhs_val.dtype == trt.int32) and (\n        rhs_val.dtype == trt.int8 or rhs_val.dtype == trt.int32\n    ):\n        lhs_val = cast_trt_tensor(network, lhs_val, trt.float32, name)\n        rhs_val = cast_trt_tensor(network, rhs_val, trt.float32, name)\n    return [lhs_val, rhs_val]\n\n\ndef broadcastable(\n    a: TRTTensor,\n    b: TRTTensor,\n) -> bool:\n    \"Check if two tensors are broadcastable according to torch rules\"\n    a_shape = tuple(a.shape)\n    b_shape = tuple(b.shape)\n\n    # check from the trailing\n    diff = len(a_shape) - len(b_shape)\n\n    # Validate tensors have same rank and shape\n    if diff == 0 and all(a_shape[i] == b_shape[i] for i in range(len(a_shape))):\n        return True\n\n    # Left-pad the shorter dimension with ones\n    if diff > 0:\n        b_shape = (1,) * abs(diff) + b_shape\n    else:\n        a_shape = (1,) * abs(diff) + a_shape\n\n    # Validate one of the following conditions for broadcastability per-dimension\n    # 1. Equal number of dimensions or 2. Dimension has shape 1\n    for i in range(len(a_shape)):\n        if not (a_shape[i] == b_shape[i] or a_shape[i] == 1 or b_shape[i] == 1):\n            return False\n    return True\n", "path": "py/torch_tensorrt/dynamo/conversion/converter_utils.py"}]}