will not be called
961924
private int getHuffmanValue(final int table[], final int temp[], final int index[]) throws IOException {
        int code, input;
        final int mask = 0xFFFF;

        if (index[0] < 8) {
            temp[0] <<= 8;
            input = this.input.readUnsignedByte();
            if (input == 0xFF) {
                marker = this.input.readUnsignedByte();
                if (marker != 0) {
                    markerIndex = 9;
                }
            }
            temp[0] |= input;
        }
        else {
            index[0] -= 8;
        }

        code = table[temp[0] >> index[0]];

        if ((code & MSB) != 0) {
            if (markerIndex != 0) {
                markerIndex = 0;
                return 0xFF00 | marker;
            }

            temp[0] &= (mask >> (16 - index[0]));
            temp[0] <<= 8;
            input = this.input.readUnsignedByte();

            if (input == 0xFF) {
                marker = this.input.readUnsignedByte();
                if (marker != 0) {
                    markerIndex = 9;
                }
            }

            temp[0] |= input;
            code = table[((code & 0xFF) * 256) + (temp[0] >> index[0])];
            index[0] += 8;
        }

        index[0] += 8 - (code >> 8);

        if (index[0] < 0) {
            throw new IIOException("index=" + index[0] + " temp=" + temp[0] + " code=" + code + " in HuffmanValue()");
        }

        if (index[0] < markerIndex) {
            markerIndex = 0;
            return 0xFF00 | marker;
        }

        temp[0] &= (mask >> (16 - index[0]));
        return code & 0xFF;
    }
1160358
@ObjectiveCName("toggleCallMuteWithCallId:")
    public void toggleCallMute(long callId) {
        if (modules.getCallsModule().getCall(callId).getIsAudioEnabled().get()) {
            modules.getCallsModule().muteCall(callId);
        } else {
            modules.getCallsModule().unmuteCall(callId);
        }
    }
199534
def call_no_reply(self, fn, *args, **kwargs):
        
        self.default_call_chain.call_no_reply(fn, *args, **kwargs)
326712
def _cancel_callback(self, request_id):
        """"""
        def callback(future):
            if future.cancelled():
                self.notify(CANCEL_METHOD, {'id': request_id})
                future.set_exception(JsonRpcRequestCancelled())
        return callback
799135
def reject(self, callback):
        
        if self._use_as_callable(callback):
            return self.filter(lambda item: not callback(item))

        return self.filter(lambda item: item != callback)
867568
def call(self, name: str, *args, **kwargs):
        ''''''
        if self._event_dispatcher is not None:
            self._event_dispatcher.notify(name, *args, **kwargs)

        if self._callbacks[name]:
            return self._callbacks[name](*args, **kwargs)
        else:
            raise HookDisconnected('No callback is connected.')
953894
def _wait_non_ressources(self, callback):
        """"""  # noqa: E501
        self.trigger = threading.Lock()
        self.was_ended = False
        self.trigger.acquire()
        self.trigger.acquire()
        if not self.was_ended:
            callback(self)
750440
protected void excludeNotCovered(ModifiableDoubleDBIDList candidates, double fmax, ModifiableDoubleDBIDList collect) {
    for(DoubleDBIDListIter it = candidates.iter(); it.valid();) {
      if(it.doubleValue() > fmax) {
        collect.add(it.doubleValue(), it);
        candidates.removeSwap(it.getOffset());
      }
      else {
        it.advance(); // Keep in candidates
      }
    }
  }
1228618
def callable(self) -> Optional[str]:
        """"""
        if self.current_trace_frame_index != -1:
            return self._get_callable_from_trace_tuple(
                self.trace_tuples[self.current_trace_frame_index]
            )[0]
        return None
1186320
def runcall(self, func, *args, **kw):
        
        # XXX where is this used ? can be removed ?
        self.enable_by_count()
        try:
            return func(*args, **kw)
        finally:
            self.disable_by_count()
171870
def cancel(self) :
        ""
        dbus.dbus_pending_call_cancel(self._dbobj)
        if self._awaiting != None :
            # This probably shouldn’t occur. Looking at the source of libdbus,
            # it doesn’t keep track of any “cancelled” state for the PendingCall,
            # it just detaches it from any notifications about an incoming reply.
            self._awaiting.cancel()
470637
def calledWith(cls, spy, *args, **kwargs): #pylint: disable=invalid-name
        
        cls.__is_spy(spy)
        if not (spy.calledWith(*args, **kwargs)):
            raise cls.failException(cls.message)
1164161
def not_implemented(self, func_name):
        '''
        
        '''
        msg = '%s is not overridden by %s' % (func_name, type(self).__name__)
        self.logger.error(msg)
        raise NotImplementedError(msg)
365921
def call
      return broadcast(:invalid) unless user&.invited_to_sign_up?

      user.invite!(user.invited_by, invitation_instructions: instructions)

      broadcast(:ok)
    end
1116928
public static void assertNotAnswered(String msg, SipCall call) {
    assertNotNull("Null assert object passed in", call);
    assertFalse(msg, call.isCallAnswered());
  }
511369
def alwaysCalledWithExactly(cls, spy, *args, **kwargs): #pylint: disable=invalid-name
        
        cls.__is_spy(spy)
        if not (spy.alwaysCalledWithExactly(*args, **kwargs)):
            raise cls.failException(cls.message)
304322
def _check_cb(cb_):
    '''
    
    '''
    if cb_ is not None:
        if hasattr(cb_, '__call__'):
            return cb_
        else:
            log.error('log_callback is not callable, ignoring')
    return lambda x: x