text: import sys
  sys.path.insert(0, '../../')
  
  #  import torch
  #  import torch.nn as nn
  import oneflow as of
  import oneflow.nn as nn
  #  from typing import Type, Any, Callable, Union, List, Optional
  
  from libs.components.conv import conv3x3, conv1x1
  
  class ResidualBasicBlock(nn.Module):
      expansion: int = 1
      def __init__(
          self,
          inplanes: int,
          planes: int,
          stride: int = 1,
          downsample: Optional[nn.Module] = None,
          groups: int = 1,
          base_width: int = 64,
          dilation: int = 1,
          norm_layer: Optional[Callable[..., nn.Module]] = None
      ) -> None:
          super(ResidualBasicBlock, self).__init__()
          if norm_layer is None:
              norm_layer = nn.BatchNorm2d
          if groups != 1 or base_width != 64:
              raise ValueError('BasicBlock only supports groups=1 and base_width=64')
          if dilation > 1:
              raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
          # Both self.conv1 and self.downsample layers downsample the input when stride != 1
          self.conv1 = conv3x3(inplanes, planes, stride)
          self.bn1 = norm_layer(planes)
          self.relu = nn.ReLU(inplace=True)
          self.conv2 = conv3x3(planes, planes)
          self.bn2 = norm_layer(planes)
          self.downsample = downsample
          self.stride = stride
  
      def forward(self, x):
          identity = x
  
          out = self.conv1(x)
          out = self.bn1(out)
          out = self.relu(out)
  
          out = self.conv2(out)
          out = self.bn2(out)
  
          if self.downsample is not None:
              identity = self.downsample(x)
  
          out += identity
          out = self.relu(out)
  
          return out
  