try:
    begin_date1 = datetime.datetime.now()
    #block_read = 10000000
    block_read = 100000000
    #fh = os.open(options_value.source_file,os.O_RDONLY)
    fh = file(options_value.source_file,"rb")
    s = ""
    record = []
    #s = list(os.read(fh,block_read))
    #s.extend([char for char in fh.read(block_read)])
    s = fh.read(block_read).encode('hex_codec')
    if block_read > os.stat(options_value.source_file)[6]:
        block_read = len(s)
    number_irc = 0
    record1 =[]
    print "<ADM RECORD>" + s[:64]  + "<RECORD>"
    s = s[64:]
    while s:
        record = s.replace("ff32", "ff<RECORD>32").replace("ff33", "ff<RECORD>33").replace("ff34", "ff<RECORD>34").replace("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "<RECORD>").split("<RECORD>")
        s = ""
        #print record
        for rec_idx, rec_str in enumerate(record):
            #print rec_str
            if (rec_str[:2] == "32" and rec_str[len(rec_str) - 2:] == "ff") or (rec_str[:2] == "34" and rec_str[len(rec_str) - 2:] == "ff"):
                if rec_str[:2] == "32" and len(rec_str) <= 32:
                    if len(record) >= rec_idx + 2:
                        record[rec_idx] = record[rec_idx] + record[rec_idx + 1]
                        record[rec_idx + 1] = ""
                        print "<RECORD>" + record[rec_idx] + "</RECORD>"
                else:
                    print "<RECORD>" + rec_str + "</RECORD>"
            else:
                if rec_str == record[-1] and record[-1]:
                    s = record[-1]
                else:
                    if rec_str[:2] == "33":
                        print "<RECORD>" + rec_str + "</RECORD>"
                        print "Total time for while " + str(datetime.datetime.now() - begin_date1)
                        sys.exit()
        s += fh.read(block_read).encode('hex_codec')
    print "Total time for while " + str(datetime.datetime.now() - begin_date1)
finally:
    print "END parser difference time: " + str(datetime.datetime.now() - begin_date1) + " PARSER"
    print "CLOSE FILE\n"
    #c = os.close(fh)
    fh.close()

from numpy import *
a = memmap(r'c:\test\W1_RB.EGRID', uint8)
c = where(a==0xff)[0]					      # позиции всех элементов со значением ff
d = where((a[c+1]>0x31) & (a[c+1]<0x35))[0]    # позиции всех элементов со значениями ff32-ff34
# проверка найденных индексов
print a[c[d]] # -> [255 255 255 255 255 ...
print a[c[d]+1] # -> [51 51 51 51 51 51 51 ...

import os
import binascii
import time as _time

from io import StringIO
    
from enum import enum

STATE = enum("original", "end", "begin", "stop")

def main(BLOCK_SIZE=4096):
    out = StringIO()
    write = out.write
    hexlify = binascii.hexlify

    begin = _time.time()
    file_size = os.path.getsize(options_value.source_file)

    with open(options_value.source_file, "rb") as f:
        write("<ADM RECORD>{0}<RECORD>\n".format(hexlify(f.read(32))))
        pos   = 0
        bfr   = b""
        state = STATE.original
        while state != STATE.stop:
            if state == STATE.original:
                pos = 0
                bfr += f.read(BLOCK_SIZE)
                state = STATE.begin
            elif state == STATE.begin:
                pos = bfr.find(b"\xff", pos)
                if -1 == pos:
                    state = STATE.original
                else:
                    try:
                        if bfr[pos + 1] in (b"\x32", b"\x33", b"\x34"):
                            state = STATE.end
                    except IndexError:
                        if file_size == f.tell():
                            state = STATE.end
                        else:
                            state = STATE.original
            elif state ==STATE.end:
                write("<RECORD>{0}<RECORD>\n".format(hexlify(bfr[:pos])))
                bfr = bfr[pos + 1:]
                state = STATE.begin if bfr else STATE.stop
    print("total time:", _time.time() - begin)
    
    with open("outfile", "wb") as f:
        f.write(out.getvalue())