#include<iostream>

using namespace std;

int N, X;
string S;

int main() {
    cin >> N >> X >> S;
    int res = X;
    for (int i = 0; i < S.size(); i++) {
        if(S[i] == 'o')
            res++;
        if(S[i] == 'x') {
            res--;
            res = max(0, res);
        }
    }
    cout << res << endl;
}
/*  Jai Shree Ram 🚩🚩🚩 */
#include "bits/stdc++.h"
#define ll long long int
#define oo 1000000000000000000
#define forr(i,n) for(int i=0;i<n;i++)
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define all(x) x.begin(),x.end()
#define unique(v) sort(all(v)); v.resize(distance(v.begin(),unique(all(v))))
#define eb emplace_back
#define FF first
#define SS second
#define mem(a,v) memset(a,v,sizeof(a))
#define pb push_back
#define popcount(x) __builtin_popcount(x)

using namespace std;

template<typename T>
ostream &operator<<(ostream &output,const vector<T> &v){ 
    if(v.empty()) return output;
    for(int i=0;i<v.size()-1;i++) output << v[i] <<" ";
    output << v.back();
    return output;
}
template<typename T>
istream &operator>>(istream &input,vector<T> &v){ 
    for(auto &i: v) cin >> i;
    return input;            
}


template <int MOD=1000000007>
struct Modular {
    int value;
    static const int MOD_value = MOD;
 
    Modular(long long v = 0) { value = v % MOD; if (value < 0) value += MOD;}
    Modular(long long a, long long b) : value(0){ *this += a; *this /= b;}
 
    Modular& operator+=(Modular const& b) {value += b.value; if (value >= MOD) value -= MOD; return *this;}
    Modular& operator-=(Modular const& b) {value -= b.value; if (value < 0) value += MOD;return *this;}
    Modular& operator*=(Modular const& b) {value = (long long)value * b.value % MOD;return *this;}
 
    friend Modular mexp(Modular a, long long e) {
        Modular res = 1; while (e) { if (e&1) res *= a; a *= a; e >>= 1; }
        return res;
    }
 
    friend Modular inverse(Modular b, long long m = MOD) {
        long long u = 0, v = 1, a = b.value;
        while (a != 0) {
            long long t = m / a;
            m -= t * a; swap(a, m);
            u -= t * v; swap(u, v);
        }
        return Modular(u);
    }
 
    Modular& operator/=(Modular const& b) { return *this *= inverse(b); }
    friend Modular operator+(Modular a, Modular const b) { return a += b; }
    friend Modular operator-(Modular a, Modular const b) { return a -= b; }
    friend Modular operator-(Modular const a) { return 0 - a; }
    friend Modular operator*(Modular a, Modular const b) { return a *= b; }
    friend Modular operator/(Modular a, Modular const b) { return a /= b; }
    friend std::ostream& operator<<(std::ostream& os, Modular const& a) {return os << a.value;}
    friend bool operator==(Modular const& a, Modular const& b) {return a.value == b.value;}
    friend bool operator!=(Modular const& a, Modular const& b) {return a.value != b.value;}
};
using mint = Modular<>;


vector<mint> fac, inv;
void preFac(int _n){
    fac.resize(_n, 1);
    inv.resize(_n, 1);
    for (int i = 1; i < _n; ++i) fac[i] = i * fac[i-1];
    inv[_n-1] = mint(1, fac[_n-1].value);
    for (int i = _n-2; i >= 0; --i) inv[i] = (i+1) * inv[i+1];
}
 
mint nCr(int _n, int _r) {
    if (_r < 0 || _r > _n) return 0;
    return fac[_n] * inv[_r] * inv[_n-_r];
}
 
mint nPr(int _n, int _r) {
    if (_r < 0 || _r > _n) return 0;
    return fac[_n] * inv[_n-_r];
}

void __sol(){
    preFac(2e6+10);
    int n,m,k; cin >> n >> m >> k;
    if(n - m > k) cout << 0;
    else cout << nCr(n + m , m ) - nCr(n + m , m +  k + 1);
    return;
}


int main(){ 
    fastio;
    int tc=1;  // cin >> tc;
    while(tc--) __sol();
    return 0;
}