#define SAVE_MAJOR_VERSION 5

                continue

                raise

};
enum tag_major_version
{
    TAG_MAJOR_START = 5,
    TAG_MAJOR_VERSION = 5

enum tag_minor_version
{
    TAG_MINOR_PIETY = 2,        // Added piety_hysteresis
    TAG_MINOR_QUIVER = 3,       // Added quiver
    TAG_MINOR_MAPMARK = 4,      // Added sizes to map markers
    TAG_MINOR_VERSION = 4       // Current version
};

    if (minorVersion >= 3) ASSERT(count_c == 0);

    if (minorVersion >= TAG_MINOR_QUIVER)
        ASSERT(count_c == 0);

    if (minorVersion >= 2)

    if (minorVersion >= TAG_MINOR_PIETY)

    if (minorVersion >= 3)

    if (minorVersion >= TAG_MINOR_QUIVER)

    env.markers.read(th);

    env.markers.read(th, minorVersion);

TAG_MAJOR_VERSION = 5
TAG_MINOR_VERSION = 4

    def __init__(self, f):

    def __init__(self, f, minor):
        if minor >= 4:
            expected_size = f.stream1('I')
        num_read = -f.file.tell()

        num_read += f.file.tell()

        if minor >= 4:
            assert num_read == expected_size

        print '  version %d.%d' % (self.major, self.minor)
        if (self.major != TAG_MAJOR_VERSION or
            self.minor > TAG_MINOR_VERSION):
            print "  WARNING: Cannot handle this version!"

                print "  Found %s (currently unsupported)" % tag_name

                print "  Skipping %s" % tag_name

                print "  Found %s (parsing)" % tag_name

                print "  Parsing %s" % tag_name

        self.cloud_no = f.stream1('H')

        self.markers = [ MapMarker(f) for x in xrange(f.stream1('H')) ]

        if minor >= 4:
            cooky = f.stream1('I')
            assert cooky == 0x17742C32
        self.markers = [ MapMarker(f, minor) for x in xrange(f.stream1('H')) ]

static const long MARKERS_COOKY = 0x17742C32;

    // how many markers

    marshallLong(outf, MARKERS_COOKY);
    std::vector<unsigned char> buf;

        i->second->write(outf);

        buf.clear();
        writer tmp_outf(&buf);
        i->second->write(tmp_outf);
        // Write the marker data, prefixed by a size
        marshallLong(outf, buf.size());
        outf.write(&buf[0], buf.size());

void map_markers::read(reader &inf)

void map_markers::read(reader &inf, int minorVersion)

    if (minorVersion >= TAG_MINOR_MAPMARK)
    {
        const long cooky = unmarshallLong(inf);
        ASSERT(cooky == MARKERS_COOKY);
    }

    {
        // used by tools
        if (minorVersion >= TAG_MINOR_MAPMARK)
            unmarshallLong(inf);

        {

        }
    }

static void save_level(int level_saved, level_area_type lt,
                       branch_type where_were_you);

void save_level(int level_saved, level_area_type lt,
                branch_type where_were_you);

static bool _get_and_validate_version(FILE *restoreFile, char& major, char& minor,
                                      std::string* reason=0);

#define GHOST_MINOR_VERSION 1
#define LEVEL_MINOR_VERSION 1

// 1: starting version
// 2: append piety_hysteresis to TAG_YOU
// 3: add quiver info.
#define YOU_MINOR_VERSION   3

static bool determine_ghost_version( FILE *ghostFile,
                                     char &majorVersion, char &minorVersion );
static void restore_ghost_version( FILE *ghostFile, char major, char minor );

static void restore_tagged_file( FILE *restoreFile, int fileType,
                                 char minorVersion );
static void load_ghost();

static bool determine_version( FILE *restoreFile,
                               char &majorVersion, char &minorVersion );

static void restore_version( FILE *restoreFile,
                             char majorVersion, char minorVersion );
static bool determine_level_version( FILE *levelFile,
                                     char &majorVersion, char &minorVersion );
static void restore_level_version( FILE *levelFile,
                                   char majorVersion, char minorVersion );
static bool determine_ghost_version( FILE *ghostFile,
                                     char &majorVersion, char &minorVersion );
static void restore_ghost_version( FILE *ghostFile,
                                   char majorVersion, char minorVersion );
static void restore_tagged_file( FILE *restoreFile, int fileType,
                                 char minorVersion );
static void load_ghost();

    char majorVersion = 0;
    char minorVersion = 0;

    char majorVersion;
    char minorVersion;

    if (determine_version(charf, majorVersion, minorVersion)
        && majorVersion == SAVE_MAJOR_VERSION)

    if (_get_and_validate_version(charf, majorVersion, minorVersion))

static void write_version( FILE *dataFile, int majorVersion, int minorVersion,

static void _write_version( FILE *dataFile, int majorVersion, int minorVersion,

static void write_tagged_file( FILE *dataFile, char majorVersion,
                               char minorVersion, int fileType,
                               bool extended_version = false )

static void _write_tagged_file( FILE *outf, int fileType,
                                bool extended_version = false )

    write_version( dataFile, majorVersion, minorVersion, extended_version );

    _write_version( outf, TAG_MAJOR_VERSION, TAG_MINOR_VERSION,
                    extended_version );

            tag_write((tag_type)i, dataFile);

        {
            tag_write((tag_type)i, outf);
        }

    // BEGIN -- must load the old level : pre-load tasks

    // LOAD various tags

    if (!determine_level_version( levelFile, majorVersion, minorVersion )
            || majorVersion != SAVE_MAJOR_VERSION)

    if (!_get_and_validate_version( levelFile, majorVersion, minorVersion ))

        char majorVersion = 0;
        char minorVersion = 0;

        char majorVersion;
        char minorVersion;

        if (!determine_level_version( levelFile, majorVersion, minorVersion ))

        std::string reason;
        if (!_get_and_validate_version( levelFile, majorVersion, minorVersion, &reason ))

            end(-1, false, "\nLevel file appears to be invalid.\n");

            end(-1, false, "\nLevel file is invalid.  %s\n",
                reason.c_str());

        restore_level_version( levelFile, majorVersion, minorVersion );

        restore_tagged_file(levelFile, TAGTYPE_LEVEL, minorVersion);

    write_tagged_file( saveFile, SAVE_MAJOR_VERSION,
                       LEVEL_MINOR_VERSION, TAGTYPE_LEVEL );

    _write_tagged_file( saveFile, TAGTYPE_LEVEL );

    write_tagged_file( charf, SAVE_MAJOR_VERSION,
                       YOU_MINOR_VERSION, TAGTYPE_PLAYER );

    _write_tagged_file( charf, TAGTYPE_PLAYER );

    if (majorVersion != SAVE_MAJOR_VERSION
        || minorVersion != GHOST_MINOR_VERSION)

    if (majorVersion != TAG_MAJOR_VERSION || minorVersion > TAG_MINOR_VERSION)

    char majorVersion = 0;
    char minorVersion = 0;

    if (!determine_version(charf, majorVersion, minorVersion))
        end(-1, false, "\nSavefile appears to be invalid.\n");

    char majorVersion;
    char minorVersion;
    std::string reason;
    if (!_get_and_validate_version(charf, majorVersion, minorVersion, &reason))
        end(-1, false, "\nSave file is invalid.  %s\n", reason.c_str());

    restore_version(charf, majorVersion, minorVersion);

    restore_tagged_file(charf, TAGTYPE_PLAYER, minorVersion);

static bool determine_version( FILE *restoreFile,
                               char &majorVersion, char &minorVersion )

static bool _get_and_validate_version(FILE *restoreFile, char &major, char &minor,
                                      std::string* reason)

    std::string dummy;
    if (reason == 0) reason = &dummy;

    {
        major = minor = -1;
        *reason = "File is corrupt.";

    }

    // otherwise, read version and validate.
    majorVersion = buf[0];
    minorVersion = buf[1];

    major = buf[0];
    minor = buf[1];

    if (majorVersion == SAVE_MAJOR_VERSION)
        return true;
    return false;   // if it's not 0, no idea
}
static void restore_version( FILE *restoreFile,
                             char majorVersion, char minorVersion )
{
    // assuming the following check can be removed once we can read all
    // savefile versions.
    if (majorVersion != SAVE_MAJOR_VERSION)

    if (major != TAG_MAJOR_VERSION)

        end(-1, false, "\nSorry, this release cannot read a v%d.%d savefile.\n",
            majorVersion, minorVersion);

        *reason = make_stringf("Major version mismatch: %d (want %d).", major, TAG_MAJOR_VERSION);
        return false;

    switch(majorVersion)

    if (minor >  TAG_MINOR_VERSION)

        case SAVE_MAJOR_VERSION:
            restore_tagged_file(restoreFile, TAGTYPE_PLAYER, minorVersion);
            break;
        default:
            break;

        *reason = make_stringf("Minor version mismatch: %d (want <= %d).", minor, TAG_MINOR_VERSION);
        return false;

    return true;

// generic v4 restore function

}
static bool determine_level_version( FILE *levelFile,
                                     char &majorVersion, char &minorVersion )
{
    // read first two bytes.
    char buf[2];
    if (read2(levelFile, buf, 2) != 2)
        return false;               // empty file?
    // otherwise, read version and validate.
    majorVersion = buf[0];
    minorVersion = buf[1];
    if (majorVersion == SAVE_MAJOR_VERSION)
        return true;
    return false;   // if its not SAVE_MAJOR_VERSION, no idea

static void restore_level_version( FILE *levelFile,
                                   char majorVersion, char minorVersion )
{
    // assuming the following check can be removed once we can read all
    // savefile versions.
    if (majorVersion != SAVE_MAJOR_VERSION)
    {
        end(-1, false,
            "\nSorry, this release cannot read a v%d.%d level file.\n",
            majorVersion, minorVersion);
    }
    switch(majorVersion)
    {
        case SAVE_MAJOR_VERSION:
            restore_tagged_file(levelFile, TAGTYPE_LEVEL, minorVersion);
            break;
        default:
            break;
    }
}

    if (majorVersion == SAVE_MAJOR_VERSION
        && minorVersion <= GHOST_MINOR_VERSION)

    if (majorVersion == TAG_MAJOR_VERSION
        && minorVersion <= TAG_MINOR_VERSION)

    return false;   // if its not SAVE_MAJOR_VERSION, no idea!

    return false;   // if its not TAG_MAJOR_VERSION, no idea!

    case SAVE_MAJOR_VERSION:

    case TAG_MAJOR_VERSION:

    write_tagged_file( gfile, SAVE_MAJOR_VERSION,
                       GHOST_MINOR_VERSION, TAGTYPE_GHOST,
                       true );

    _write_tagged_file( gfile, TAGTYPE_GHOST, true );

// XXX: remove?

    void read(reader &);

    void read(reader &, int minorVersion);