fn main() {
  let (n, m): (usize, usize) = get::read_tuple();
  let mut edges: Vec<(usize, usize)> = get::read_tuples(m);

  for i in 0..m {let (a,b) = edges[i]; edges[i] = (a-1,b-1)}
  let graph: Graph = Graph::new_nonlabeled(n, &edges[..]);
  
  let mut ans = 0;
  for (v, w) in edges {
    let mut g = graph.clone();
    g.cut(v,w);
    ans += if g.is_connected() {0} else {1};
  }
  
  println!("{}", ans);
}

struct Graph {
  adj: Vec<Vec<(usize,isize)>>
}

impl Clone for Graph {
  fn clone(&self) -> Graph {
    Graph {adj: self.adj.clone()}
  }
}

impl Graph {
  #[allow(dead_code)]
  fn new_nonlabeled(n: usize, edges: &[(usize,usize)]) -> Graph {
    let mut g: Vec<Vec<(usize,isize)>> = vec![vec![]; n];
    for &(a, b) in edges {
      g[a].push((b,0));
      g[b].push((a,0));
    }
    Graph {adj: g}
  }
  
  #[allow(dead_code)]
  fn cut(&mut self, v: usize, w: usize) {
    self.adj[v].retain(|&(t,_)| t != w);
    self.adj[w].retain(|&(t,_)| t != v);
  }
  
  #[allow(dead_code)]
  fn is_connected(&self) -> bool {
    self.dfs(0).len() == self.adj.len()
  }
  
  #[allow(dead_code)]
  fn dfs(&self, s: usize) -> Vec<(usize)> {
    fn go(g: &Graph, current: usize, mut path: &mut Vec<usize>, mut visited: &mut Vec<bool>) {
      for &(next, _) in &g.adj[current] {
        if visited[next] {
          continue
        } else {
          visited[next] = true;
          path.push(next);
          go(&g, next, &mut path, &mut visited)
        }
      }
    }
    let mut path = vec![s];
    let mut visited = vec![false; self.adj.len()];
    visited[s] = true;
    go(&self, s, &mut path, &mut visited);
    path
  }
}

mod get {
  use std::io::*;
  use std::str::*;

  #[allow(dead_code)]
  pub fn read<T: FromStr>() -> T {
    let mut buf = String::new();
    stdin().read_line(&mut buf).ok();
    buf.trim().parse::<T>().ok().unwrap()
  }

  #[allow(dead_code)]
  pub fn reads<T: FromStr>(n: usize) -> Vec<T> {
    let mut vec: Vec<T> = vec![];
    for _ in 0 .. n {
      vec.push(read());
    }
    vec
  }

  #[allow(dead_code)]
  pub fn read_tuple<T1: FromStr, T2: FromStr>() -> (T1, T2) {
    let mut buf = String::new();
    stdin().read_line(&mut buf).ok();
    let mut it = buf.trim().split_whitespace();
    let x = it.next().unwrap().parse::<T1>().ok().unwrap();
    let y = it.next().unwrap().parse::<T2>().ok().unwrap();
    (x, y)
  }

  #[allow(dead_code)]
  pub fn read_tuples<T1: FromStr, T2: FromStr>(n: usize) -> Vec<(T1, T2)> {
    let mut vec: Vec<(T1, T2)> = vec![];
    for _ in 0 .. n {
      vec.push(read_tuple());
    }
    vec
  }

  #[allow(dead_code)]
  pub fn read_vec<T: FromStr>() -> Vec<T> {
    let mut buf = String::new();
    stdin().read_line(&mut buf).ok();
    buf.trim().split_whitespace().map(|t| t.parse::<T>().ok().unwrap()).collect()
  }

  #[allow(dead_code)]
  pub fn read_mat<T: FromStr>(h: usize) -> Vec<Vec<T>> {
    let mut mat: Vec<Vec<T>> = vec![];
    for _ in 0 .. h {
      mat.push(read_vec());
    }
    mat
  }
}

mod put {
  use std::string::*;

  #[allow(dead_code)]
  pub fn print_vec<T: ToString>(vec: &Vec<T>, sep: &str) {
    let out = vec.iter().map(|e| e.to_string()).collect::<Vec<_>>().as_slice().join(sep);
    println!("{}", out);
  }

  #[allow(dead_code)]
  pub fn print_mat<T: ToString>(mat: &Vec<Vec<T>>, sep: &str) {
    for v in mat {
      print_vec(v, sep);
    }
  }
}

Measured memory_bytes: 4352