def method_initialize(self, space, args_w):
     if len(args_w) == 1:
         address = Coerce.ffi_address(space, args_w[0])
         return self._initialize(space, address)
     elif len(args_w) == 2:
         sizeof_type = Coerce.int(space, args_w[0])
         address = Coerce.ffi_address(space, args_w[1])
         return self._initialize(space, address, sizeof_type)

 def method_sub(self, space, w_other):
     if isinstance(w_other, W_TimeObject):
         return space.newfloat(
             self.epoch_seconds - Coerce.float(space, w_other))
     else:
         w_time = space.send(space.getclassfor(W_TimeObject), "allocate")
         w_time._set_epoch_seconds(
             self.epoch_seconds - Coerce.float(space, w_other))
         w_time._set_offset(self.offset)
         return w_time

 def method_match(self, space, w_s, w_offset=None):
     if w_s is space.w_nil:
         return space.w_nil
     s = Coerce.str(space, w_s)
     if w_offset is not None:
         offset = Coerce.int(space, w_offset)
     else:
         offset = 0
     ctx = self.make_ctx(s, offset)
     matched = rsre_core.search_context(ctx)
     return self.get_match_result(space, ctx, s, matched)

 def method_at(self, space, w_time, w_microtime=None):
     if not (w_time.is_kind_of(space, space.w_numeric) or
             w_time.is_kind_of(space, space.getclassfor(W_TimeObject))):
         raise space.error(space.w_TypeError)
     if w_microtime is not None:
         microtime = Coerce.float(space, w_microtime) * 0.000001
     else:
         microtime = 0.0
     timestamp = Coerce.float(space, w_time)
     w_time = space.send(self, "new")
     w_time._set_epoch_seconds(timestamp + microtime)
     return w_time

def coerce_address(space, w_addressable):
    if space.is_kind_of(w_addressable, space.w_bignum):
        return Coerce.int(space, w_addressable)
    elif space.is_kind_of(w_addressable, space.w_fixnum):
        return Coerce.int(space, w_addressable)
    elif space.is_kind_of(w_addressable,
                          space.getclassfor(W_PointerObject)):
        w_address = space.send(w_addressable, 'address')
        return coerce_address(space, w_address)
    else:
        errmsg = ("can't convert %s into FFI::Pointer" %
                  space.getclass(w_addressable).name)
        raise space.error(space.w_TypeError, errmsg)

 def _rand_int(self, space, integer):
     random = self.random.random()
     max = Coerce.int(space, integer)
     if max <= 0:
         raise space.error(space.w_ArgumentError, "invalid argument")
     else:
         return space.newint(int(random * max))

 def method_pack(self, space, w_template):
     template = Coerce.str(space, w_template)
     result = RPacker(template, space.listview(self)).operate(space)
     w_result = space.newstr_fromchars(result)
     if space.is_true(space.send(w_template, "tainted?")):
         space.send(w_result, "taint")
     return w_result

 def method_sleep(self, space, w_duration=None):
     if w_duration is None:
         raise space.error(space.w_NotImplementedError)
     elif space.is_kind_of(w_duration, space.w_string):
         raise space.error(space.w_TypeError, "can't convert String into time interval")
     start = time.time()
     time.sleep(Coerce.float(space, w_duration))
     return space.newint(int(round_double(time.time() - start, 0)))

 def method_plus(self, space, w_other):
     if isinstance(w_other, W_TimeObject):
         raise space.error(space.w_TypeError, "time + time?")
     w_time = space.send(space.getclassfor(W_TimeObject), "allocate")
     w_time._set_epoch_seconds(
         self.epoch_seconds + Coerce.float(space, w_other))
     w_time._set_offset(self.offset)
     return w_time

 def wrapper(self, space, args_w):
     if len(args_w) == 2:
         w_value1, w_value2 = args_w
     else:
         # delegate and hope that the gateway will raise an
         # ArgumentError
         args = [Coerce.float(space, w_arg) for w_arg in args_w]
         return func(self, space, args)
     if space.is_kind_of(w_value1, space.w_numeric):
         if space.is_kind_of(w_value2, space.w_numeric):
             value1 = Coerce.float(space, w_value1)
             value2 = Coerce.int(space, w_value2)
             return func(self, space, value1, value2)
         else:
             raise_type_error(space, w_value2)
     else:
         raise_type_error(space, w_value1)

 def singleton_method_chmod(self, space, mode, args_w):
     for arg_w in args_w:
         path = Coerce.path(space, arg_w)
         try:
             os.chmod(path, mode)
         except OSError as e:
             raise error_for_oserror(space, e)
     return space.newint(len(args_w))

 def singleton_method_delete(self, space, args_w):
     for w_path in args_w:
         path = Coerce.path(space, w_path)
         try:
             os.unlink(path)
         except OSError as e:
             raise error_for_oserror(space, e)
     return space.newint(len(args_w))

 def method_at(self, space, w_time):
     if not (w_time.is_kind_of(space, space.w_numeric) or
             w_time.is_kind_of(space, space.getclassfor(W_TimeObject))):
         raise space.error(space.w_TypeError)
     timestamp = Coerce.float(space, w_time)
     w_time = space.send(self, "new")
     w_time._set_epoch_seconds(timestamp)
     return w_time

 def method_initialize(self, space, w_source, flags=0):
     if isinstance(w_source, W_RegexpObject):
         self.set_source(space, w_source.source, w_source.flags)
     else:
         try:
             self.set_source(space, Coerce.str(space, w_source), flags)
         except regexp.RegexpError as e:
             raise space.error(space.w_RegexpError, str(e))
     return self

 def method_div(self, space, w_other):
     if space.is_kind_of(w_other, space.w_float):
         if space.float_w(w_other) == 0.0:
             self.raise_zero_division_error(space)
         else:
             w_float = space.send(space.newfloat(space.float_w(self)), "/", [w_other])
             w_float = space.newfloat(math.floor(Coerce.float(space, w_float)))
             return space.send(w_float, "to_i")
     else:
         return self.divide(space, w_other)

 def method_match_operator(self, space, w_s):
     if w_s is space.w_nil:
         return space.w_nil
     s = Coerce.str(space, w_s)
     ctx = self.make_ctx(s)
     matched = rsre_core.search_context(ctx)
     self.get_match_result(space, ctx, s, matched)
     if matched:
         return space.newint(ctx.match_start)
     else:
         return space.w_nil

    def method_subscript(self, space, w_idx, w_count, w_other=None):
        if w_other is None:
            w_other = w_count
            w_count = None

        other = Coerce.str(space, w_other)
        start_idx = -1
        end_idx = -1
        if space.is_kind_of(w_idx, space.w_string):
            other_str = space.str_w(w_idx)
            start_idx = space.str_w(self).find(other_str)
            end_idx = start_idx + len(other_str)
        elif space.is_kind_of(w_idx, space.w_regexp):
            ctx = w_idx.make_ctx(space.str_w(self))
            if self.search_context(space, ctx):
                if w_count is None:
                    start_idx = ctx.match_start
                    end_idx = ctx.match_end
                elif space.is_kind_of(w_count, space.w_string):
                    raise space.error(
                        space.w_NotImplementedError,
                        "string subscript replace with regexp and named group"
                    )
                else:
                    groupnum = Coerce.int(space, w_count)
                    try:
                        start_idx, end_idx = ctx.span(groupnum)
                    except IndexError:
                        pass
        else:
            start_idx, end_idx, as_range, nil = space.subscript_access(self.length(), w_idx, w_count=w_count)
            if not w_count:
                end_idx = start_idx + 1

        if start_idx < 0 or end_idx < 0:
            raise space.error(space.w_IndexError, "cannot find substring in string to replace")

        self.strategy.to_mutable(space, self)
        self.strategy.delslice(space, self.str_storage, start_idx, end_idx)
        self.strategy.insert(self.str_storage, start_idx, other)
        return self

 def method_module_function(self, space, args_w):
     if not args_w:
         self.set_default_visibility(space, W_FunctionObject.MODULE_FUNCTION)
         return self
     for w_arg in args_w:
         name = Coerce.symbol(space, w_arg)
         w_method = self.find_method(space, name)
         if w_method is None or isinstance(w_method, UndefMethod):
             cls_name = space.obj_to_s(self)
             raise space.error(space.w_NameError, "undefined method `%s' for class `%s'" % (name, cls_name))
         self.attach_method(space, name, w_method)
         self.set_method_visibility(space, name, W_FunctionObject.PRIVATE)
     return self

 def srand(self, space, seed=None):
     previous_seed = self.w_seed
     if seed is None:
         seed = intmask(self._generate_seed())
     else:
         seed = Coerce.int(space, seed)
     self.w_seed = space.newint(seed)
     if previous_seed is None:
         value = space.newfloat(self.random.random())
     else:
         value = previous_seed
     self.random = Random(abs(seed))
     return value

    def method_last(self, space, w_count=None):
        if w_count is not None:
            count = Coerce.int(space, w_count)
            if count < 0:
                raise space.error(space.w_ArgumentError, "negative array size")
            start = len(self.items_w) - count
            if start < 0:
                start = 0
            return space.newarray(self.items_w[start:])

        if len(self.items_w) == 0:
            return space.w_nil
        else:
            return self.items_w[len(self.items_w) - 1]