Проверьте правильность текста программы проверки текста заклинаний.

Bd Tc Ec Fcd Tc,

Zb Ra Ca Dab Ra

#include <stdlib.h>
#include <iostream>
#include <conio.h>
#include <string>
void main(void) {
    std::string is;
    char ma ='a';
    int i = 0, a=1,
        per = 0, t[81];
    int s = 20;
    std::getline(std::cin, is);
    char    *p = &is[0];
    per = is.size();
    do
    {
        ma = *p;
        if (ma == ' '||ma=='.') {
            if(s>a) s = a-1;
            if (ma == '.') { t[i] = 999; };
            t[i]=0;
            a = 0;
        }
        else {
            t[i] =(int)(ma);
            
            
        };
        *p++;
        
        i++; a++;
    } while (*p != is[per]);
    t[i] = 999;
    std::cout <<"Ok s=" << s<<std::endl;
    a = (int)('z'); per = (int)('Z');
    do
    {
        ma=t[i];
        if (ma == 0) {
            printf(" ",&ma);
 
        }
        else if(ma<per){ printf("%c", &ma); }
        else{
            ma = ma + s;
            if (ma >= a) {
                ma = ma - a + per;
                printf("%c", &ma);
            }
            else
            {
                ma = ma - per;
                printf("%c", &ma);
                    ///
            }
        }
        i++;
    } while (t[i] != 999);
 
    system("pause");
}

///////////////////////////////////////////////////////////////////////////////
//На вход программе подается текст заклинания, состоящего не более,
//чем из 200 символов, заканчивающийся точкой (другие точки во входных
//данных отсутствуют). Оно было зашифровано волшебником следующим образом.
//Сначала он определил количество букв в самом коротком слове, обозначив
//полученное число через К (словом называется непрерывная последовательность
//английских букв, слова друга от друга отделяются любыми другими символами,
//длина слова не превышает 20 символов). Затем он заменил каждую английскую букву
//в заклинании на букву, стоящую в английском альфавите на следуюшую букв K,
//(алфавит считается циклическим, то есть, перед буквой А стоит буква Z),
//оставив другие символы неизменными. Строчные буквы при этом остались строчными,
//а прописные - прописными.
//Требуется написать программу, которая будет выводит на экран текст расшифрованного
//заклинания.
//Например, если текст зашифрованный текст был таким:
//Bd Tc Ec Fcd Tc,
 
//то стал таким:
//Zb Ra Ca Dab Ra
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <functional>
#include <iostream>
#include <string>
///////////////////////////////////////////////////////////////////////////////
const   char    FIRST_ALPHABET_SYMB     =   'a';
const   int     ALPHABET_SIZE           =   26;
///////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
///////////////////////////////////////////////////////////////////////////////
char    get_decrypted_symb_with_key
    (
        char    symb,
        int     key
    )
{
    if  (
            !std::isalpha( symb )
        )
    {
        return  symb;
    }
 
    bool    is_lower    =   std::islower( symb );
    symb                =   std::tolower( symb );
 
    int     ind         =       (
                                        symb
                                    -   FIRST_ALPHABET_SYMB
                                    +   ALPHABET_SIZE
 
                                    -       key
                                        %   ALPHABET_SIZE
                                )
 
                            %   ALPHABET_SIZE;
 
    return      (
                    is_lower
                        ?   FIRST_ALPHABET_SYMB
                        :   std::toupper( FIRST_ALPHABET_SYMB )
                )
 
            +   ind;
}
///////////////////////////////////////////////////////////////////////////////
void    set_key
    (
        T_str   const   &   str,
        int             &   key
    )
{
    key     =   0;
    int     word_cur_size{};
 
    for( size_t  i{}; i < str.size(); ++i )
    {
        if  (
                std::isalpha
                    (
                        str[i]
                    )
            )
        {
            ++word_cur_size;
        }
        else
        {
            if( word_cur_size )
            {
                if  (
                            key     ==  0
 
                        ||      word_cur_size
                            <   key
                    )
                {
                    key     =   word_cur_size;
                }//if
 
                word_cur_size   =   0;
            }//if
        }//else
    }//for
}
///////////////////////////////////////////////////////////////////////////////
T_str   get_decrypted_spell( T_str  const   &   spell )
{
    int     key{};
 
    set_key     (
                    spell,
                    key
                );
 
    T_str   res_spell;
 
    std::transform
        (
            spell.begin         (),
            spell.end           (),
            std::back_inserter  ( res_spell ),
 
            std::bind
                (
                    get_decrypted_symb_with_key,
                    std::placeholders::_1,
                    key
                )
        );
 
    return  res_spell;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_str   encrypted_spell;
 
    getline
        (
            std::cin,
            encrypted_spell
        );
 
    std::cout   <<  get_decrypted_spell( encrypted_spell )
                <<  std::endl;
}