output_description: Print the number of _palindromic numbers_ among the integers between A and B
  (inclusive).
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      A B
attempt: 
  
  fn main() {
      let a: i32 = read();
      let b: i32 = read();
      let mut ans = 0;
      for i in a..b+1 {
          let s: String = i.to_string();
          let s: Vec<char> = s.chars().collect();
          if s[0] == s[4] && s[1] == s[3] {
              ans += 1;
          }
      }
      println!("{}", ans);
  }
  
  // 以下関数
  
  
  use std::io::*;
  use std::str::FromStr;
  pub fn read<T: FromStr>() -> T {
      let stdin = stdin();
      let stdin = stdin.lock();
      let token: String = stdin
          .bytes()
          .map(|c| c.expect("failed to read char") as char)
          .skip_while(|c| c.is_whitespace())
          .take_while(|c| !c.is_whitespace())
          .collect();
      token.parse().ok().expect("failed to parse token")
  }
  
  pub const MOD: u64 = 10e9 as u64 + 7;
  
  pub fn is_prime(n: i32) -> bool {
      if n < 2 {
          return false;
      } else if n == 2 {
          return true;
      }
      let mut i = 2;
      while i * i < n {
          if n % i == 0 {
              return false;
          } else {
              i += 1;
              continue;
          }
      }
      true
  }
  
  pub fn lcm(mut n: i32, mut m: i32) -> i32 {
      n = if n > m { m } else { n };
      m = if n > m { n } else { m };
      let mut i = n;
      while i % m != 0 {
          i += n;
      }
      i
  }
  
  pub fn abs(n: i32) -> i32 {
      if n >= 0 {
          n
      } else {
          -n
      }
  }
  
  pub fn max(n: i32, m: i32) -> i32 {
      if n >= m {
          n
      } else {
          m
      }
  }
  
  pub fn min(n: i32, m: i32) -> i32 {
      if n <= m {
          n
      } else {
          m
      }
  }
problem_description: Statement
  
  Find the number of _palindromic numbers_ among the integers between A and B
  (inclusive). Here, a palindromic number is a positive integer whose string
  representation in base 10 (without leading zeros) reads the same forward and
  backward.
samples: [{"input": "11009 11332", "output": "4\n    \n\nThere are four integers that satisfy the conditions: 11011, 11111, 11211 and\n11311.\n\n* * *"}, {"input": "31415 92653", "output": "612"}]