#include <iostream>
#include <fstream>
#include <vector>
#include <fstream>
#include <queue>
using namespace std;

ifstream in("joc4.in");
ofstream out("joc4.out");

const int MAXN = 250, INF = 2000000000;

vector <int> G[2*MAXN+1];

int N, M, A, B, answer = 0;

bool viz[2*MAXN+1];

int father[2*MAXN+1], c[2*MAXN+1][2*MAXN+1];

void zeroVizAndFather()
{
    for(int i = 1; i <= 2*N; i++)
    {
        father[ i ] = 0;
        viz[ i ] = false;
    }
}

void testReadData()
{
    for(int i = 1; i <= 2*N; i++)
    {
        cout<<i<<' '<<' ';

        for(int j = 0; j < G[ i ].size(); j++)
            cout<<G[ i ][ j ]<<' ';
        cout<<endl;
    }
}

void readData()
{

    in>>N>>M>>A>>B;

    for(int i = 1; i <= M; i++)
    {
        int x, y;
        in>>x>>y;
        G[ x + N ].push_back( y );
        G[ y + N ].push_back( x );
        c[ x + N ][ y ] = 1;
        c[ y + N ][ x ] = 1;
    }

    for(int i = 1; i <= N; i++)
    {
        G[ i ].push_back( i + N );
        c[ i ][ i + N ] = 1;
    }

    c[ A ][ A + N ] = INF;
    c[ B ][ B + N ] = INF;
}



bool findAugPaths(int nodeStart)
{
    zeroVizAndFather();

    queue <int> Q;
    Q.push( nodeStart );

    while( Q.empty() == false )
    {
        int currNode = Q.front();
        viz[ currNode ] = true;

        if( currNode == B + N )
            return true;

        for(int i = 0; i < G[ currNode ].size(); i++)
        {
            int nextNode = G[ currNode ][ i ];

            if( c[ currNode ][ nextNode ] > 0 && viz[ nextNode ] == false )
            {
                father[ nextNode ] = currNode;
                Q.push( nextNode );
            }
        }

        Q.pop();
    }

    return false;
}

void increaseFlow()
{
    int node = B + N;

    answer++;

    /*
    for( ; node != A; node = father[ node ] )
    {
        cout<<node<<' ';
    }

    cout<<node<<' ';

    cout<<endl;*

    node = B + N;*/

    for( ; node != A; node = father[ node ] )
    {
        c[ father[ node ] ][ node ]--;
        c[ node ][ father[ node ] ]++;
    }
}

void solve()
{
    while( findAugPaths( A ) == true )
    {
        for(int i = 0; i < G[ B + N ].size(); i++)
        {
            int node = G[ B + N ][ i ];

            if( father[ node + N ] != 0 && c[ node + N ][ N ] > 0  )
            {
                father[ N ] = node + N;
                increaseFlow();
            }
        }
    }
}



int main()
{
    readData();
    //testReadData();
    solve();
    out<<answer;
    return 0;
}