#define NDEBUG
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <queue>
#include <string>
#include <vector>
#include <unistd.h>
using namespace std;
#define TRACE(x) cerr<<"# "#x<<endl;
#define DEBUG(x) cerr<<#x<<" = "<<(x)<<endl;
typedef unsigned long long ULL;
typedef long long LL;
const int INF = 0x7FFFFFFF;

class IO {
        #define IO_DEBUG_ENABLED 0
    public:
        IO() {
            buffer = new char[ BUFFER_SIZE ];
            bufferOut = new char[ BUFFER_SIZE ];
        }
        ~IO() {
            /* delete [] buffer; */
            flush();
        }
        inline void readChar(char * const c) {
            readIntoBuffer();
            *c = buffer[ bufferIndex ];
            ++bufferIndex;
        }
        void readUInt(unsigned int * const out) {
            unsigned int res = 0;
            char c;
            skipWC();
            readChar(&c);
            while( (c >= '0') && (c <= '9') ) {
                res *= 10;
                res += c - '0';
                readChar(&c);
            }
            *out = res;
        }
        void readULL(unsigned long long * const out) {
            unsigned long long res = 0;
            char c;
            skipWC();
            readChar(&c);
            while( (c >= '0') && (c <= '9') ) {
                res *= 10;
                res += c - '0';
                readChar(&c);
            }
            *out = res;
        }
        void readInt(int * const out) {
            int res = 0;
                int neg = 0;
            char c;
            skipWC();
            readChar(&c);
            if(c == '-') {
                neg = 1;
                c = '0';
            }
            #if IO_DEBUG_ENABLED
            else if( (c >= '0') && (c <= '9') ) {
            } else {
                fprintf(stderr, "readInt() ERROR unexpected char '%c' (decimal %d)\n", c, static_cast<int>(c));
            }
            #endif
            while( (c >= '0') && (c <= '9') ) {
                res *= 10;
                res += c - '0';
                readChar(&c);
            }
            *out = (0 == neg) ? res : -res;
        }
        void readLL(long long * const out) {
            long long res = 0;
                int neg = 0;
            char c;
            skipWC();
            readChar(&c);
            if(c == '-') {
                neg = 1;
                c = '0';
            }
            #if IO_DEBUG_ENABLED
            else if( (c >= '0') && (c <= '9') ) {
            } else {
                fprintf(stderr, "readLL() ERROR unexpected char '%c' (decimal %d)\n", c, static_cast<int>(c));
            }
            #endif
            while( (c >= '0') && (c <= '9') ) {
                res *= 10;
                res += c - '0';
                readChar(&c);
            }
            *out = (0 == neg) ? res : -res;
        }
        void readLine(char * const dst) {
            char c;
            char *d = dst;
            readChar(&c);
            while(c > 13) { // while((c!=10) && (c!=13) && (c!=0))
                *d = c;
                ++d;
                readChar(&c);
            }
            if(c == 13) { // skip (forget) EOL characters
                readChar(&c);
                if(c != 10) {
                    --bufferIndex; // next char after '/r' is not '/n' - it is unexpected but try to accept as valid EOL
                    #if IO_DEBUG_ENABLED
                    fprintf(stderr, __FUNCTION__ "() ERROR unexpected char (ASCII 0x%x) (decimal %d)\n", static_cast<int>(c), static_cast<int>(c));
                    #endif
                }
            }
            *d = 0;
        }
        char* readString(char * const dst) {
            char c;
            char *d = dst;
            skipWC();
            readChar(&c);
            while((c > 13) && (c != ' ')) {	// Read only "printable" characters
                *d = c;
                ++d;
                readChar(&c);
            }
            *d = 0;
            return d;
        }
        void readString(char * const dst, bool * const isNextCharEOL) {
            readString(dst);
            char c = buffer[bufferIndex-1];
            if((c != 10) && (c != 13) && (c != 0))
                *isNextCharEOL = false;
            else
                *isNextCharEOL = true;
        }
        inline void flush() {
            if(bufferOutIndex > 0) {
                write(1, bufferOut, bufferOutIndex);
                bufferOutIndex = 0;
            }
        }
        inline void writeChar(char c) {
            if(bufferOutIndex >= BUFFER_SIZE) {
                flush();
            }
            bufferOut[ bufferOutIndex++ ] = c;
        }
        inline void writeString(const char *str) {
            for(const char *src = str; *src ;++src) {
                writeChar(*src);
            }
        }

        inline void writeU32(unsigned x) {
            char lbuf[10];
            if((bufferOutIndex+sizeof(lbuf)) >= BUFFER_SIZE) {
                flush();
            }
            if(x) {
                unsigned len=0;
                while(x) {
                    unsigned d = x / 10;
                    lbuf[ ++len ] = '0' + static_cast<char>(x - 10*d);
                    x = d;
                }
                while(len) {
                    bufferOut[ bufferOutIndex++ ] = lbuf[ len-- ];
                }
            } else {
                bufferOut[ bufferOutIndex++ ] = '0';
            }
        }

        inline void writeU64(ULL x) {
            char lbuf[20];
            if((bufferOutIndex+sizeof(lbuf)) >= BUFFER_SIZE) {
                flush();
            }
            if(x) {
                unsigned len=0;
                while(x) {
                    ULL d = x / 10ULL;
                    lbuf[ ++len ] = '0' + static_cast<char>(x - 10ULL*d);
                    x = d;
                }
                while(len) {
                    bufferOut[ bufferOutIndex++ ] = lbuf[ len-- ];
                }
            } else {
                bufferOut[ bufferOutIndex++ ] = '0';
            }
        }

    protected:
        inline void readIntoBuffer() {
            if(bufferIndex >= bytesRead) {
                buffer[0] = 0; // make the first characted white-char => readChar() does not check bytesRead
                bytesRead = read(0, buffer, BUFFER_SIZE);
                bufferIndex = 0;
            }
        }
        inline void skipWC() {
            char *cPtr;
            do {
                readIntoBuffer();
                cPtr = buffer + bufferIndex;
                while( (bufferIndex < bytesRead) && ((*cPtr == 10) || (*cPtr == ' ') || (*cPtr == 13))) {
                    ++bufferIndex;
                    ++cPtr;
                }
            } while((bufferIndex >= bytesRead) && (bytesRead > 0));
        }
    private:
        const unsigned int BUFFER_SIZE = 4 * 1024;
        char *buffer = nullptr;
        int bufferIndex = 0;
        int bytesRead = 0;
        char *bufferOut = nullptr;
        unsigned int bufferOutIndex = 0;
} static io;


constexpr char vowels[6] = {'a', 'e', 'i', 'o', 'u', 'y'};
static char speech[200001];

inline int isVowel(const char c) {
    for(unsigned i=0; i<sizeof(vowels); ++i) {
        if(c == vowels[i])
            return 1;
    }
    return 0;
}

int main()
{
    char *end = io.readString(speech);
    unsigned len = static_cast<unsigned>(end - speech);
    ULL result = 0ULL;
    int row = 0;

    if(len > 2)
    {
        row = 2*isVowel(speech[0]) - 1;
        if(row > 0) {
            row = (isVowel(speech[1])) ? 2 : -1;
        } else {
            row = (isVowel(speech[1])) ? 1 : -2;
        }
        unsigned min_i = 1;
        for(unsigned i=2; i<len; ++i)
        {
            if(isVowel(speech[i]))
            {
                if(row > 0) {
                    if(++row > 2) {
                        result += (i - min_i) * (len - i);
                        min_i = i;
                    }
                } else {
                    row = 1;
                }
            }
            else
            {
                if(row < 0) {
                    if(--row < -2) {
                        result += (i - min_i) * (len - i);
                        min_i = i;
                    }
                } else {
                    row = -1;
                }
            }
        }
    }

    io.writeU64(result);
    io.writeChar('\n');
}