1. import java.util.*; 
    2.  
         
  2. /** 
    3.  
         
  3.  *  
    4.  
         
  4.  * @author tunzao 
    5.  
         
  5.  * @version 1.0 May 6, 2011 
    6.  
         
  6.  * 
    7.  
         
  7.  */ 
    8.  
         
  8. public class Palindromes 
    9.  
         
  9. { 
    10.  
         
  10.     public static void main(String[] args) 
    11.  
         
  11.     { 
    12.  
         
  12.         Scanner in = new Scanner(System.in); 
    13.  
         
  13.         while(in.hasNext()) 
    14.  
         
  14.         { 
    15.  
         
  15.             String s =  in.nextLine(); 
    16.  
         
  16.             if (s.length() == 0) 
    17.  
         
  17.                 break; 
    18.  
         
  18.             char[] ch = s.toCharArray(); 
    19.  
         
  19.             boolean isPal = true; 
    20.  
         
  20.             boolean isMirror = true; 
    21.  
         
  21.              
    22.  
         
  22.             for (int i = 0, j = ch.length-1; i < j; i++, j--) 
    23.  
         
  23.             { 
    24.  
         
  24.                 if (ch[i] != ch[j]) 
    25.  
         
  25.                 { 
    26.  
         
  26.                     isPal = false; 
    27.  
         
  27.                     if (ch[i] != getReverseChar(ch[j])) 
    28.  
         
  28.                     { 
    29.  
         
  29.                         isMirror = false; 
    30.  
         
  30.                         break; 
    31.  
         
  31.                     } 
    32.  
         
  32.                 } 
    33.  
         
  33.             } 
    34.  
         
  34.              
    35.  
         
  35.             if (!isPal && !isMirror) 
    36.  
         
  36.                 System.out.println(s + " -- is not a palindrome."); 
    37.  
         
  37.             else if (isPal && !isMirror) 
    38.  
         
  38.                 System.out.println(s + " -- is a regular palindrome."); 
    39.  
         
  39.             else if (!isPal && isMirror) 
    40.  
         
  40.                 System.out.println(s + " -- is a mirrored string."); 
    41.  
         
  41.             else 
    42.  
         
  42.                 System.out.println(s + " -- is a mirrored palindrome."); 
    43.  
         
  43.         } 
    44.  
         
  44.         in.close(); 
    45.  
         
  45.         //System.exit(0); 
    46.  
         
  46.     } 
    47.  
         
  47.      
    48.  
         
  48.     private static char getReverseChar(char c) 
    49.  
         
  49.     { 
    50.  
         
  50.         switch (c) 
    51.  
         
  51.         { 
    52.  
         
  52.             case 'A': 
    53.  
         
  53.                 return 'A'; 
    54.  
         
  54.             case 'E': 
    55.  
         
  55.                 return '3'; 
    56.  
         
  56.             case 'H': 
    57.  
         
  57.                 return 'H'; 
    58.  
         
  58.             case 'I': 
    59.  
         
  59.                 return 'I'; 
    60.  
         
  60.             case 'J': 
    61.  
         
  61.                 return 'L'; 
    62.  
         
  62.             case 'L': 
    63.  
         
  63.                 return 'J'; 
    64.  
         
  64.             case 'M': 
    65.  
         
  65.                 return 'M'; 
    66.  
         
  66.             case 'O': 
    67.  
         
  67.                 return 'O'; 
    68.  
         
  68.             case 'S': 
    69.  
         
  69.                 return '2'; 
    70.  
         
  70.                  
    71.  
         
  71.             case 'T': 
    72.  
         
  72.                 return 'T'; 
    73.  
         
  73.             case 'U': 
    74.  
         
  74.                 return 'U'; 
    75.  
         
  75.             case 'W': 
    76.  
         
  76.                 return 'W'; 
    77.  
         
  77.             case 'X': 
    78.  
         
  78.                 return 'X'; 
    79.  
         
  79.             case 'Y': 
    80.  
         
  80.                 return 'Y'; 
    81.  
         
  81.             case 'Z': 
    82.  
         
  82.                 return '5'; 
    83.  
         
  83.             case '1': 
    84.  
         
  84.                 return '1'; 
    85.  
         
  85.             case '2': 
    86.  
         
  86.                 return 'S'; 
    87.  
         
  87.             case '3': 
    88.  
         
  88.                 return 'E'; 
    89.  
         
  89.             case '5': 
    90.  
         
  90.                 return 'Z'; 
    91.  
         
  91.             case '8': 
    92.  
         
  92.                 return '8'; 
    93.  
         
  93.             default: 
    94.  
         
  94.                 return 0; 
    95.  
         
  95.         } 
    96.  
         
  96.     } 
    97.  
         
  97. } 
    98.