Let's denote a function f(x) in such a way: we add 1 to x, then, while there is at least one trailing zero in the resulting number, we remove that zero. For example, 

  * f(599) = 6: 599 + 1 = 600 → 60 → 6; 
  * f(7) = 8: 7 + 1 = 8; 
  * f(9) = 1: 9 + 1 = 10 → 1; 
  * f(10099) = 101: 10099 + 1 = 10100 → 1010 → 101. 



We say that some number y is reachable from x if we can apply function f to x some (possibly zero) times so that we get y as a result. For example, 102 is reachable from 10098 because f(f(f(10098))) = f(f(10099)) = f(101) = 102; and any number is reachable from itself.

You are given a number n; your task is to count how many different numbers are reachable from n.

Input

The first line contains one integer n (1 ≤ n ≤ 10^9).

Output

Print one integer: the number of different numbers that are reachable from n.

Examples

Input


1098


Output


20


Input


10


Output


19

Note

The numbers that are reachable from 1098 are:

1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1098, 1099.
import java.io.BufferedInputStream;
import java.util.Scanner;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.ArrayList;
import java.util.Queue;
import java.util.LinkedList;
import java.util.Map.Entry;
import java.util.StringTokenizer;
import java.io.BufferedInputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.HashMap;
import java.util.Scanner;
public class Codeforces {
	static 	PrintWriter pw=new PrintWriter(System.out);
	
	public static void main(String [] args) throws IOException {
		Scanner sc=new Scanner(System.in);
		TreeSet<Integer> treeSet=new TreeSet<Integer>();
		int x=sc.nextInt();
		while(true) {
			if(treeSet.contains(1) && x==1) break;
		     treeSet.add(x++);
			while(x%10==0)
				x/=10;
		}
		//pw.println(treeSet);
		pw.println(treeSet.size());
		pw.flush();
		pw.close();
	}
	static class pair implements Comparable<pair>{
		String  name; int x,y ;
		String x1;
		public pair(String name , int x) {
			this.name=name; this.x=x;
		}
		public pair(String x1) {
			this.x1=x1;
		}
		public int compareTo(pair o) {
			if(x1.length()!=o.x1.length()) return x1.length()-o.x1.length();
			return x1.compareTo(o.x1);
		}
//		public int compareTo(pair o) {
//			if(!name.equals(o.name))
//				return name.compareTo(o.name);
//			return x-o.x;
//		}
//		public String toString() {
//			return name +" "+x;
//		}
		public String toString() {
			return x1;
		}
	}
   static class Scanner {
		StringTokenizer st;
		BufferedReader br;
 
		public Scanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}
 
		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}
 
		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
 
		public String nextLine() throws IOException {
			return br.readLine();
		}
 
		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
 
		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}
 
		public char nextChar() throws IOException {
			return next().charAt(0);
		}
 
		public Long nextLong() throws IOException {
			return Long.parseLong(next());
		}
 
		public boolean ready() throws IOException {
			return br.ready();
		}
 
		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
	}