code: def _loc_inner(self, ta, tb, out):
      # Expect to have ta < tb
  
      # First, we (this interval) only have jurisdiction over [self._start, self._end]. So if we're asked for
      # something outside of that then we pass the buck up to our parent, who is strictly larger.
      if ta < self._start or tb > self._end:
          raise trampoline.TailCall(
              self._parent._loc_inner(ta, tb, out)
          )
  
      # If it's us that's being asked for, then we add ourselves on to out and return.
      if ta == self._start and tb == self._end:
          out.append(self)
          return
  
      # If we've got this far then we know that it's an interval that's within our jurisdiction, and that it's not us.
      # So next we check if it's up to us to figure out, or up to our children.
      if self._midway is None:
          # It's up to us. Create subintervals (_split) if appropriate.
          if ta == self._start:
              self._split(tb)
              raise trampoline.TailCall(
                  self._left_child._loc_inner(ta, tb, out)
              )
          # implies ta > self._start
          self._split(ta)
          # Query our (newly created) right_child: if tb == self._end then our right child will be the result, and it
          # will tell us so. But if tb < self._end then our right_child will need to make another split of its own.
          raise trampoline.TailCall(
              self._right_child._loc_inner(ta, tb, out)
          )
  
      # If we're here then we have children: self._midway is not None
      if tb <= self._midway:
          # Strictly our left_child's problem
          raise trampoline.TailCall(
              self._left_child._loc_inner(ta, tb, out)
          )
      if ta >= self._midway:
          # Strictly our right_child's problem
          raise trampoline.TailCall(
              self._right_child._loc_inner(ta, tb, out)
          )
      # It's a problem for both of our children: the requested interval overlaps our midpoint. Call the left_child
      # first (to append to out in the correct order), then call our right child.
      # (Implies ta < self._midway < tb)
      yield self._left_child._loc_inner(ta, self._midway, out)
      raise trampoline.TailCall(
          self._right_child._loc_inner(self._midway, tb, out)
      )
  
imports: import math
  import trampoline
  import warnings
  import numpy
  import torch
  from .None import brownian_base
  from ..settings import LEVY_AREA_APPROXIMATIONS
  from ..types import Scalar, Optional, Tuple, Union, Tensor
label_desc: Use image node_id 8 for calling the _Interval obj's underlying member method code with example usage: obj._loc_inner(ta, tb, out) without return types