code: def backward_impl(self, inputs, outputs, propagate_down, accum):
      g_dx0 = nn.Variable(outputs[0].shape).apply(data=outputs[0].grad)
      g_db0 = nn.Variable(outputs[1].shape).apply(data=outputs[1].grad)
      g_dg0 = nn.Variable(outputs[2].shape).apply(data=outputs[2].grad)
      g_dz0 = (
          nn.Variable(outputs[3].shape).apply(data=outputs[3].grad)
          if self._is_add
          else None
      )
      dy = nn.Variable(inputs[0].shape).apply(
          data=inputs[0].data, need_grad=True
      )
      x0 = nn.Variable(inputs[1].shape).apply(
          data=inputs[1].data, need_grad=True
      )
      b0 = nn.Variable(inputs[2].shape).apply(
          data=inputs[2].data, need_grad=True
      )
      g0 = nn.Variable(inputs[3].shape).apply(
          data=inputs[3].data, need_grad=True
      )
      rm = nn.Variable(inputs[4].shape).apply(data=inputs[4].data)
      rv = nn.Variable(inputs[5].shape).apply(data=inputs[5].data)
      y0 = nn.Variable(inputs[6].shape).apply(data=inputs[6].data)
      z0 = (
          nn.Variable(inputs[7].shape).apply(
              data=inputs[7].data, need_grad=True
          )
          if self._is_add
          else None
      )
  
      with nn.auto_forward():
          g_dy_, g_x0_, g_b0_, g_g0_ = double_backward(
              g_dx0,
              g_db0,
              g_dg0,
              g_dz0,
              dy,
              x0,
              b0,
              g0,
              rm,
              rv,
              y0,
              z0,
              self.axes,
              self.decay_rate,
              self.eps,
              self.nonlinearity,
              self.batch_stat,
          )
      g_dy = inputs[0].grad
      g_x0 = inputs[1].grad
      g_g0 = inputs[3].grad
      g_z0 = inputs[7].grad if self._is_add else None
      # wrt dy
      if propagate_down[0]:
          if accum[0]:
              g_dy += g_dy_.data
          else:
              g_dy.copy_from(g_dy_.data)
      # wrt x
      if propagate_down[1]:
          if accum[1]:
              g_x0 += g_x0_.data
          else:
              g_x0.copy_from(g_x0_.data)
      # wrt g
      if propagate_down[3]:
          if accum[3]:
              g_g0 += g_g0_.data
          else:
              g_g0.copy_from(g_g0_.data)
  
imports: import nnabla
  import nnabla.function
  import nnabla.functions
  from nnabla.function import PythonFunction
  from .batch_normalization import double_backward_for_batch
  from .batch_normalization import double_backward_for_global
  from .utils import no_grad
label_desc: Use image node_id 13 for calling the FusedBatchNormalizationBackward obj's underlying member method code with example usage: obj.backward_impl(inputs, outputs, propagate_down, accum) without return types