def __init__(self, val=0, min=None, max=None, _nrbits=0):
     if _nrbits:
         self._min = 0
         self._max = 2**_nrbits
     else:
         self._min = min
         self._max = max
         if max is not None and min is not None:
             if min >= 0:
                 _nrbits = len(bin(max-1))
             elif max <= 1:
                 _nrbits = len(bin(min))
             else:
                 # make sure there is a leading zero bit in positive numbers
                 _nrbits = maxfunc(len(bin(max-1))+1, len(bin(min)))
     if isinstance(val, (int, long)):
         self._val = val
     elif isinstance(val, StringType):
         mval = val.replace('_', '')
         self._val = long(mval, 2)
         _nrbits = len(val)
     elif isinstance(val, intbv):
         self._val = val._val
         self._min = val._min
         self._max = val._max
         _nrbits = val._nrbits
     else:
         raise TypeError("intbv constructor arg should be int or string")
     self._nrbits = _nrbits
     self._handleBounds()

    def to_word(self,data):
        buf = bytearray(data)
        
        print len(buf)
        a = (3,6,7,4,7,10,5)
        b = (5,2,7,4,1,9,3)
        j = 0
        x = {}
        for i in range(0,6):
            if(i == 2):
                x[i] = buf[j] << a[i] &((2^(11-a[j])-1) << a[i]) | b[3] << 1 | buf[3+1] >> b[i]
                j = j + 2
            elif(i == 5):
                x[i] = buf[j] << a[i] & ((2^(11-a[i])-1) << a[i]) | buf[7] << 2 | buf[7+1] >> b[i]
                j = j + 2
            elif(i == 6):
                x[i] = buf[9] & ((2^6-1) << 3)
            else:
                print "%d %d" % (i,j)
                x[i] = buf[j] << a[i] & ((2^(11-a[i])-1) << a[i]) | buf[j+1] >> b[i]
                j = j + 1

        for i in range(0,10):
            print str(bin(buf[i])).split('b')[1],
        print "\n"
    
        for i in range(0,7):
            print str(bin(x[i])).split('b')[1],
        print "\n"

def read_bitpacked_deprecated(fo, byte_count, count, width):
    raw_bytes = array.array('B', fo.read(byte_count)).tolist()

    mask = _mask_for_bits(width)
    index = 0
    res = []
    word = 0
    bits_in_word = 0
    while len(res) < count and index <= len(raw_bytes):
        logger.debug("index = %d", index)
        logger.debug("bits in word = %d", bits_in_word)
        logger.debug("word = %s", bin(word))
        if bits_in_word >= width:
            # how many bits over the value is stored
            offset = (bits_in_word - width)
            logger.debug("offset = %d", offset)

            # figure out the value
            value = (word & (mask << offset)) >> offset
            logger.debug("value = %d (%s)", value, bin(value))
            res.append(value)

            bits_in_word -= width
        else:
            word = (word << 8) | raw_bytes[index]
            index += 1
            bits_in_word += 8
    return res

 def stimulus():
     for i in range(8):
         value = random.randint(-(2**15), 2**15-1)
         data_in.next = intbv( value, min=-(2**15), max=2**15-1)
         
         print "In: %s (%i) | Out: %s (%i)" % (bin(data_in, 16), data_in, bin(data_out, 32), data_out)
         yield delay(5)

def GF2_span(D, L):
    '''
    >>> from GF2 import one
    >>> D = {'a', 'b', 'c'}
    >>> L = [Vec(D, {'a': one, 'c': one}), Vec(D, {'b': one})]
    >>> len(GF2_span(D, L))
    4
    >>> Vec(D, {}) in GF2_span(D, L)
    True
    >>> Vec(D, {'b': one}) in GF2_span(D, L)
    True
    >>> Vec(D, {'a':one, 'c':one}) in GF2_span(D, L)
    True
    >>> Vec(D, {x:one for x in D}) in GF2_span(D, L)
    True
    '''
    from GF2 import one
    span=[]
    S=2**len(L)
    for i in range(S) :
        ms = [one if (len(bin(i))-2 >k and bin(i)[len(bin(i))-k-1]=='1') else 0 for k in reversed(range(len(L)))]
        v_sum=Vec(D,{})
        for j in range(len(L)):
            v_sum+=ms[j]*L[j]
        span.append(v_sum)
    
    return span

def readImageData(rowsize,padding,width,inFile):
    EOF = False
    unpaddedImage = bytearray()
    i = 1

    #Undefined bits in the byte at the end of a row (not counting 4-byte padding)
    #A 100-pixel row's pixels take up 100 bits, or 12.5 bytes. This means that there
    #are 8*0.5 (4) unused bits at the end, which must be set to FF so that they will be
    #white after inversion later
    unusedBits = int((math.ceil(width/8.0)-(width/8.0))*8)

    #Binary mask to OR with the last byte; if there are 5 unused bits then the mask will
    #be 00011111
    unusedBitsMask = int(pow(2,unusedBits)-1)
    print bin(unusedBitsMask)
    while not EOF:
        try:
            readByte = int(binascii.hexlify(inFile.read(1)),16)
            if i == rowsize-padding:
                inFile.seek(padding,1) #Skip the padding at the end of the row
                i = 1
                unpaddedImage.append(readByte | unusedBitsMask)
            else:
                unpaddedImage.append(readByte)
                i += 1
        except ValueError:
            EOF = True
    return unpaddedImage

 def createPattern(self,details=2):
     if details in [0,1]:
         return None
     elif details == 2:
         cell=self.coords
         name=str(cell[0])+"-"+str(cell[1])
         bitDist=self.descriptor.bitDistance
         zero=[-self.descriptor.markerArea[i]/2. for i in [0,1]]
         BITS=Structure("CellBits_"+name)
         CIRCLEMARKER=self.createCircleMarker()
         bit=[int(i) for i in bin(int(cell[0]))[::-1][:-2]]
         ##TODO use descriptor.getBits(cell)
         for i,b in enumerate(bit):
             if b:
                 x=zero[0]+mod(i+1,self.descriptor.noBitsX)*bitDist
                 y=zero[1]+((i+1)/self.descriptor.noBitsY)*bitDist
                 BITS.insertElement(CIRCLEMARKER,xy=(x,y))
         bit=[int(i) for i in bin(int(cell[1]))[::-1][:-2]]
         for i,b in enumerate(bit):
             if b:
                 x=zero[0]+(self.descriptor.noBitsX-mod(i+1,self.descriptor.noBitsX)-1)*bitDist
                 y=zero[1]+(self.descriptor.noBitsY-(i+1)/self.descriptor.noBitsY-1)*bitDist
                 BITS.insertElement(CIRCLEMARKER,xy=(x,y))
         return BITS
     else:
         raise ValueError("details can be 0,1,2")

def hamming_code_distance(string1, string2):
    """
    Compute the Hamming Code distance between two strings
    """
    if len(string1) is not len(string2):
        # If strings are different lengths, truncate the longer one so that you
        # can do the compare
        string1 = string1[0:len(string2)]
        string2 = string2[0:len(string1)]
        #raise Exception("Buffers are different lengths!")
    bytes1=string1.encode()
    bytes2=string2.encode()
    i = 0
    hamming_distance = 0
    while i < len(bytes1):
        char1 = bytes1[i]
        char2 = bytes2[i]
        bin1 = "{:0>8}".format(bin(char1)[2:])
        bin2 = "{:0>8}".format(bin(char2)[2:])
        j = 0
        thisbyte_hd = 0
        while j < 8:
            if bin1[j] is not bin2[j]:
                thisbyte_hd +=1
                hamming_distance += 1
            j +=1
        i +=1
    return hamming_distance

 def bitSwapRequired(self, a, b):
     xor_ab = a ^ b
     #count '1' in bits of xor result if the result is positive value
     if xor_ab >= 0:
         return bin(xor_ab).count('1')
     else:
         #suppose 32 bits integer
         MAX_BITS_LEN = 32
         #use compliment bits to represent negative value
         bits_without_sign = bin(xor_ab)[3:].zfill(MAX_BITS_LEN - 1)
         bits_inverted = bits_without_sign.replace('1','r').replace('0','1').replace('r','0')
         carry_bit = None
         #the sign bit must be '1', so initialize the counter with 1
         count_1_of_compliment_bits = 1
         #calculate the compliment bits by adding 1 to bits_inverted
         for i in range(len(bits_inverted)-1,-1,-1):
             if carry_bit == None:
                 if bits_inverted[i] == '1':
                     carry_bit = 1
                     continue
             else:
                 if bits_inverted[i] == '1' and carry_bit == 1:
                     continue
                 if bits_inverted[i] == '0' and carry_bit == 0:
                     continue
             count_1_of_compliment_bits += 1
             carry_bit = 0
         return count_1_of_compliment_bits

def late(n, p):
        result = 0
        for i in range(1, 2**n + 1):
                if '111' in bin(i):
                        lates = bin(i).count('1')
                        result += p**lates * (1 - p)**(n - lates)
        return 1 - result

 def test_set_bit_no_actual_change(self):
     initial = "10010100"  # 148 in binary
     output = Encrypter.set_bit(int(initial, 2), 6, 0)
     self.assertEqual(bin(output)[2:], initial)
     initial = "10010100"  # 148 in binary
     output = Encrypter.set_bit(int(initial, 2), 2, 1)
     self.assertEqual(bin(output)[2:], initial)

    def test_unaligned_native_struct_fields(self):
        if sys.byteorder == "little":
            fmt = "<b h xi xd"
        else:
            base = LittleEndianStructure
            fmt = ">b h xi xd"

        class S(Structure):
            _pack_ = 1
            _fields_ = [("b", c_byte),

                        ("h", c_short),

                        ("_1", c_byte),
                        ("i", c_int),

                        ("_2", c_byte),
                        ("d", c_double)]

        s1 = S()
        s1.b = 0x12
        s1.h = 0x1234
        s1.i = 0x12345678
        s1.d = 3.14
        s2 = bytes(struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14))
        self.assertEqual(bin(s1), bin(s2))

def shortest_path(start, end, upper_limit):
    visited = set([])

    # Maintain a tuple for (number, path length)
    agenda = [(start,1,[start])]

    # Perform a breadth first search
    while len(agenda) > 0:
        cur, length, path = agenda.pop(0)

        # Do not repeat visited numbers
        if cur in visited:
            continue

        visited.add(cur)
        
        for diff in differences:
            top = cur + diff
            bottom = cur - diff
            
            # Found the shortest path
            if top == end or bottom == end:
                tot = path + [end]
                for i in tot:
                    print bin(i), i
                return length + 1

            # Prune for range and if it is prime
            if top <= upper_limit and is_prime(top):
                agenda.append((top,length+1,path+[top]))
            if bottom >= 2 and is_prime(bottom):
                agenda.append((bottom,length+1,path+[bottom]))

def cross_1(set):
    for i in range(len(set)):
        for j in range(len(set[i])):
            rand_seq = range(len(set[i][j]))
            random.shuffle(rand_seq)
            for k in range(len(rand_seq)/2):
                n_1, n_2 = rand_seq[k], rand_seq[len(rand_seq)-k-1]
                if i in [0, 2, 4]:
                    p_1, p_2 = (bin(int(set[i][j][n_1]))[2:]), (bin(int(set[i][j][n_2]))[2:])
                    p_1, p_2 = p_1.zfill(30), p_2.zfill(30)
                if i in [1, 3]:
                    p_1, p_2 = (bin(int(set[i][j][n_1]))[2:]), (bin(int(set[i][j][n_2]))[2:])
                    p_1, p_2 = p_1.zfill(30), p_2.zfill(30)
                n = 0
                for x in range(0,len(p_1)):
                    if p_2[x] == '1':
                        n = x
                        break
                    elif p_1[x] == '1':
                        n = x
                        break
                if n > (len(p_1)-1):
                    ran_num = random.sample(xrange(n, len(p_1)-1), 2)
                    r_n1, r_n2 = ran_num[0], ran_num[1]
                    if r_n1 > r_n2:
                        r_n1, r_n2 = r_n2, r_n1
                    for l in range(r_n1,r_n2):
                        p_2, p_1 = p_2[0:l] + str(p_1[l]) + p_2[l+1:], p_1[0:l] +  str(p_2[l]) + p_1[l+1:]
                    print p_1, p_2
                    set[i][j][n_1], set[i][j][n_2] = int(p_1,2), int(p_2,2)
    return mut_1(set)

def updatefromremote(ui, repo, remotemarks, path, trfunc, explicit=()):
    ui.debug("checking for updated bookmarks\n")
    localmarks = repo._bookmarks
    (addsrc, adddst, advsrc, advdst, diverge, differ, invalid, same
     ) = compare(repo, remotemarks, localmarks, dsthex=hex)

    status = ui.status
    warn = ui.warn
    if ui.configbool('ui', 'quietbookmarkmove', False):
        status = warn = ui.debug

    explicit = set(explicit)
    changed = []
    for b, scid, dcid in addsrc:
        if scid in repo: # add remote bookmarks for changes we already have
            changed.append((b, bin(scid), status,
                            _("adding remote bookmark %s\n") % (b)))
        elif b in explicit:
            explicit.remove(b)
            ui.warn(_("remote bookmark %s points to locally missing %s\n")
                    % (b, scid[:12]))

    for b, scid, dcid in advsrc:
        changed.append((b, bin(scid), status,
                        _("updating bookmark %s\n") % (b)))
    # remove normal movement from explicit set
    explicit.difference_update(d[0] for d in changed)

    for b, scid, dcid in diverge:
        if b in explicit:
            explicit.discard(b)
            changed.append((b, bin(scid), status,
                            _("importing bookmark %s\n") % (b)))
        else:
            snode = bin(scid)
            db = _diverge(ui, b, path, localmarks, snode)
            if db:
                changed.append((db, snode, warn,
                                _("divergent bookmark %s stored as %s\n") %
                                (b, db)))
            else:
                warn(_("warning: failed to assign numbered name "
                       "to divergent bookmark %s\n") % (b))
    for b, scid, dcid in adddst + advdst:
        if b in explicit:
            explicit.discard(b)
            changed.append((b, bin(scid), status,
                            _("importing bookmark %s\n") % (b)))
    for b, scid, dcid in differ:
        if b in explicit:
            explicit.remove(b)
            ui.warn(_("remote bookmark %s points to locally missing %s\n")
                    % (b, scid[:12]))

    if changed:
        tr = trfunc()
        for b, node, writer, msg in sorted(changed):
            localmarks[b] = node
            writer(msg)
        localmarks.recordchange(tr)

	def __init__(self, mips, instrucao):
		self.mips = mips
		self.rs = bin(eval("0b"+instrucao[6:11]))
		self.rt = bin(eval("0b"+instrucao[11:16]))
		self.rd = bin(eval("0b"+instrucao[16:21]))
		self.shamt = bin(eval("0b"+instrucao[21:26]))
		self.isMul = False

    def computeNewR(self, nodesR, competitorsR):
        """ Metoda wylicza nowa wartosc r dla wezla na podstawie wartosci jego konkutenta.
        
        Argumenty:
        nodesR - wartosc r dla wezla, ktory jest aktualnie rozpatryway
        competitorsR - wartosc r (konkurenta), na podstawie ktorej zostanie obliczone nowe r
        """
        
        # warunek potrzebny w przypadku malych ID
        if nodesR < competitorsR:
            return 0
        
        # obliczanie nowego r dla rozpatrywanego wezla
        binNodesR       = bin(nodesR)
        binCompetitorsR = bin(competitorsR)

        # teraz to sa 2 stringi - obciecie dwoch pierwszych znakow
        binNodesR       = binNodesR[2:]
        binCompetitorsR = binCompetitorsR[2:]

        # miejsce prependowania zera nie jest do konca jasne:
        # wezmy binNodeR = 1, binCompR = 10
        # w przypadku doczepiania zera z lewej, dostajemy:
        # binNodeR = 01, binCompR = 10

        while len(binCompetitorsR)  > len(binNodesR):
            binNodesR       = ''.join(['0', binNodesR])
    
        while len(binNodesR)        > len(binCompetitorsR):
            binCompetitorsR = ''.join(['0', binCompetitorsR])
            
        # teraz sprawdzanie, czy wartosc r wezla jest mniejsza niz wartosc r competitora
        decNodesR       = int(binNodesR, 2)
        decCompetitorsR = int(binCompetitorsR, 2)
        
        # jesli wezel ma najmniejsze r, to nowa wartosc r <- 0
        if decNodesR < decCompetitorsR:
            return 0

        # algorytm operuje na odwroconych napisach, ale w implementacji z pythonem
        # wykorzystany jest fakt, ze tablice sa numerowane od 0
        # w tym momencie na pozycji nr 0 w implementacji jest znak,
        # ktory bylby na samym koncu stringa w opisie teoretycznym/pseidokodzie
        
        # szukanie indeksow
        # liczymy nie od 0, ale od 1!
        # zwracamy ten indeks, gdzie binNodesR, a binCompetitorsR = 0
        i       = 0
        length  = len(binNodesR)
        
        while i < length:
            if binNodesR[i] == '1' and binCompetitorsR[i] == '0':
                break
            
            i+=1
    
        index   = len(binNodesR) - i # bo zaczynamy liczenie indeksow od 1, nie od zera
        # taki wymog pracy
        
        return index

def addBinSlow(a, b):
    aBin = bin(a)[2:]
    bBin = bin(b)[2:]

    lA = len(aBin)
    lB = len(bBin)

    if lA > lB:
        bBin = bBin.zfill(lA)
    elif lB > lA:
        aBin = aBin.zfill(lB)

    assert len(aBin) == len(bBin)

    res = len(aBin) * ['']
    k = 0
    for i, j in zip(aBin, bBin):
        if i == '0' and j == '0':
            out = '0'
        elif i == '0' and j == '1':
            out = '1'
        elif i == '1' and j == '0':
            out = '1'
        elif i == '1' and j == '1':
            out = '0'
        else:
            print 'Error'

        res[k] = out
        k += 1

    binResult = ''.join(res)
    return s2b(binResult)

 def getBits(self,cell):
         zero=[-self.markerArea[i]/2. for i in [0,1]]
         bitx=[int(i) for i in bin(int(cell[0]))[::-1][:-2]]
         bity=[int(i) for i in bin(int(cell[1]))[::-1][:-2]]
         s0=int(np.log2(self.cellsPerBlock[0]*self.noBlocks[0]))
         s1=int(np.log2(self.cellsPerBlock[1]*self.noBlocks[1]))
         for i in range(s0-len(bitx)):
             bitx.append(0)
         for i in range(s1-len(bity)):
             bity.append(0)
         tx=np.zeros(s0,dtype=np.bool)
         ty=np.zeros(s1,dtype=np.bool)
         px=np.empty((s0,2))
         py=np.empty((s1,2))
         for i,b in enumerate(bitx):
             x=zero[0]+mod(i+1,self.noBitsX)*self.bitDistance
             y=zero[1]+((i+1)/self.noBitsY)*self.bitDistance
             px[i]=(x,y)
             tx[i]=b
         for i,b in enumerate(bity):
             x=zero[0]+(self.noBitsX-mod(i+1,self.noBitsX)-1)*self.bitDistance
             y=zero[1]+(self.noBitsY-(i+1)/self.noBitsY-1)*self.bitDistance
             py[i]=(x,y)
             ty[i]=b
         return px,py,tx,ty

def rebuild_id_header(channels, frequency, blocksize_short, blocksize_long):
	packet = OggPacket()

	buf = OggpackBuffer()
	ogg.oggpack_write(buf, 0x01, 8)
	for c in 'vorbis':
		ogg.oggpack_write(buf, ord(c), 8)
	ogg.oggpack_write(buf, 0, 32)
	ogg.oggpack_write(buf, channels, 8)
	ogg.oggpack_write(buf, frequency, 32)
	ogg.oggpack_write(buf, 0, 32)
	ogg.oggpack_write(buf, 0, 32)
	ogg.oggpack_write(buf, 0, 32)
	ogg.oggpack_write(buf, len(bin(blocksize_short)) - 3, 4)
	ogg.oggpack_write(buf, len(bin(blocksize_long)) - 3, 4)
	ogg.oggpack_write(buf, 1, 1)

	if hasattr(ogg, 'oggpack_writecheck'):
		ogg.oggpack_writecheck(buf)

	packet.bytes = ogg.oggpack_bytes(buf)
	buf = ctypes.create_string_buffer(bytes(buf.buffer[:packet.bytes]), packet.bytes)
	packet.packet = ctypes.cast(ctypes.pointer(buf), ctypes.POINTER(ctypes.c_char))
	packet.b_o_s = 1
	packet.e_o_s = 0
	packet.granulepos = 0
	packet.packetno = 0

	return packet