#include <iostream>
#include <vector>
#include <algorithm>

struct Player;
bool CompPower(Player fir, Player sec);
bool CompNumbers(Player fir, Player sec);
void PrintNums(std::vector<Player> data, int left, int right);
void Merge(std::vector<Player> &res, int ii, int jj, int mm, bool comp(Player, Player));
void MergeSort(std::vector<Player> &data, int ii, int jj, bool comp(Player, Player));

struct Player {
    int64_t power;
    int num;
};

bool CompPower(Player fir, Player sec) {
    return fir.power <= sec.power;
}

bool CompNumbers(Player fir, Player sec) {
    return  fir.num <= sec.num;
}

void PrintNums(std::vector<Player> data, int left, int right) {

    for (int k = left; k <= right; ++k) {
        std::cout << data[k].num << ' ';
    }
}

void Merge(std::vector<Player> &res, int ii, int jj, int mm, bool comp(Player, Player)) {

    std::vector<Player> left(mm - ii + 1), right(jj - mm);
    std::copy(res.begin() + ii, res.begin() + mm + 1, left.begin());
    std::copy(res.begin() + mm + 1, res.begin() + jj + 1, right.begin());
    int r_ind  = 0, l_ind = 0, res_ind = ii;
    int r_size = right.size(), l_size = left.size();
    while (r_ind < r_size && l_ind < l_size) {
        if (comp(left[l_ind] , right[r_ind])) {
            res[res_ind] = left[l_ind];

            ++l_ind;
        } else {
            res[res_ind] = right[r_ind];
            ++r_ind;
        }
        ++res_ind;
    }
    while (l_ind < l_size) {
        res[res_ind] = left[l_ind];
        ++res_ind;
        ++l_ind;
    }
    while (r_ind < r_size) {
        res[res_ind] = right[r_ind];
        ++res_ind;
        ++r_ind;
    }
}

void MergeSort(std::vector<Player> &data, int ii, int jj, bool comp(Player, Player) ) {
    if (ii < jj) {
        int middle =  ii + (jj - ii) / 2;
        MergeSort(data, ii, middle, comp);
        MergeSort(data, middle + 1, jj, comp);
        Merge(data, ii, jj, middle, comp);
    }
}

int main() {
    int nn, inp;
    std::cin >> nn;
    std::vector<Player> data(nn);
    for (int i = 0; i < nn; ++i) {
        std::cin >> inp;
        data[i].power = inp;
        data[i].num = i + 1;
    }
    MergeSort(data, 0, nn - 1, CompPower);
    int left = 0, right = 0;
    int64_t sum = data[0].power, max_sum = data[0].power;
    while (right < nn - 1) {
        if (data[right + 1].power <= data[left].power + data[left + 1].power) {
            sum += data[right + 1].power;
            ++right;
        } else {
            max_sum = std::max(sum, max_sum);
            sum -= data[left].power;
            ++left;
        }
    }
    max_sum = std::max(sum, max_sum);
    std::cout << max_sum << '\n';
    MergeSort(data, left, right, CompNumbers);
    PrintNums(data, left, right);
    return 0;
}