How to use the persistence.read_uint16 function in Persistence

persistence.write_uint16(output_file, hunk_id)
        output_file_length_offset = output_file.tell()
        persistence.write_uint32(output_file, 0)
        output_file_payload_offset = output_file.tell()
        persistence.write_uint16(output_file, SNAPSHOT_HUNK_VERSIONS[SAVEFILE_HUNK_LOADER] + 1)

        # Transform the hunk from input file to output file.
        persistence.write_string(output_file, persistence.read_string(input_file)) # loader_system_name
        data_size = persistence.read_uint32(input_file)
        persistence.write_uint32(output_file, data_size) # loader_segments
        output_file.write(input_file.read(data_size))
        set_value = persistence.read_set_of_uint32s(input_file)
        persistence.write_dict_uint32_to_list_of_uint32s(output_file, { k: [] for k in set_value }) # loader_relocated_addresses
        set_value = persistence.read_set_of_uint32s(input_file)
        persistence.write_set_of_uint32s(output_file, set_value) # loader_relocatable_addresses
        persistence.write_uint16(output_file, persistence.read_uint16(input_file)) # loader_entrypoint_segment_id
        persistence.write_int32(output_file, persistence.read_uint32(input_file)) # loader_entrypoint_offset

        # Update the header length field, then fast forward to the end of the hunk.
        new_hunk_length = output_file.tell() - output_file_payload_offset
        output_file.seek(output_file_length_offset, os.SEEK_SET)
        persistence.write_uint32(output_file, new_hunk_length)
        output_file.seek(new_hunk_length, os.SEEK_CUR)

        if output_file.tell() - output_file_payload_offset != new_hunk_length:
            logger.error("convert_project_format_4_to_5: block length mismatch %d != %d", output_file.tell() - output_file_payload_offset, new_hunk_length)
            return None

    return output_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)
        hunk_length = persistence.read_uint32(input_file)
        hunk_payload_offset = input_file.tell()

        actual_hunk_version = persistence.read_uint16(input_file)
        expected_hunk_version = SNAPSHOT_HUNK_VERSIONS[hunk_id]
        if expected_hunk_version != actual_hunk_version:
            logger.error("convert_project_format_3_to_4: hunk %d version mismatch %d != %d", hunk_id, expected_hunk_version, actual_hunk_version)
            return None
        logger.debug("convert_project_format_3_to_4: file hunk %d", hunk_id)

        # Copy unaffected hunks verbatim.
        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

- Inserts a version number into all hunks.
    """
    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 != 2:
        return None

    logger.info("Upgrading save-file from version 2 to version 3: Hunk versioning..")
    save_count = persistence.read_uint32(input_file)

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

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

def load_loader_hunk(f, program_data):
    program_data.loader_system_name = persistence.read_string(f)
    program_data.loader_segments = read_segment_list(f)
    program_data.loader_relocated_addresses = persistence.read_dict_uint32_to_set_of_uint32s(f)
    program_data.loader_relocatable_addresses = persistence.read_set_of_uint32s(f)
    program_data.loader_entrypoint_segment_id = persistence.read_uint16(f)
    program_data.loader_entrypoint_offset = persistence.read_uint32(f)

    ## POST PROCESSING
    program_data.loader_data_types = loaderlib.get_system_data_types(program_data.loader_system_name)

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

    logger.info("Upgrading save-file from version 2 to version 3: Hunk versioning..")
    save_count = persistence.read_uint32(input_file)

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

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

        input_hunk_length = persistence.read_uint32(input_file)
        output_length_offset = output_file.tell()
        persistence.write_uint32(output_file, 0)
        output_data_offset = output_file.tell()
        # Modification.
        persistence.write_uint16(output_file, SNAPSHOT_HUNK_VERSIONS[hunk_id])

        input_data = input_file.read(input_hunk_length)
        output_file.write(input_data)
        output_hunk_length = output_file.tell() - output_data_offset
        output_file.seek(output_length_offset, os.SEEK_SET)
        persistence.write_uint32(output_file, output_hunk_length)
        output_file.seek(output_hunk_length, os.SEEK_CUR)

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)

- 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)
        hunk_length = persistence.read_uint32(input_file)