package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

func main() {
	reader := bufio.NewReaderSize(os.Stdin, 1024*1024)
	nStr, err := reader.ReadString('\n')
	if err != nil && err.Error() != "EOF" {
		return
	}
	nStr = strings.TrimSpace(nStr)
	if len(nStr) == 0 {
		return
	}

	MOD := int64(998244353)

	var N int64 = 0
	for i := 0; i < len(nStr); i++ {
		N = (N*2 + int64(nStr[i]-'0')) % MOD
	}
	N = (N + 1) % MOD

	var dp [8]int64
	dp[0] = 1

	comboA := [6]int{0, 0, 0, 1, 1, 1}
	comboB := [6]int{0, 0, 1, 0, 1, 1}
	comboC := [6]int{0, 1, 1, 0, 0, 1}

	for i := 0; i < len(nStr); i++ {
		n_i := int(nStr[i] - '0')
		var nextDp [8]int64

		for state := 0; state < 8; state++ {
			if dp[state] == 0 {
				continue
			}
			la := (state >> 2) & 1
			lb := (state >> 1) & 1
			lc := state & 1

			for j := 0; j < 6; j++ {
				a := comboA[j]
				b := comboB[j]
				c := comboC[j]

				if la == 0 && a > n_i {
					continue
				}
				if lb == 0 && b > n_i {
					continue
				}
				if lc == 0 && c > n_i {
					continue
				}

				nla := la
				if a < n_i {
					nla = 1
				}
				nlb := lb
				if b < n_i {
					nlb = 1
				}
				nlc := lc
				if c < n_i {
					nlc = 1
				}

				nstate := (nla << 2) | (nlb << 1) | nlc
				nextDp[nstate] += dp[state]
				if nextDp[nstate] >= MOD {
					nextDp[nstate] -= MOD
				}
			}
		}
		dp = nextDp
	}

	var S int64 = 0
	for state := 0; state < 8; state++ {
		S += dp[state]
	}
	S %= MOD

	part1 := (N * N % MOD) * N % MOD
	part2 := (3 * S) % MOD
	part3 := (3 * N % MOD) * N % MOD

	ans := (part1 - part2 + part3 - N) % MOD
	if ans < 0 {
		ans += MOD
	}

	fmt.Println(ans)
}