'use strict'

class Main {
  solve() {
    const size = input.nextIntArr();
    const edges = input.nextIntRange(size[1]);
    console.log(new Graph().from(edges,1).bridges.length);
  }
}

class Graph {
  constructor() { }

  from(edgeList, offset) {
    if (offset) {
      this.edgeList = edgeList.map((e) => 
        [e[0] - offset, e[1] - offset]
      );
    }
    else {
      this.edgeList = edgeList;
    }

    this.list = [];
    for (const n of this.edgeList) {
      this.list[n[0]]
      this.list[n[0]] = this.list[n[0]] ? this.list[n[0]] : [];
      this.list[n[1]] = this.list[n[1]] ? this.list[n[1]] : [];
      this.list[n[0]].push(n[1]);
      this.list[n[1]].push(n[0]);
    }
    return this;
  }

  get bridges() {
    if (this._bridges) {return this._bridges;}
    const used_v = [];
    const used_e = [];
    const ord = new Array(this.length).fill(0);
    const lowlink = new Array(this.length).fill(0);
    let k = 0;
    const dfs = (v) => {
      used_v[v] = true;
      ord[v] = lowlink[v] = k;
      ++k;
      for (const _v of this.list[v]) {
        if (!used_v[_v]) {
          used_e[v+','+_v] = true;
          dfs(_v);
          lowlink[v] = Math.min(lowlink[v],lowlink[_v]);
        }
        else if (!used_e[_v+','+v]) {
          // backward
          lowlink[v] = Math.min(lowlink[v], ord[_v]);
        }
      } 
    }
    dfs(0);
    this._bridges = this.edgeList.filter(e => ord[e[0]] < lowlink[e[1]]
    || ord[e[1]] < lowlink[e[0]]);
    return this._bridges;
  }

  get eSize() { return this.edgeList.length; } 
  get length() { return this.list.length; }

  get matrix() {
    if (this.matrix) {return this.matrix;}
    this.matrix = [];
    for (let i = 0; i < this.length; ++i) {
      for (let j = 0; j < this.length; ++j) {
        this.matrix[i][j] = 0;
      } 
    }

    for(const e1 in this.list) {
      const l = this.list[e1];
      for(const e2 of l) {
        this.matrix[e1][e2] = 1;
      }
    } 
    return this.matrix;
  }
}

class Underscore {
  sum(arr) { return arr.reduce((a,b)=>a+b); }
  min(arr, func) { if (func == null) {func = (a,b) => a - b} return arr.reduce((a,b) => func(a,b) < 0 ? a : b); }
  max(arr, func) { if (func == null) {func = (a,b) => a - b} return arr.reduce((a,b) => func(a,b) > 0 ? a : b); }
  sort(arr, func) { if (func == null) {func = (a,b) => a - b} return arr.sort(func) }
  range(start, stop, step) {
	if (stop == null) {
	  stop = start || 0;
	  start = 0;
	}
	if (!step) {
	  step = stop < start ? -1 : 1;
	}
	const length = Math.max(Math.ceil((stop - start) / step), 0);
	const range = Array(length);

	for (var idx = 0; idx < length; idx++, start += step) {
	  range[idx] = start;
	}
	return range;
  }

  first (array, n) {
    if (array == null || array.length < 1) return n == null ? void 0 : [];
    if (n == null) return array[0];
    return this.initial(array, array.length - n);
  };

  initial (array, n) { return array.slice.call(array, 0, Math.max(0, array.length - (n == null ? 1 : n))); }

  tail(array, n) { return array.slice.call(array, n == null ? 1 : n); }

  last (array, n) { 
    if (n == null) return array[array.length - 1];
    return this.tail(array, Math.max(0, array.length - n)); 
  }

  /* 累積和 */
  sumArray (arr) { return this.tail(arr.reduce(((a,b,i) => {a.push(b + a[i]); return a}), [0])); }

  binarySearch (array, key, iteratee) {
	const itr = (obj) => (typeof obj === 'object') ? obj[iteratee] : obj;
	const value = itr(obj);
	let low = 0, high = array.length;
	while (low < high) {
	  let mid = Math.floor((low + high) / 2);
	  if (itr(array[mid]) < value) low = mid + 1; else high = mid;
	}
	return low;
  };
}
const _ = new Underscore();

class Input {
  constructor() {
	this.cursor = 0;
	this.inputAll();
  }

  inputAll() {
	this.data = (require("fs").readFileSync("/dev/stdin", "utf8")).split('\n');
	return this.data;
  }

  /* 1行 or 複数行文字列 */
  nextLine(n) {
	if (n) {
	  const ret = this.data.slice(this.cursor, this.cursor + n);
	  this.cursor += n;
	  return ret;
	}
	return this.data[this.cursor++];
  }
  /* 一行文字配列 */
  nextStrArr() { return this.nextLine().split(' '); } 
  /* 一行整数配列 */
  nextIntArr() { return this.nextStrArr().map((e) => parseInt(e)); }
  /* 一行浮動小数点配列 */
  nextFloatArr() { return this.nextStrArr().map((e) => parseFloat(e)); }
  /* 複数行整数配列 */
  nextIntLine(n) { return this.nextLine(n).map((e) => parseInt(e)) }
  /* 複数行浮動小数点配列 */
  nextFloatLine(n) { return this.nextLine(n).map((e) => parseFloat(e)) }
  /* 複数行文字列二次元配列 */
  nextStrRange(n) { return this.nextLine(n).map((line) => line.split(' ')); }
  /* 複数行整数二次元配列 */
  nextIntRange(n) {
	return this.nextLine(n).map((line) => line.split(' ').map((e) => parseInt(e)));
  }
  /* 複数行浮動小数点数二次元配列 */
  nextFloatRange(n) {
	return this.nextLine(n).map((line) => line.split(' ').map((e) => parseFloat(e)));
  }
} 
const input = new Input();
(new Main()).solve();
