func_code_string: #include <bits/stdc++.h>   using namespace std;   using ll = long long;   namespace io {   const int SIZE = (1 << 21) + 1;   char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1;   inline char getc() {     return (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),                         (iS == iT ? EOF : *iS++))                      : *iS++);   }   inline void flush() {     fwrite(obuf, 1, oS - obuf, stdout);     oS = obuf;   }   inline void putc(char x) {     *oS++ = x;     if (oS == oT) flush();   }   template <class T>   inline void read(T &x) {     char ch;     int f = 1;     x = 0;     while (isspace(ch = getc()))       ;     if (ch ==  - ) ch = getc(), f = -1;     do x = x * 10 + ch -  0 ;     while (isdigit(ch = getc()));     x *= f;   }   template <class T, class... Args>   inline void read(T &x, Args &...args) {     read(x);     read(args...);   }   template <class T>   inline void write(T x) {     static char stk[128];     int top = 0;     if (x == 0) {       putc( 0 );       return;     }     if (x < 0) putc( - ), x = -x;     while (x) stk[top++] = x % 10, x /= 10;     while (top) putc(stk[--top] +  0 );   }   template <class T, class... Args>   inline void write(T x, Args... args) {     write(x);     putc(   );     write(args...);   }   inline void space() { putc(   ); }   inline void endl() { putc(  n ); }   struct _flush {     ~_flush() { flush(); }   } __flush;   };  // namespace io   using io::endl;   using io::flush;   using io::getc;   using io::putc;   using io::read;   using io::space;   using io::write;   const int M = 1000000007;   inline int add(int x, int y) { return x + y >= M ? x + y - M : x + y; }   template <class... Args>   inline int add(int x, int y, Args... args) {     return add(add(x, y), args...);   }   inline int sub(int x, int y) { return x - y < 0 ? x - y + M : x - y; }   inline int mul(int x, int y) { return 1LL * x * y % M; }   template <class... Args>   inline int mul(int x, int y, Args... args) {     return mul(mul(x, y), args...);   }   inline void inc(int &x, int y = 1) {     x += y;     if (x >= M) x -= M;   }   inline void dec(int &x, int y = 1) {     x -= y;     if (x < 0) x += M;   }   inline int power(int x, int y) {     int res = 1;     for (; y; y >>= 1, x = mul(x, x))       if (y & 1) res = mul(res, x);     return res;   }   inline int inv(int x) { return power(x, M - 2); }   const int N = 4005;   int _g[N * 2], *g = _g + N;   int n, m;   struct DP {     int a[N * 2];     int *f;     DP() {       f = a + N;       fill(f - m, f + m + 1, 0);       f[0] = 1;     }     void update(int x) {       fill(g - m, g + m + 1, 0);       for (int i = -m + x; i <= m - x; ++i) g[i - x] = (g[i - x] + f[i]) % M;       for (int i = -m + x; i <= m - x; ++i) g[i + x] = (g[i + x] + f[i]) % M;       for (int i = -m; i <= m; ++i) f[i] = (f[i] + g[i]) % M;     }     void select(int x) {       fill(g - m, g + m + 1, 0);       for (int i = -m + x; i <= m; ++i) g[i - x] = (g[i - x] + f[i]) % M;       for (int i = -m; i <= m - x; ++i) g[i + x] = (g[i + x] + f[i]) % M;       for (int i = -m; i <= m; ++i) f[i] = g[i];     }     void operator=(const DP &r) {       for (int i = -m; i <= m; ++i) f[i] = r.f[i];     }     int query(int x) {       int res = 0;       for (int i = 2 - x; i <= x - 2; ++i) inc(res, f[i]);       return res;     }   };   vector<int> G[N];   int a[N];   bool vis[N];   DP f;   DP stk[20];   int top = 0;   int dfs(int x, int fa) {     vis[x] = true;     for (int v : G[x]) {       if (v == fa) continue;       if (v == 1) return 1;       return dfs(v, x) + 1;     }     return 1;   }   int res = 0;   void solve(int l, int r) {     if (l == r) {       inc(res, f.query(a[l]));       return;     }     stk[top] = f;     ++top;     int mid = (l + r) >> 1;     for (int i = l; i <= mid; ++i) f.update(a[i]);     solve(mid + 1, r);     f = stk[top - 1];     for (int i = mid + 1; i <= r; ++i) f.update(a[i]);     solve(l, mid);     --top;   }   void solve2(int l, int r) {     if (l == r) {       inc(res, add(f.f[a[l]], f.f[a[l] - 1], f.f[1 - a[l]], f.f[-a[l]]));       inc(res, add(f.f[a[l]], f.f[a[l] - 1], f.f[1 - a[l]], f.f[-a[l]]));       return;     }     stk[top] = f;     ++top;     int mid = (l + r) >> 1;     for (int i = l; i <= mid; ++i) f.select(a[i]);     solve2(mid + 1, r);     f = stk[top - 1];     for (int i = mid + 1; i <= r; ++i) f.select(a[i]);     solve2(l, mid);     --top;   }   int main() {     read(n, m);     for (int i = 1; i <= m; ++i) {       int u, v;       read(u, v);       G[u].push_back(v);       G[v].push_back(u);     }     int cnt = 0;     for (int v : G[1]) {       if (!vis[v]) a[++cnt] = dfs(v, 1) + 1;     }     solve(1, cnt);     res = mul(res, 2);     if ((m & 1) == 0) {       f = DP();       for (int i = 1; i <= cnt; ++i) f.select(a[i]);       inc(res, f.f[0]);     } else {       f = DP();       solve2(1, cnt);     }     write(res), endl();     return 0;   }   