#include <iostream>
#include <vector>
#include <random>
#include <assert.h>
#include <algorithm>
#include <chrono>


struct Player {
    int number = 0;
    int efficiency = 0;
};

bool CompareByEfficiency(const Player& lhs, const Player& rhs) {
    return (lhs.efficiency == rhs.efficiency) ?
        lhs.number < rhs.number : lhs.efficiency < rhs.efficiency;
}

bool CompareByNumber(const Player& lhs, const Player& rhs) {
    return (lhs.number == rhs.number) ?
        lhs.efficiency < rhs.efficiency : lhs.number < rhs.number;
}

void Merge(std::vector<Player>::iterator first_begin,
                          std::vector<Player>::iterator first_end,
                          std::vector<Player>::iterator second_begin,
                          std::vector<Player>::iterator second_end,
                          std::vector<Player>* merged_vector_destination,
                          bool compare(const Player&, const Player&)) {

    while (first_begin < first_end &&
           second_begin < second_end) {
        if (compare(*first_begin, *second_begin)) {
            merged_vector_destination->push_back(*first_begin);
            ++first_begin;
        } else {
            merged_vector_destination->push_back(*second_begin);
            ++second_begin;
        }
    }
    while (first_begin < first_end) {
        merged_vector_destination->push_back(*first_begin);
        ++first_begin;
    }
    while (second_begin < second_end) {
        merged_vector_destination->push_back(*second_begin);
        ++second_begin;
    }
}

void Sort(std::vector<Player>::iterator first_player,
          std::vector<Player>::iterator last_player,
          bool compare(const Player&, const Player&) = CompareByEfficiency) {

    int64_t vector_size = std::distance(first_player, last_player);
    std::vector<Player> merged;

    if (vector_size > 1) {
        Sort(first_player, first_player + vector_size / 2, compare);
        Sort(first_player + (vector_size / 2), last_player, compare);

        Merge(first_player, first_player + vector_size / 2,
              first_player + vector_size / 2, last_player,
              &merged,
              compare);

        std::copy(merged.begin(), merged.end(), first_player);
        merged.clear();
    }
}

int64_t ComputeTeamEfficiency(std::vector<Player> team) {
    int total_team_efficiency = 0;
    for (const auto& player : team) {
        total_team_efficiency += player.efficiency;
    }
    return total_team_efficiency;
}

bool IsConsistent(const std::vector<Player>::iterator& team_begin,
                  const std::vector<Player>::iterator& team_end) {
    if (std::distance(team_begin, team_end) < 3) {
        return true;
    }
    return std::prev(team_end)->efficiency <=
           team_begin->efficiency + std::next(team_begin)->efficiency;
}

std::vector<Player> FindMostEfficientSolidaryTeam(const std::vector<Player>& all_players) {
    std::vector<Player> sorted_by_efficiency = all_players;

    std::sort(sorted_by_efficiency.begin(), sorted_by_efficiency.end(), CompareByEfficiency);

    auto current_team_begin = sorted_by_efficiency.begin();
    auto current_team_end = std::next(sorted_by_efficiency.begin());

    auto best_team_begin = current_team_begin;
    auto best_team_end = current_team_end;

    int64_t current_team_efficiency = sorted_by_efficiency[0].efficiency;
    int64_t best_team_efficiency  = current_team_efficiency;

    while (current_team_end < sorted_by_efficiency.end()) {

        while (IsConsistent(current_team_begin, current_team_end)) {

            if (current_team_efficiency > best_team_efficiency) {
                best_team_efficiency = current_team_efficiency;
                best_team_begin = current_team_begin;
                best_team_end = current_team_end;
            }

            if (current_team_end < sorted_by_efficiency.end()) {
                current_team_efficiency += current_team_end->efficiency;
                ++current_team_end;
            } else {
                break;
            }
        }

        while (current_team_begin < current_team_end &&
               !IsConsistent(current_team_begin, current_team_end)) {

            current_team_efficiency -= current_team_begin->efficiency;
            ++current_team_begin;
        }

        if (current_team_efficiency > best_team_efficiency) {
            best_team_efficiency = current_team_efficiency;
            best_team_begin = current_team_begin;
            best_team_end = current_team_end;
        }
    }

    std::vector<Player> best_team(best_team_begin, best_team_end);
    std::sort(best_team.begin(), best_team.end(), CompareByNumber);
    return best_team;
}

std::vector<Player> LoadAllPlayers() {
    int players_count = 0;
    std::cin >> players_count;
    Player player;

    std::vector<Player> all_players;
    for (int player_index = 0; player_index < players_count; ++player_index) {
        player.number = player_index + 1;
        std::cin >> player.efficiency;
        all_players.push_back(player);
    }

    return all_players;
}

void PrintBestTeam(const std::vector<Player>& team) {
    std::cout << ComputeTeamEfficiency(team) << "\n";
    for (auto player : team) {
        std::cout << player.number << " ";
    }
}

int main() {

    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    auto best_team = FindMostEfficientSolidaryTeam(LoadAllPlayers());
    PrintBestTeam(best_team);

    return 0;
}