//*****************************************************************************/
// include
//*****************************************************************************/
#include <stdio.h>
#include <string.h>

//*****************************************************************************/
// define
//*****************************************************************************/
#define MIN_STRLEN ( ( int ) 1 )
#define MAX_STRLEN ( ( int ) 20000 )

//*****************************************************************************/
// struct
//*****************************************************************************/
typedef struct
{
	int index;	// idxStackからPOPしたインデックス
	int area;	// 水たまりの面積
}AREA;

//*****************************************************************************/
// プロトタイプ宣言
//*****************************************************************************/
int checkStringLength( int length );
void pushIdxStack( int* pIdxStack, int index, int* pSp );
void pushAreaStack( AREA* pAreaStack, int index, int area, int* pSp );
int popIdxStack( int* pIdxStack, int* pSp );
void mergeArea( AREA* pAreaStack, int* pSp );

//*****************************************************************************/
// @brief  メイン関数
// @param  無し
// @return 正常終了なら0、異常終了なら-1
//*****************************************************************************/
int main( void )
{
	int i = 0;							// ループカウンタ
	char string[MAX_STRLEN+1] = {};		// 入力文字列を格納する配列
	int length = 0;						// 入力文字列の長さ(終端文字を含まない)
	int totalArea = 0;					// 水たまりの総面積
	
	int idxStack[MAX_STRLEN];			// インデックス格納用スタック
	AREA areaStack[MAX_STRLEN];			// 水たまり面積格納用スタック
	int popIdx = 0;						// スタックからPOPしたインデックス
	int spIdxStack = 0;					// idxStackのスタックポインタ
	int spAreaStack = 0;				// areaStackのスタックポインタ
	
	// スタックの初期化
	memset( &idxStack[0], 0, sizeof(idxStack) );
	memset( &areaStack[0], 0, sizeof(areaStack) );
	
	// 入力文字列を取得
	scanf( "%s", &string[0] );
	length = strlen( &string[0] );
	
	// 入力文字列の制約チェック
	if( checkStringLength( length ) == -1 )
	{
		return -1;
	}
	
	// 入力1文字ごとの判定処理
	for( i = 0; i < length; i++ )
	{
		switch( string[i] )
		{
		// 入力が「\」
		case '\\':
			pushIdxStack( &idxStack[0], i, &spIdxStack );
			break;
			
		// 入力が「/」
		case '/' :
			// スタックが空
			if( spIdxStack == 0 ){ break; }
			
			popIdx = popIdxStack( &idxStack[0], &spIdxStack );
			totalArea += ( i - popIdx );
			pushAreaStack( &areaStack[0], popIdx, i - popIdx, &spAreaStack );
			mergeArea( &areaStack[0], &spAreaStack );
			break;
			
		// 入力が「_」
		default:
			break;
		}
	}
	
	// 水たまりの総面積を出力
	printf( "%d\n", totalArea );
	
	if( spAreaStack == 0 )
	{
		// 水たまりが存在しない
		printf( "%d\n", spAreaStack );
	}
	else
	{
		// 水たまりの数を出力
		printf( "%d ", spAreaStack );
		
		// 水たまりごとの面積を出力
		for( i = 0; i < spAreaStack - 1; i++ )
		{
			printf( "%d ", areaStack[i].area );
		}
		printf( "%d\n", areaStack[spAreaStack-1].area );
	}
	return 0;
}

//*****************************************************************************/
// @brief  入力文字列の長さチェック
// @param  \0, \nを除いた入力文字列の長さ
// @return 制約内なら0、制約違反なら-1
//*****************************************************************************/
int checkStringLength( int length )
{
	return ( ( length < MIN_STRLEN ) || ( length > MAX_STRLEN ) ) ? -1 : 0;
}

//*****************************************************************************/
// @brief  idxStackに入力文字列のインデックスをPUSHする
// @param  pIdxStack: idxStackの先頭アドレス
// @param  index: PUSHするインデックス
// @param  pSp: idxStackのスタックポインタ
// @return 無し
//*****************************************************************************/
void pushIdxStack( int* pIdxStack, int index, int* pSp )
{
	pIdxStack[*pSp] = index;
	(*pSp)++;
}

//*****************************************************************************/
// @brief  areaStackにインデックスと水たまりの面積をPUSHする
// @param  pAreaStack: areaStackの先頭アドレス
// @param  index: PUSHするインデックス
// @param  area: PUSHする水たまりの面積
// @param  pSp: areaIndexのスタックポインタ
// @return 無し
//*****************************************************************************/
void pushAreaStack( AREA* pAreaStack, int index, int area, int* pSp )
{
	pAreaStack[*pSp].index = index;
	pAreaStack[*pSp].area = area;
	(*pSp)++;
}

//*****************************************************************************/
// @brief  idxStackからインデックスをPOPする
// @param  pIdxStack: idxStackの先頭アドレス
// @param  pSp: idxStackのスタックポインタ
// @return POPしたインデックス
//*****************************************************************************/
int popIdxStack( int* pIdxStack, int* pSp )
{
	(*pSp)--;
	return pIdxStack[*pSp];
}

//*****************************************************************************/
// @brief  水たまりの面積を結合する
// @param  pAreaStack: areaStackの先頭アドレス
// @param  pSp: areaStackのスタックポインタ
// @return 無し
//*****************************************************************************/
void mergeArea( AREA* pAreaStack, int* pSp )
{
	int i = 0;

	for( i = (*pSp) - 1; i > 0; i-- )
	{
		// idxStackからPOPしたインデックス＜areaStackにPUSHしたインデックスなら、
		// 水たまりの面積を結合する
		if( pAreaStack[i].index < pAreaStack[i-1].index )
		{
			(*pSp)--;
			pAreaStack[i-1].index = pAreaStack[i].index;
			pAreaStack[i-1].area += pAreaStack[i].area;
		}
	}
}



Measured memory_bytes: 2140