use std::collections::VecDeque;
use std::env;
//use std::fmt::Debug;
use std::io;
use std::io::prelude::*;
//use std::time::{Duration, Instant};

//===================================================
// MACROs need to be defined above the use place ... ?
macro_rules! dprintln {
    ($($x:expr),*) => {{
        if $crate::is_debug_mode() {
            let f = || {println!( $($x),*)};
            f()
        }
    }}
}

/// Backward For-Loop Helper
///  from -> to (exclude `to`)
///
/// # Examples
/// see tests::macro_backward()
///
#[macro_export]
macro_rules! backward_ho {
    ($from:expr, $to:expr) => {{
        (($to + 1)..($from + 1)).rev()
    }};
}
//===================================================

fn main() {
    // Initialize
    set_debug_mode(false);
    for arg in env::args() {
        if arg == "--debug" {
            set_debug_mode(true);
        }
    }
    dprintln!("[DebugMode] {}", "On");

    // Execute
    dprintln!("=================");
    dprintln!("= READ INPUT     ");
    let stdin = io::stdin();
    let input = Input::new(stdin.lock());
    dprintln!("[Input] \n{:?}", input);
    dprintln!("=================");
    dprintln!("= INTERPRET INPUT");
    let q = input.into_quiz();
    dprintln!("[Quiz] \n{:?}", q);
    dprintln!("=================");
    dprintln!("= SOLVE QUIZE    ");
    let a = q.solve();
    dprintln!("[Answer] \n{:?}", a);
    dprintln!("=================");
    dprintln!("= PRINT ANSWER   ");
    a.print();
    dprintln!("=================");
}

#[derive(Debug)]
enum LandShape {
    Down,
    Up,
    Plane,
}


#[derive(Debug)]
struct Quiz {
    v: Vec<LandShape>, // 1<= v.len <= 200,000
}

#[derive(Debug)]
struct Answer {
    sum: u32,
    v: Vec<u32>,
}

impl<R: BufRead> Input<R> {
    fn into_quiz(mut self) -> Quiz {
        use LandShape::*;
        let s: String = self.parse_next().unwrap();
        let mut v = Vec::new();
        for c in s.chars() {
            let shape = match c {
                '/' => Up,
                '\\' => Down,
                '_' => Plane,
                _ => panic!("Parse error"),
            };
            v.push(shape);
        }
        Quiz { v }
    }
}

#[derive(Debug,Copy,Clone)]
enum Record {
    DownSlope(usize),
    Puddle(u32),
}

impl Quiz {
    fn solve(self) -> Answer {
        let mut ans_v = Vec::new();
        let mut stack: Vec<Record> = Vec::new();

        for (idx, shape) in self.v.into_iter().enumerate() {
            dprintln!("{} {:?}", idx, shape);
            dprintln!(" stack {:?}", stack);
            match shape {
                LandShape::Down => stack.push(Record::DownSlope(idx)),
                LandShape::Plane => (),
                LandShape::Up   => {
                    let mut tv = Vec::new();
//                    while let Some(r) = stack.pop() {
//                        if let Record::Puddle(size) = r {
//                            tv.push(size);
//                        } else {
//                            stack.push(r);
//                            break;
//                        }
//                    }
                    loop {
                        match stack.last() {
                            Some(&Record::Puddle(size)) => {
                                stack.pop();
                                tv.push(size);
                            },
                            _ => break,
                        }
                    }

                    if let Some(Record::DownSlope(left)) = stack.pop() {
                        dprintln!("  puddle! {} -> {}, includes {:?}", left, idx, tv);
                        let sum_tv = tv.iter().fold(0, |s,x| s+x);
                        let size = (idx - left) as u32 + sum_tv;
                        stack.push(Record::Puddle(size));
                    } else {
                        dprintln!("  independent puddles {:?}", tv);
                        tv.reverse();
                        for e in tv.into_iter() {
                            ans_v.push(e);
                        }
                    }
                },
            }
        }
        for e in stack {
            if let Record::Puddle(size) = e {
                ans_v.push(size);
            }
        }

        let sum = ans_v.iter().fold(0, |cur, &x| cur+x);

        Answer { 
            sum: sum,
            v: ans_v
        }
    }
}

impl Answer {
    fn print(self) {
        println!("{}", self.sum);
        if self.v.len() > 0 {
            println!("{} {}", self.v.len(), concat_vec_to_string(&self.v));
        } else {
            println!("0");
        }
    }
}

// =====================================================
// =
// =====================================================

//==================================================
// Stdin Reader
#[derive(Debug)]
pub enum Token {
    Word(String),
    LineBreak,
}

impl Token {
    pub fn is_word(&self) -> bool {
        match *self {
            Token::Word(ref _x) => true,
            _ => false,
        }
    }
}

#[derive(Debug)]
pub struct Input<R: BufRead> {
    input: R,
    tokens: VecDeque<Token>,
}

impl<R: BufRead> Input<R> {
    pub fn new(input: R) -> Self {
        let tokens = VecDeque::new();

        Input { input, tokens }
    }

    pub fn read_next_word(&mut self) -> Option<Token> {
        loop {
            match self.tokens.pop_front() {
                None => {
                    // Read Input
                    let mut line = String::new();
                    let n = self.input.read_line(&mut line).expect("Read Error.");
                    if n == 0 {
                        return None;
                    }
                    let mut line_tokens = tokenaize(line);
                    self.tokens.append(&mut line_tokens);
                }
                Some(Token::LineBreak) => (),
                x => return x,
            }
        }
    }

    pub fn parse_next<T>(&mut self) -> Option<T>
    where
        T: std::str::FromStr,
    {
        if let Some(Token::Word(str)) = self.read_next_word() {
            match str.parse() {
                Ok(x) => Some(x),
                _ => None,
            }
        } else {
            None
        }
    }

    pub fn parse_next_vec<T>(&mut self, size: usize) -> Option<Vec<T>>
    where
        T: std::str::FromStr,
    {
        let mut v = Vec::new();

        for _i in 0..size {
            if let Some(t) = self.parse_next() {
                v.push(t);
            } else {
                return None;
            }
        }

        Some(v)
    }

    pub fn parse_next_vec2<T>(&mut self, size2: usize, size1: usize) -> Option<Vec<Vec<T>>>
    where
        T: std::str::FromStr,
    {
        let mut v = Vec::new();

        for _i in 0..size2 {
            if let Some(t) = self.parse_next_vec(size1) {
                v.push(t);
            } else {
                return None;
            }
        }

        Some(v)
    }

    pub fn parse_all_remaining_into_vec<T>(&mut self) -> Vec<T>
    where
        T: std::str::FromStr,
    {
        let mut v = Vec::new();

        loop {
            match self.parse_next() {
                Some(x) => v.push(x),
                None => return v,
            }
        }
    }
}

fn tokenaize(str: String) -> VecDeque<Token> {
    let mut v = VecDeque::new();

    for w in str.split_whitespace() {
        v.push_back(Token::Word(w.to_string()));
    }
    v.push_back(Token::LineBreak);
    v
}

//==================================================
// Utility Functions
pub fn concat_vec_to_string<T>(v: &Vec<T>) -> String
where
    T: std::fmt::Display,
{
    let mut string = String::with_capacity(v.len() * 2);

    if let Some((h, t)) = v.split_first() {
        string = h.to_string();

        for obj in t {
            string.push(' ');
            string.push_str(&obj.to_string());
        }
    }

    return string;
}

//==================================================
// Debug Switch
static mut S_DEBUG_MODE: bool = false;
fn is_debug_mode() -> bool {
    unsafe { S_DEBUG_MODE }
}

fn set_debug_mode(mode: bool) {
    unsafe {
        S_DEBUG_MODE = mode;
    }
}

//==================================================
// Usage
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn macro_backward() {
        let mut v = Vec::new();
        for i in backward_ho!(5, 1) {
            v.push(i);
        }
        assert_eq!(vec![5, 4, 3, 2], v);
    }
}



Measured memory_bytes: 5056