How to use the persistence.read_uint32 function in Persistence

def read_segment_list_entry(f):
    v = [ None ] * loaderlib.SIZEOF_SI
    v[loaderlib.SI_TYPE] = persistence.read_uint8(f)
    offset_value = persistence.read_uint32(f)
    if offset_value == 0xFFFFFFFF: # Unsigned, special value.
        offset_value = -1
    v[loaderlib.SI_FILE_OFFSET] = offset_value
    v[loaderlib.SI_DATA_LENGTH] = persistence.read_uint32(f)
    v[loaderlib.SI_LENGTH] = persistence.read_uint32(f)
    v[loaderlib.SI_ADDRESS] = persistence.read_uint32(f)
    return v

Modifications:
    - disassembly hunk processor id has changed from string to uint32.
    """
    SNAPSHOT_HUNK_VERSIONS = {
        SAVEFILE_HUNK_SOURCEDATA: 1,
        SAVEFILE_HUNK_SOURCEDATAINFO: 1,
        SAVEFILE_HUNK_LOADER: 1,
        SAVEFILE_HUNK_LOADERINTERNAL: 1,
        SAVEFILE_HUNK_DISASSEMBLY: 1,
    }

    input_file.seek(0, os.SEEK_END)
    file_size = input_file.tell()
    input_file.seek(0, os.SEEK_SET)

    savefile_id = persistence.read_uint32(input_file)
    savefile_version = persistence.read_uint16(input_file)
    if savefile_version != 3:
        return None

    logger.info("Upgrading save-file from version 3 to version 4: Processor id field..")
    save_count = persistence.read_uint32(input_file)

    output_file = tempfile.TemporaryFile()
    persistence.write_uint32(output_file, savefile_id)
    persistence.write_uint16(output_file, 4)
    persistence.write_uint32(output_file, save_count)

    while input_file.tell() < file_size:
        # This should be pretty straightforward.
        hunk_header_offset = input_file.tell()
        hunk_id = persistence.read_uint16(input_file)

def read_SegmentBlock(f):
    block = SegmentBlock()
    bytes_to_read = struct.calcsize(SEGMENTBLOCK_PACK_FORMAT)
    block.segment_id, block.segment_offset, block.address, block.length, block.flags, block.line_count, line_data_count = struct.unpack(SEGMENTBLOCK_PACK_FORMAT, f.read(bytes_to_read))

    if line_data_count > 0:
        if get_block_data_type(block) == DATA_TYPE_CODE:
            block.line_data = [ None ] * line_data_count
            for i in range(line_data_count):
                type_id = persistence.read_uint8(f)
                if type_id == SLD_INSTRUCTION:
                    block_offset = persistence.read_uint16(f)
                    block.line_data[i] = (type_id, block_offset)
                elif type_id == SLD_EQU_LOCATION_RELATIVE:
                    block_offset = persistence.read_uint32(f)
                    block.line_data[i] = (type_id, block_offset)
                elif type_id in (SLD_COMMENT_TRAILING, SLD_COMMENT_FULL_LINE):
                    text = persistence.read_string(f)
                    block.line_data[i] = (type_id, text)
    return block

def load_disassembly_hunk(f, program_data):
    program_data.branch_addresses = persistence.read_dict_uint32_to_set_of_uint32s(f)
    program_data.reference_addresses = persistence.read_dict_uint32_to_set_of_uint32s(f)
    program_data.symbols_by_address = persistence.read_dict_uint32_to_string(f)
    program_data.post_segment_addresses = persistence.read_dict_uint32_to_list_of_uint32s(f)
    program_data.flags = persistence.read_uint32(f)
    program_data.processor_id = persistence.read_uint32(f)

    # Reconstitute the segment block list.
    num_blocks = persistence.read_uint32(f)
    program_data.blocks = [ None ] * num_blocks
    for i in range(num_blocks):
        program_data.blocks[i] = read_SegmentBlock(f)

    ## POST PROCESSING
    # Rebuild the segment block list indexing lists.
    program_data.block_addresses = [ 0 ] * num_blocks
    program_data.block_line0s_dirtyidx = 0
    program_data.block_line0s = program_data.block_addresses[:]
    for i in range(num_blocks):
        program_data.block_addresses[i] = program_data.blocks[i].address

if hunk_id != SAVEFILE_HUNK_DISASSEMBLY:
            input_file.seek(hunk_header_offset, os.SEEK_SET)
            raw_hunk_length = (hunk_payload_offset - hunk_header_offset) + hunk_length
            output_file.write(input_file.read(raw_hunk_length))
            continue

        ## 1. Load the hunk payload.
        branch_addresses = persistence.read_dict_uint32_to_set_of_uint32s(input_file)
        reference_addresses = persistence.read_dict_uint32_to_set_of_uint32s(input_file)
        symbols_by_address = persistence.read_dict_uint32_to_string(input_file)
        post_segment_addresses = persistence.read_dict_uint32_to_list_of_uint32s(input_file)
        flags = persistence.read_uint32(input_file)
        processor_name = persistence.read_string(input_file)

        # Reconstitute the segment block list.
        num_blocks = persistence.read_uint32(input_file)
        input_file_offset = input_file.tell()
        block_data_length = hunk_length - (input_file_offset - hunk_payload_offset)
        block_data_string = input_file.read(block_data_length)
        #blocks = [ None ] * num_blocks
        #for i in range(num_blocks):
        #    blocks[i] = read_SegmentBlock(input_file)
        ## 2. Write the generic hunk header, then the payload, then fill in the header.

        # Only these two are likely to have been in use.
        if processor_name == "m68k":
            processor_id = loaderlib.constants.PROCESSOR_M680x0
        elif processor_name == "mips":
            processor_id = loaderlib.constants.PROCESSOR_MIPS
        else:
            logger.error("convert_project_format_3_to_4: unrecognised arch name %s", processor_name)
            return None

f = new_f
            logger.info("load_project: save file upgraded to version %d", savefile_version)
            continue
        break

    logger.debug("bfile %s", f)
    program_data = ProgramData()
    program_data.save_count = persistence.read_uint32(f)

    sourcedata_offset = sourcedata_length = None
    while f.tell() < file_size:
        if work_state is not None and work_state.check_exit_update(0.1 + 0.8 * (file_size-f.tell()), "TEXT_LOAD_READING_PROJECT_DATA"):
            return None

        hunk_id = persistence.read_uint16(f)
        hunk_length = persistence.read_uint32(f)
        expected_hunk_version = CURRENT_HUNK_VERSIONS[hunk_id]
        offset0 = f.tell()
        actual_hunk_version = persistence.read_uint16(f)
        if SAVEFILE_HUNK_DISASSEMBLY == hunk_id:
            load_disassembly_hunk(f, program_data)
        elif SAVEFILE_HUNK_LOADER == hunk_id:
            load_loader_hunk(f, program_data)
        elif SAVEFILE_HUNK_LOADERINTERNAL == hunk_id:
            load_loaderinternaldata_hunk(f, program_data)
        elif SAVEFILE_HUNK_SOURCEDATAINFO == hunk_id:
            load_sourcedatainfo_hunk(f, program_data)
        elif SAVEFILE_HUNK_SOURCEDATA == hunk_id:
            skip_bytes = (f.tell() - offset0)
            sourcedata_offset, sourcedata_length = offset0 + skip_bytes, hunk_length - skip_bytes
            f.seek(sourcedata_length, os.SEEK_CUR)
        else:

def read_segment_list_entry(f):
    v = [ None ] * loaderlib.SIZEOF_SI
    v[loaderlib.SI_TYPE] = persistence.read_uint8(f)
    offset_value = persistence.read_uint32(f)
    if offset_value == 0xFFFFFFFF: # Unsigned, special value.
        offset_value = -1
    v[loaderlib.SI_FILE_OFFSET] = offset_value
    v[loaderlib.SI_DATA_LENGTH] = persistence.read_uint32(f)
    v[loaderlib.SI_LENGTH] = persistence.read_uint32(f)
    v[loaderlib.SI_ADDRESS] = persistence.read_uint32(f)
    return v