def _rdraw(self, offs=(0,0)):
		ofs_x, ofs_y = offs
		x0 = self.draw_area[2]
		y0 = self.draw_area[1]
		ofs_x += x0
		ofs_y += y0
		buf = empty_img()
		for i, line in enumerate(self.img):
			linebuf = line.copy()
			l = linebuf.length()
			if l == ofs_x:
				pass
			elif l < ofs_x:
				dl = ofs_x - l
				a = bitarray(dl)
				a.setall(False)
				linebuf = a + linebuf
			elif l > ofs_x:
				dl = l - ofs_x
				del linebuf[:dl]
			l = linebuf.length()
			if l == 160:
				pass
			elif l > 160:
				del linebuf[160:]
			elif l < 160:
				dl = 160 - l
				a = bitarray(dl)
				a.setall(False)
				linebuf += a
			y = ofs_y + i
			linebuf &= self.mask[y]
			buf[y] = linebuf
		self.buf = buf
		self.redraw = False

	def _cdraw(self, offs=(0,0)):
		ofs_x, ofs_y = offs
		x1 = (self.draw_area[0] + self.draw_area[2])/2
		y1 = self.draw_area[1]
		x1 += ofs_x
		y1 += ofs_y
		buf = empty_img()
		for i, line in enumerate(self.img):
			linebuf = line.copy()
			l = linebuf.length()
			x0 = x1 - (l/2)
			if x0 == 0:
				pass
			elif x0 < 0:
				del linebuf[:abs(x0)]
			elif x0 > 0:
				a = bitarray(x0)
				a.setall(False)
				linebuf = a + linebuf
			l = linebuf.length()
			if l == 160:
				pass
			elif l > 160:
				del linebuf[160:]
			elif l < 160:
				dl = 160 - l
				a = bitarray(dl)
				a.setall(False)
				linebuf += a
			y = y1 + i
			linebuf &= self.mask[y]
			buf[y] = linebuf
		self.buf = buf
		self.redraw = False

	def _generate_pawn(self, team, adv, empty, moves):
		pawns =  bitarray(self.pieces[team][PAWN])
		''' Loop for each pawn '''
		while(pawns.any()):

			pos_init = pawns.index(1)
			bb_init = bitarray(64)
			bb_init.setall(0)
			bb_init[pos_init] = 1

			# Movement to 1 forward
			if team == WHITE:
				bb_final = rightshift(bb_init, 8) & empty
			else:
				bb_final = leftshift(bb_init, 8) & empty

			self._check_move(team, PAWN, pos_init, bb_final, moves)

			# Normal capture
			if team == WHITE:
				bb_final_1 = rightshift(bb_init, 7) & adv & notHFile
				bb_final_2 = rightshift(bb_init, 9) & adv & notAFile
			else:
				bb_final_1 = leftshift(bb_init, 7) & adv & notAFile
				bb_final_2 = leftshift(bb_init, 9) & adv & notHFile

			self._check_move(team, PAWN, pos_init, bb_final_1, moves)
			self._check_move(team, PAWN, pos_init, bb_final_2, moves)

			pawns ^= bb_init

def getbytes(data, start, end):

    array = bitarray()
    array.frombytes(data)

    length = array.length()
    bStart = length - start - 1
    bEnd = length - end

    # <-start     end->
    #  7 6 5 4 3 2 1 0
    # +---------------+
    # |0|0|1|0|1|1|1|1|
    # +---------------+

    peace = array[bStart:bEnd]

    pLen = peace.length()

    byte_len = 8
    rest = (byte_len - pLen) % byte_len

    zeroArr = bitarray(rest)
    zeroArr.setall(False)
    zeroArr += peace

    return zeroArr.tobytes()

def merge_data(first_data, second_data):

    f_array = bitarray()
    f_array.frombytes(first_data)

    s_array = bitarray()
    s_array.frombytes(second_data)

    return (f_array + s_array).tobytes()

    def __init__(self):
        
        self.FD = 0x7E
        self.byteFD = (self.FD).to_bytes(1,byteorder='big',signed=False)

        self.insertingBitVal = True
        self.bitFrameDelim = bitarray()
        self.bitFrameDelim.frombytes(self.byteFD)
        
        self.bitPattern = bitarray()
        self.__initBitPattern(self.bitPattern)

 def _initializeBFPattern(self):
     if not os.path.exists(self._bf_pattern_path):
         _bitarray = bitarray(self._mbits)
         _bitarray.setall(0)
         _bitarray.tofile(open(self._bf_pattern_path, "wb"))
         self._bflog.log("info", "Initializing bloomfilter pattern %s successful" % self._bf_pattern_path)
     else:
         self._bflog.log("info", "Bloomfilter pattern %s already existing" % self._bf_pattern_path)
         if self._mbits == 0:
             _bitarray = bitarray()
             _bitarray.fromfile(open(self._bf_pattern_path, "rb"))
             self._mbits = len(_bitarray)

    def get_optimal_path(self, InSkills, OutSkills):

        OldGraph = self.Graph
        self.Graph.add_node(self.FakeBeginNode)
        FakeBeginEdges = self.gen_out_node_edges(self.FakeBeginNode, InSkills)
        self.Graph.add_weighted_edges_from(FakeBeginEdges)

        self.FakeEndNode =  self.DB.CourseCID
        
        self.Graph.add_nodes_from([self.FakeEndNode])

        PathesList = []

        FakeEndEdges = self.gen_inp_node_edges(self.FakeEndNode, OutSkills)
        self.Graph.add_weighted_edges_from(FakeEndEdges)

        #print InSkills, OutSkills

        answer = topological_sort(self.Graph)
        answer = answer[answer.index(0) + 1:answer.index(self.FakeEndNode)]    

        #print answer, self.check_path(answer, InSkills, OutSkills)

        barr = bitarray(2**len(answer))
        barr.setall(False)

        opt_path = self.recurse_search(answer, answer, InSkills, OutSkills, barr)

        self.Graph.remove_node(self.FakeBeginNode)
        self.Graph.remove_node(self.FakeEndNode)

        #print '^ ', self.debug_i, self.debug_m, ' ^'

        return index2path(opt_path[1], answer)

def set_data(o_data, n_data, start, end):

        old_data = bitarray()
        old_data.frombytes(o_data)
        new_data = bitarray()
        new_data.frombytes(n_data)

        length = len(new_data)
        bStart = length - start - 1
        bEnd = length - end

        first_peace = old_data[:bStart]
        second_peace = old_data[bEnd:]

        ret_data = first_peace + new_data[length - (bEnd - bStart):] + second_peace
        return ret_data.tobytes()

	def _ldraw(self, offs=(0,0)):
		ofs_x, ofs_y = offs
		x0 = self.draw_area[0]
		y0 = self.draw_area[1]
		ofs_x += x0
		ofs_y += y0
		buf = empty_img()
		for i, line in enumerate(self.img):
			linebuf = line.copy()
			if ofs_x == 0:
				pass
			elif ofs_x < 0:
				del linebuf[:abs(ofs_x)]
			else:
				linebuf[:0] = bitarray(ofs_x * [False])
			l = linebuf.length()
			if l == 160:
				pass
			elif l < 160:
				linebuf.extend((160-l)*[False])
			else:
				del(linebuf[160:])
			y = ofs_y + i
			linebuf &= self.mask[y]
			buf[y] = linebuf
		self.buf = buf
		self.redraw = False

	def __init__(self, daemon):
		self.daemon = daemon
		self.buf = None
		self.height = 43
		self.width = 160
		self.buf = [ bitarray(self.width * [False]) for x in range(self.height) ]
		self.clear()

def coddingFile(file):
    dfrequencia = countT(file)
    l = createNode(dfrequencia)
    dic = huffmann(l)
    k = bitarray()
    for i in file:
        k += dic[i]
    return k

def junk(code, *args, **kwargs):
    tsize = int(args[0])
    instream = bitarray('0'*tsize)
    insertpos = random.randint(1, len(code)-tsize)
    c = code[:insertpos]
    c += instream
    c += code[insertpos:]
    return c

	def init_g15(self):
		host = 'localhost'
		port = 15550
		g15 = G15()
		g15.set_timeout(0.2)
		g15.connect(host, port)
		self.keys = bitarray('0000000000')
		self.g15 = g15

	def get_keys(self):
		try:
			buf = self.sock.recv(1024)
			a = bitarray(endian='little')
			a.fromstring(buf)
			self.keys = a[18:28]
		except socket.timeout:
			return None
		return self.keys

	def __init__(self, team, piece_type, pos_init, pos_final, capture=False, capture_type=None):
		self.team = team
		self.piece_type = piece_type
		self.pos_init = pos_init
		self.pos_final = pos_final

		self.pos_init_bb = bitarray(64)
		self.pos_init_bb.setall(0)
		self.pos_init_bb[pos_init[0]*8 + pos_init[1]] = 1

		self.pos_final_bb = bitarray(64)
		self.pos_final_bb.setall(0)
		self.pos_final_bb[pos_final[0]*8 + pos_final[1]] = 1

		self.from_to = self.pos_init_bb ^ self.pos_final_bb

		self.capture = capture
		self.capture_type = capture_type

def mk_sketch(x, W, cfg):
    """ Given centered input ndarray, create sketch. """
    if cfg.quantize:
        bools = [np.dot(x, row) >= 0.0 for row in W]
        return bitarray(bools)
    else:
        x = x.reshape(-1,1)
        res = np.dot(W, x).flatten()
        return normalize_array(res)

    def Substitude(self, msg):
        """
            Substitudes all bits in input message
        """

        bits = bitarray()
        if type(msg) == str:
            bits.frombytes(msg)
        elif type(msg) == bitarray:
            bits = msg
        else:
            raise ValueError("Not valid type of input data")

        res = bitarray(bits.length() * [0])
        size = len(self.__bare)
        for i in range(0, bits.length()):
            res[i] = bits[(i / size) * size + self.__bare[i % size]]
        return res

    def Reduce(self, block, size):
        """
        Shrinks or extends block to specified size with permutation
        """

        bits = bitarray()
        if type(block) == str:
            bits.frombytes(block)
        elif type(block) == bitarray:
            bits = block
        else:
            raise ValueError("Not valid type of input data")

        res = bitarray(size * [0])

        for i in range(0, size):
            res[i] = bits[self.__bare[i]]
        return res

def compHuffman(texto):
    l = []
    for i in freq:
        l.append(N(i, freq[i]))
    l.sort()
    arvore = huffmann(l)
    array = bitarray()
    for i in texto:
        array += arvore[i]
    return array.tobytes()