#include <iostream>

int partition(long long int* array, int* ind_array, int l, int r)
{
    int i, j, tmp, tmp_ind, pivot;
    pivot = array[(l + r) / 2];
    tmp = 0;

    while (true) {
        while (array[l] < pivot)
            l += 1;
        while (array[r] > pivot)
            r -= 1;

        if (l >= r)
            return r;

        tmp_ind = ind_array[l];
        ind_array[l] = ind_array[r];
        ind_array[r] = tmp_ind;

        tmp = array[l];
        array[l] = array[r];
        array[r] = tmp;
        l += 1;
        r -= 1;
    }
}

void quickSort(long long int* array, int* ind_array, int l, int r)
{
    if (l < r) {
        int q = partition(array, ind_array, l, r);
        quickSort(array, ind_array, l, q);
        quickSort(array, ind_array, q + 1, r);
    }
}

int main()
{
    int n, R, L;
    long long int max_sum, min_sum, curr_sum;
    int res_L, res_R;
    std::cin >> n;
    long long int a[n];
    int ind_array[n];

    for (int i = 0; i < n; ++i) {
        std::cin >> a[i];
        ind_array[i] = i + 1;
    }

    quickSort(a, ind_array, 0, n - 1);

    R = 0;
    max_sum = a[0];
    curr_sum = a[0];

    for (L = 0; L < n; ++L) {

        if (L == (n - 1)) {
            min_sum = a[L];
        }
        else
            min_sum = a[L] + a[L + 1];

        while ((R < (n - 1)) && (a[R + 1] <= min_sum)) {
            R += 1;
            curr_sum += a[R];
        }

        if (curr_sum > max_sum) {
            max_sum = curr_sum;
            res_L = L;
            res_R = R;
        }

        curr_sum -= a[L];
    }

    int len = (res_R - res_L + 1);
    for (int i = 0; i < len; ++i) {
        a[i] = ind_array[res_L + i];
    }

    quickSort(a, ind_array, 0, len - 1);

    std::cout << max_sum << std::endl;
    for (int i = 0; i < len; ++i)
        std::cout << a[i] << " ";

    return 0;
}