Define the ``Int3()`` function in the interpreter. Calling
    ``Int3()`` will drop the user into an interactive debugger.
429508
def int3(params, ctxt, scope, stream, coord, interp):
    
    if interp._no_debug:
        return

    if interp._int3:
        interp.debugger = PfpDbg(interp)
        interp.debugger.cmdloop()
687841
def p_parameter_3(p):
    
    args = {}
    if len(p) == 4:
        args['is_array'] = True
        args['array_size'] = p[3]
    p[0] = CIMParameter(p[2], 'reference', reference_class=p[1], **args)
1172193
def p_Callable(p):
    '''
    
    '''
    if len(p) <= 3:
        p[0] = Callable(p[1], None)
    else:
        p[0] = Callable(p[1], p[3])
143526
def tri_value(self):
        
        # This emulates a reverse dependency of 'm && visibility' for
        # non-optional choices, which is how the C implementation does it

        val = 0 if self.is_optional else 1

        if self.user_value is not None:
            val = max(val, self.user_value)

        # Warning: See Symbol._rec_invalidate(), and note that this is a hidden
        # function call (property magic)
        val = min(val, self.visibility)

        # Promote m to y for boolean choices
        return 2 if val == 1 and self.type is BOOL else val
1310048
def from_int(cls, integer):
        
        bin_string = bin(integer)

        return cls(
            text=len(bin_string) >= 1 and bin_string[-1] == "1",
            comment=len(bin_string) >= 2 and bin_string[-2] == "1",
            user=len(bin_string) >= 3 and bin_string[-3] == "1",
            restricted=len(bin_string) >= 4 and bin_string[-4] == "1"
        )
868525
def parse_int(self, buff, start, end):
        '''
            
        '''
#         num = self.parse_uint(buff, start, end)
#         l = (end - start)
#         return self.twos_comp(num, l * 8)
        return struct.unpack_from(self.structmap[end - start], buff, start)[0]
723888
def _canonical_int(self, interface):
        """"""
        if self.use_canonical_interface is True:
            return napalm.base.helpers.canonical_interface_name(
                interface, addl_name_map=None
            )
        else:
            return interface
51063
def int(name, default=None, allow_none=False, fallback=None):
    
    value = read(name, default, allow_none, fallback=fallback)
    if isinstance(value, builtins.str):
        value = value.strip()

    if value is None and allow_none:
        return None
    else:
        return builtins.int(value)
541295
def py3round(number):
    """"""
    if abs(round(number) - number) == 0.5:
        return int(2.0 * round(number / 2.0))

    return int(round(number))
587706
def intf_up(self, interface):
        '''
        
        '''
        if interface.name not in self._devinfo:
            self._devinfo[interface.name] = interface
            if self._devupdown_callback:
                self._devupdown_callback(interface, 'up')
        else:
            raise ValueError("Interface already registered")
1119870
def _setint(self, int_, length=None):
        """"""
        # If no length given, and we've previously been given a length, use it.
        if length is None and hasattr(self, 'len') and self.len != 0:
            length = self.len
        if length is None or length == 0:
            raise CreationError("A non-zero length must be specified with an int initialiser.")
        if int_ >= (1 << (length - 1)) or int_ < -(1 << (length - 1)):
            raise CreationError("{0} is too large a signed integer for a bitstring of length {1}. "
                                "The allowed range is [{2}, {3}].", int_, length, -(1 << (length - 1)),
                                (1 << (length - 1)) - 1)
        if int_ >= 0:
            self._setuint(int_, length)
            return
        # TODO: We should decide whether to just use the _setuint, or to do the bit flipping,
        # based upon which will be quicker. If the -ive number is less than half the maximum
        # possible then it's probably quicker to do the bit flipping...

        # Do the 2's complement thing. Add one, set to minus number, then flip bits.
        int_ += 1
        self._setuint(-int_, length)
        self._invert_all()
602876
def interpreter(self):
        
        while True:
            message = input('[#] ')
            if message.lower().strip() == 'exit':
                break

            reply = self.get_reply('#interpreter#', message)
            if not reply:
                print('No reply received.', end='\n\n')
                continue

            # typewrite(reply, end='\n\n') TODO
            print(reply, end='\n\n')
977332
def on(self, level):
        
        if isinstance(level, int) and level >= 0 and level <= 3:
            self._debug_level = level
606835
void radf3(final int ido, final int l1, final double in[], final int in_off, final double out[], final int out_off, final int offset) {
		final double taur = -0.5;
		final double taui = 0.866025403784438707610604524234076962;
		int i, ic;
		double ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i;
		int iw1, iw2;
		iw1 = offset;
		iw2 = iw1 + ido;

		int idx0 = l1 * ido;
		for (int k = 0; k < l1; k++) {
			int idx1 = k * ido;
			int idx3 = 2 * idx0;
			int idx4 = (3 * k + 1) * ido;
			int iidx1 = in_off + idx1;
			int iidx2 = iidx1 + idx0;
			int iidx3 = iidx1 + idx3;
			double i1r = in[iidx1];
			double i2r = in[iidx2];
			double i3r = in[iidx3];
			cr2 = i2r + i3r;
			out[out_off + 3 * idx1] = i1r + cr2;
			out[out_off + idx4 + ido] = taui * (i3r - i2r);
			out[out_off + ido - 1 + idx4] = i1r + taur * cr2;
		}
		if (ido == 1)
			return;
		for (int k = 0; k < l1; k++) {
			int idx3 = k * ido;
			int idx4 = 3 * idx3;
			int idx5 = idx3 + idx0;
			int idx6 = idx5 + idx0;
			int idx7 = idx4 + ido;
			int idx8 = idx7 + ido;
			for (i = 2; i < ido; i += 2) {
				ic = ido - i;
				int widx1 = i - 1 + iw1;
				int widx2 = i - 1 + iw2;

				w1r = wtable_r[widx1 - 1];
				w1i = wtable_r[widx1];
				w2r = wtable_r[widx2 - 1];
				w2i = wtable_r[widx2];

				int idx9 = in_off + i;
				int idx10 = out_off + i;
				int idx11 = out_off + ic;
				int iidx1 = idx9 + idx3;
				int iidx2 = idx9 + idx5;
				int iidx3 = idx9 + idx6;

				double i1i = in[iidx1 - 1];
				double i1r = in[iidx1];
				double i2i = in[iidx2 - 1];
				double i2r = in[iidx2];
				double i3i = in[iidx3 - 1];
				double i3r = in[iidx3];

				dr2 = w1r * i2i + w1i * i2r;
				di2 = w1r * i2r - w1i * i2i;
				dr3 = w2r * i3i + w2i * i3r;
				di3 = w2r * i3r - w2i * i3i;
				cr2 = dr2 + dr3;
				ci2 = di2 + di3;
				tr2 = i1i + taur * cr2;
				ti2 = i1r + taur * ci2;
				tr3 = taui * (di2 - di3);
				ti3 = taui * (dr3 - dr2);

				int oidx1 = idx10 + idx4;
				int oidx2 = idx11 + idx7;
				int oidx3 = idx10 + idx8;

				out[oidx1 - 1] = i1i + cr2;
				out[oidx1] = i1r + ci2;
				out[oidx2 - 1] = tr2 - tr3;
				out[oidx2] = ti3 - ti2;
				out[oidx3 - 1] = tr2 + tr3;
				out[oidx3] = ti2 + ti3;
			}
		}
	}
145526
def intround(value):
    

    return int(decimal.Decimal.from_float(
        value).to_integral_value(decimal.ROUND_HALF_EVEN))
470373
function showInterfaceJavaScript(intf, html) {
    html.push("<div class='show-JavaScript'><h3>JavaScript</h3><pre>")

    var line = ""

    line += "\n//"
    line += "\n<span class='interfaceName'>class " + intf.name + "</span>"
    html.push(line)

    intf.methods.forEach(function(method){
        showInterfaceJavaScriptMethod(intf, method, html)
    })

    html.push("</pre></div>")
}
80711
def p_statement_draw3_attr(p):
    
    p[0] = make_sentence('DRAW3',
                         make_typecast(TYPE.integer, p[3], p.lineno(4)),
                         make_typecast(TYPE.integer, p[5], p.lineno(6)),
                         make_typecast(TYPE.float_, p[7], p.lineno(6)), p[2])