int branch;     // The branch in which the level is.
    int depth;      // What depth (in this branch - starting from 1)
    int level_type;

    branch_type branch;     // The branch in which the level is.
    int depth;              // What depth (in this branch - starting from 1)
    level_area_type level_type;

    level_id() : branch(0), depth(-1), level_type(LEVEL_DUNGEON) { }
    level_id(int br, int dep, int ltype = LEVEL_DUNGEON)

    level_id()
        : branch(BRANCH_MAIN_DUNGEON), depth(-1),
          level_type(LEVEL_DUNGEON)
    {
    }
    level_id(branch_type br, int dep, level_area_type ltype = LEVEL_DUNGEON)

            branch = depth = -1;

        {
            depth = -1;
            branch = NUM_BRANCHES;
        }

    level_id(int ltype) : branch(-1), depth(-1), level_type(ltype) { }

    level_id(level_area_type ltype)
        : branch(BRANCH_MAIN_DUNGEON), depth(-1), level_type(ltype)
    {
    }

        branch = 0;

        branch = BRANCH_MAIN_DUNGEON;

        return (branch != -1 && depth != -1) || level_type != LEVEL_DUNGEON;

        return (branch != NUM_BRANCHES && depth != -1)
            || level_type != LEVEL_DUNGEON;

    LevelInfo& get_level_info(unsigned char branch = 0, int depth = -1)

    LevelInfo& get_level_info(branch_type branch = BRANCH_MAIN_DUNGEON,
                              int depth = -1)

int find_parent_branch(int br)

branch_type find_parent_branch(branch_type br)

void find_parent_branch(int br, int depth, 
                        int *pb, int *pd)

void find_parent_branch(branch_type br, int depth, 
                        branch_type *pb, int *pd)

    const branch_type bran = static_cast<branch_type>(br);
    if ( stair_level.find(bran) == stair_level.end() )
    {
        *pb = 0;
        *pd = 0;        // Check depth before using *pb.
    }

    *pb = find_parent_branch(br);   // Check depth before using *pb.
    if ( stair_level.find(br) == stair_level.end() )
        *pd = 0;

    {
        // XXX XXX FIXME Just read this from our data...
        *pb = find_parent_branch(bran);
        *pd = stair_level[bran].depth;
    }

        *pd = stair_level[br].depth;

               int branch, int subdepth)

               branch_type branch, int subdepth)

        int pb;

        branch_type pb;

    cx->branch = 0;

    cx->branch = BRANCH_MAIN_DUNGEON;

    unsigned char branch = BRANCH_MAIN_DUNGEON;     // Default

    int branch = BRANCH_MAIN_DUNGEON;     // Default

    level_id curr = level_id::current();

        case CONTROL('P'):
            return find_parent_branch(curr.branch);

static int prompt_travel_depth(branch_type branch)

static int travel_depth_keyfilter(int &c)

    // Handle one-level branches by not prompting.
    if (single_level_branch(branch))
        return 1;
    char buf[100];
    int depth = get_nearest_level_depth(branch);
    snprintf(buf, sizeof buf, "What level of %s do you want to go to? "
            "[default %d] ", branches[branch].longname, depth);
    mesclr();
    mpr(buf, MSGCH_PROMPT);
    if (cancelable_get_line( buf, sizeof buf ))
        return 0;
    if (*buf)
        depth = atoi(buf);
    return depth;

    switch (c)
    {
    case '<': case '>':
        return (-1);
    case '-':
    case CONTROL('P'): case 'p':
        c = '-';  // Make uniform.
        return (-1);
    default:
        return (1);
    }

static bool is_hell_branch(int branch)

static bool is_easy_exiting_branch(int branch)

    return branch == BRANCH_DIS || branch == BRANCH_TARTARUS 
        || branch == BRANCH_COCYTUS || branch == BRANCH_GEHENNA;

    return branches[branch].any_upstair_exits;

static level_pos find_up_level()

static level_id find_up_level(level_id curr, bool up_branch = false)

    level_id curr = level_id::current();
    curr.depth--;

    --curr.depth;

    if (is_hell_branch(curr.branch))
    {
        curr.branch = BRANCH_VESTIBULE_OF_HELL;
        curr.depth  = 1;
        return (curr);
    }

    if (up_branch || is_easy_exiting_branch(curr.branch))
        curr.depth = 0;

        return level_pos();

        return level_id();

static level_pos find_down_level()

static level_id find_up_level()
{
    return (find_up_level(level_id::current()));
}
static level_id find_down_level(level_id curr)

    level_id curr = level_id::current();
    curr.depth++;

    if (curr.depth < branches[curr.branch].depth)
        ++curr.depth;

static level_id find_down_level()
{
    return (find_down_level(level_id::current()));
}
static void travel_depth_munge(int munge_method, branch_type *br, int *depth)
{
    level_id lid(*br, *depth);
    switch (munge_method)
    {
    case '<':
        lid = find_up_level(lid);
        break;
    case '>':
        lid = find_down_level(lid);
        break;
    case '-':
        lid = find_up_level(lid, true);
        break;
    }
    *br    = lid.branch;
    *depth = lid.depth;
    if (*depth < 1)
        *depth = 1;
}
static level_id prompt_travel_depth(const level_id &id)
{
    branch_type branch = id.branch;
    // Handle one-level branches by not prompting.
    // if (single_level_branch(branch))
    //    return level_id(branch, 1);
    int depth = get_nearest_level_depth(branch);
    for (;;)
    {
        mesclr();
        mprf(MSGCH_PROMPT, "What level of %s? "
             "(default %d) ", branches[branch].longname, depth);
        char buf[100];
        const int response =
            cancelable_get_line( buf, sizeof buf, get_number_of_cols(),
                                 NULL, travel_depth_keyfilter );
        if (!response)
        {
            if (*buf)
                depth = atoi(buf);
            return level_id(branch, depth);
        }
        
        if (response == ESCAPE)
            return level_id(BRANCH_MAIN_DUNGEON, 0);
        travel_depth_munge(response, &branch, &depth);
    }
}

    target.id.branch = branch;

    target.id.branch = static_cast<branch_type>(branch);

    target.id.depth =
        prompt_travel_depth(static_cast<branch_type>(target.id.branch));

    target.id = prompt_travel_depth(target.id);

    unsigned char gridc = grd[pos.x][pos.y];

    int gridc = grd[pos.x][pos.y];

            id.branch = i;

            id.branch = static_cast<branch_type>(i);

    branch     = readShort(file);

    branch     = static_cast<branch_type>(readShort(file));

    level_type = readShort(file);

    level_type = static_cast<level_area_type>(readShort(file));

    id.branch = unmarshallByte(th);

    id.branch = static_cast<branch_type>(unmarshallByte(th));

    id.level_type = unmarshallByte(th);

    id.level_type = static_cast<level_area_type>(unmarshallByte(th));

unsigned short get_packed_place( unsigned char branch, int subdepth,
                          char level_type );

unsigned short get_packed_place( branch_type branch, int subdepth,
                                 level_area_type level_type );

unsigned short get_packed_place( unsigned char branch, int subdepth,
                                 char level_type )

unsigned short get_packed_place( branch_type branch, int subdepth,
                                 level_area_type level_type )

        ( (branch << 8) | (subdepth & 0xFF) );

        ( (static_cast<int>(branch) << 8) | (subdepth & 0xFF) );

        place = (unsigned short) ( (level_type << 8) | 0xFF );

        place = (unsigned short) ( (static_cast<int>(level_type) << 8) | 0xFF );

    case CONTROL('G'):

        return (ch);

        return (CK_ESCAPE);

    char        level_type;         // what kind of level died on..
    char        branch;             // dungeon branch

    level_area_type level_type;     // what kind of level died on..
    branch_type branch;             // dungeon branch

    int kludge_branch(int branch_01) const;

    branch_type kludge_branch(int branch_01) const;

static int str_to_branch(const std::string &branch)

static branch_type str_to_branch(const std::string &branch)

            return (i);

            return (static_cast<branch_type>(i));

static int str_to_level_area_type(const std::string &s)

static level_area_type str_to_level_area_type(const std::string &s)

            return (i);

            return (static_cast<level_area_type>(i));

int scorefile_entry::kludge_branch(int branch_01) const

branch_type scorefile_entry::kludge_branch(int branch_01) const

    static int branch_map[] = {

    static branch_type branch_map[] = {

    level_type = hs_nextint(inbuf);

    level_type = static_cast<level_area_type>(hs_nextint(inbuf));

    level_type = 0;
    branch = 0;

    level_type = LEVEL_DUNGEON;
    branch = BRANCH_MAIN_DUNGEON;

    bool any_upstair_exits;     // any upstair exits the branch (Hell branches)

      8, 'D'
    },

      8, 'D', false },

      0, 'T' },

      0, 'T', false },

      20, 'O' },

      20, 'O', false },

      8, 'E' },

      8, 'E', false },

      5, 'L' },

      5, 'L', false },

      0, 'S' },

      0, 'S', false },

      0, 'A' },

      0, 'A', false },

      5, 'M' },

      5, 'M', false },

      10, 'P' },

      10, 'P', false },

      0, 'H' },

      0, 'H', false },

      5, 'V' },

      5, 'V', false },

      0, 'B' },

      0, 'B', false },

      5, 'C' },

      5, 'C', false },

      0, 'G' },

      0, 'G', false },

      0, 'U'
    },

      0, 'U', false },

      0, 'I'
    },

      0, 'I', true },

      0, 'N'
    },

      0, 'N', true },

      0, 'X'
    },

      0, 'X', true },

      0, 'Y'
    },

      0, 'Y', true },

      0, 'R'
    },

      0, 'R', false },

      0, '0'
    },

      0, '0', false },

      1, 'Z' },

      1, 'Z', false },

      0, 0
    }

      0, 0, false }