Problem:
Score : 700 points

Problem Statement

You have an integer sequence of length N: a_1, a_2, ..., a_N.

You repeatedly perform the following operation until the length of the sequence becomes 1:

First, choose an element of the sequence.

If that element is at either end of the sequence, delete the element.

If that element is not at either end of the sequence, replace the element with the sum of the two elements that are adjacent to it. Then, delete those two elements.

You would like to maximize the final element that remains in the sequence.

Find the maximum possible value of the final element, and the way to achieve it.

Constraints

All input values are integers.

2 \leq N \leq 1000

|a_i| \leq 10^9

Input

Input is given from Standard Input in the following format:

N
a_1 a_2 ... a_N

Output

In the first line, print the maximum possible value of the final element in the sequence.

In the second line, print the number of operations that you perform.

In the (2+i)-th line, if the element chosen in the i-th operation is the x-th element from the left in the sequence at that moment, print x.

If there are multiple ways to achieve the maximum value of the final element, any of them may be printed.

Sample Input 1

5
1 4 3 7 5

Sample Output 1

11
3
1
4
2

The sequence would change as follows:

After the first operation: 4, 3, 7, 5

After the second operation: 4, 3, 7

After the third operation: 11(4+7)

Sample Input 2

4
100 100 -1 100

Sample Output 2

200
2
3
1

After the first operation: 100, 200(100+100)

After the second operation: 200

Sample Input 3

6
-1 -2 -3 1 2 3

Sample Output 3

4
3
2
1
2

After the first operation: -4, 1, 2, 3

After the second operation: 1, 2, 3

After the third operation: 4

Sample Input 4

9
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000

Sample Output 4

5000000000
4
2
2
2
2

Solution in Haskell (GHC 7.10.3) (judge verdict: Wrong Answer)

import qualified Data.ByteString.Lazy.Char8 as B
import Data.Maybe
import Data.List
-- import qualified Data.Vector.Unboxed as VU
-- import qualified Data.Vector.Unboxed.Mutable as VUM
-- import Control.Monad
-- import Control.Monad.ST
-- import Debug.Trace

naive0 [x] = x
naive0 xs = maximum [sub k xs | k <- [0..length xs - 1]]
  where
    sub k xs | k == 0 = naive0 (tail xs)
             | k == (length xs) - 1 = naive0 (init xs)
             | otherwise = naive0 ((init ys) ++ ((last ys) + z) : zs)
               where (ys, (_:z:zs)) = splitAt k xs

solve :: Int -> [Int] -> (Int, [Int])
solve n as | as_max <= 0 = noPlus n as_max as
           | otherwise   = somePlus n as
  where as_max = maximum as

noPlus n as_max as = (as_max, replicate k 1 ++ replicate (n-k-1) 2)
  where k = length $ takeWhile (< as_max) as

somePlus n as = (bVal, opList)
  where
    eLen = (n+1) `div` 2
    oLen = n `div` 2
    (es, os) = f $ partition fst $ zip (cycle [True,False]) as
      where f (x,y) = (map snd x, map snd y)
    (eVal, eMax) = myScan es
    (oVal, oMax) = myScan os
    initCut | odd n && eVal > oVal = []
            | odd n                = [n, 1]
            |          eVal > oVal = [n]
            | otherwise            = [1]
    (seq, bVal, bMax) = if eVal > oVal then (es, eVal, eMax)
                                       else (os, oVal, oMax)
    (part1, part2a) = span (<= 0) seq
    (part3r, part2r) = span (<= 0) $ reverse part2a
    part2 = reverse part2r
    opList = initCut ++ replicate (2 * k1) 1 ++ zs ++ replicate (2 * k3) 2
      where
        k1 = length part1
        k3 = length part3r
        zs = map (\x -> if x <= 0 then 3 else 2) (tail part2)

myScan as = (sum (map (max 0) as), maximum as)

readBInt :: B.ByteString -> Int
readBInt = fst . fromJust . B.readInt

tmain :: B.ByteString -> (Int, [Int])
tmain cont =
  let remLines0 = map B.words (B.lines cont)
      [bs_n]:remLines1 = remLines0
      n = readBInt bs_n
      line2:remLines2 = remLines1
      as = map readBInt line2
  in solve n as

outAnswer :: (Int, [Int]) -> IO ()
outAnswer (bVal, opList) = do
  putStrLn $ show $ bVal
  putStrLn $ show $ length $ opList
  putStr $ unlines $ map show opList

main :: IO ()
main = outAnswer . tmain =<< B.getContents