package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
	"strings"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, 10*1024*1024)
	if !scanner.Scan() {
		return
	}
	s := strings.TrimSpace(scanner.Text())
	n2 := len(s)
	if n2%2 != 0 {
		return
	}
	n := n2 / 2

	masks := []int{63, 6, 91, 79, 102, 109, 125, 7, 127, 111}

	w := func(x, y int) int {
		return bits.OnesCount(uint(masks[x] & masks[y]))
	}
	pop := func(x int) int {
		return bits.OnesCount(uint(masks[x]))
	}

	T0 := make([]int, n2)
	for i := 0; i < n2; i++ {
		T0[i] = int(s[i] - '0')
	}

	prefA := make([]int, n+1)
	prefB := make([]int, n+1)

	for i := 0; i < n; i++ {
		prefA[i+1] = prefA[i] + w(T0[i], T0[n+i])
		prefB[i+1] = prefB[i] + pop(T0[i])
	}

	L_orig := prefA[n]

	var bestI, bestD int = -1, -1

	for i := n2 - 1; i >= 0; i-- {
		for d := T0[i] + 1; d <= 9; d++ {
			maxL := 0
			if i < n {
				maxL = prefB[i] + pop(d) + 7*(n-1-i)
			} else {
				m := i - n
				maxL = prefA[m] + w(T0[m], d) + (prefB[n] - prefB[m+1])
			}
			if maxL > L_orig {
				bestI = i
				bestD = d
				break
			}
		}
		if bestI != -1 {
			break
		}
	}

	if bestI == -1 {
		fmt.Println("-1")
		return
	}

	T := make([]int, n2)
	copy(T, T0)
	T[bestI] = bestD

	curPopSum := 0
	if bestI < n {
		for k := 0; k <= bestI; k++ {
			curPopSum += pop(T[k])
		}
	}

	var suffPop []int
	if bestI < n {
		suffPop = make([]int, n+1)
	} else {
		suffPop = make([]int, n+1)
		for k := n - 1; k >= 0; k-- {
			suffPop[k] = suffPop[k+1] + pop(T[k])
		}
	}

	curWSum := 0
	if bestI >= n {
		for k := 0; k <= bestI-n; k++ {
			curWSum += w(T[k], T[n+k])
		}
	}

	for j := bestI + 1; j < n2; j++ {
		if j < n {
			for d := 0; d <= 9; d++ {
				maxL := curPopSum + pop(d) + 7*(n-1-j)
				if maxL > L_orig {
					T[j] = d
					curPopSum += pop(d)
					break
				}
			}
		} else {
			if j == n {
				for k := n - 1; k >= 0; k-- {
					suffPop[k] = suffPop[k+1] + pop(T[k])
				}
				curWSum = 0
			}
			m := j - n
			for d := 0; d <= 9; d++ {
				maxL := curWSum + w(T[m], d) + suffPop[m+1]
				if maxL > L_orig {
					T[j] = d
					curWSum += w(T[m], d)
					break
				}
			}
		}
	}

	out := make([]byte, n2)
	for i := 0; i < n2; i++ {
		out[i] = byte(T[i] + '0')
	}
	fmt.Println(string(out))
}