import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;

public class N465 {
	static Scanner in;
	static PrintWriter out;
	
	static String INPUT = "";

	static void solve() {
		char[] s = in.next().toCharArray();
		if(!(s.length >= 4))throw new AssertionError();
		if(!(s.length <= 500000))throw new AssertionError();
		for(char c : s){
			if(!(c >= 'a' && c <= 'z'))throw new AssertionError();
		}
		
		int n = s.length;
		int[] rads = palindrome(s);
		
		int[] prefix = new int[n];
		for(int i = 0;i < n;i++){
			if(rads[i] == i+1){
				prefix[i]++;
			}
		}
		
		long[] dp = new long[n];
		long[] ep = new long[n];
		
		// ([start,i],[start+delta,i],...,[start+delta*(num-1),i])
		int[] start = new int[32];
		int[] delta = new int[32];
		int[] num = new int[32];
		int I = 9999999;
		int gp = 0;
		for(int i = 0;i < n;i++){
			// g -> g'
			int gp1 = 0;
			for(int j = 0;j < gp;j++){
				if(start[j]-1 >= 0 && s[start[j]-1] == s[i]){
					start[j]--;
					start[gp1] = start[j];
					delta[gp1] = delta[j];
					num[gp1] = num[j];
					gp1++;
				}
			}
			
			int[] nstart = new int[32];
			int[] ndelta = new int[32];
			int[] nnum = new int[32];
			int gp2 = 0;
			for(int j = 0;j < gp1;j++){
				if(j == 0 && delta[j] == I || gp2-1 >= 0 && nstart[gp2-1] + ndelta[gp2-1] * (nnum[gp2-1]-1) == start[j] - delta[j]){
					// no need to modified
					nstart[gp2] = start[j];
					ndelta[gp2] = delta[j];
					nnum[gp2] = num[j];
					gp2++;
					continue;
				}
				// split
				nstart[gp2] = start[j];
				ndelta[gp2] = gp2 == 0 ? I : start[j] - (nstart[gp2-1] + ndelta[gp2-1] * (nnum[gp2-1]-1));
				nnum[gp2] = 1;
				gp2++;
				
				if(num[j] > 1){
					nstart[gp2] = start[j] + delta[j];
					ndelta[gp2] = delta[j];
					nnum[gp2] = num[j]-1;
					gp2++;
				}
			}
			
			// add XX
			if(i-1 >= 0 && s[i-1] == s[i]){
				nstart[gp2] = i-1;
				ndelta[gp2] = 0 < gp2 ? i-1-(nstart[gp2-1] + ndelta[gp2-1]*(nnum[gp2-1]-1)) : I;
				nnum[gp2] = 1;
				gp2++;
			}
			
			// add X
			nstart[gp2] = i;
			ndelta[gp2] = 0 < gp2 ? i-(nstart[gp2-1] + ndelta[gp2-1]*(nnum[gp2-1]-1)) : I;
			nnum[gp2] = 1;
			gp2++;
			
			// merge
			int gp3 = 0;
			for(int j = 0;j < gp2;j++){
				if(j == 0 || ndelta[j] != ndelta[j-1]){
					nstart[gp3] = nstart[j];
					ndelta[gp3] = ndelta[j];
					nnum[gp3] = nnum[j];
					gp3++;
				}else{
					nnum[gp3-1] += nnum[j];
				}
			}
			
			start = nstart;
			delta = ndelta;
			num = nnum;
			gp = gp3;
			
			for(int j = 0;j < gp;j++){
				int r = start[j] + (num[j]-1)*delta[j];
				long lv = 0;
				if(r-1 >= 0)lv += prefix[r-1];
				
				if(num[j] > 1 && start[j]-delta[j] >= 0){
					lv += ep[start[j]-delta[j]];
				}
				
				dp[i] += lv;
				if(delta[j] <= start[j]){
					ep[start[j]-delta[j]] = lv;
				}
			}
		}
		
		int[] suffix = new int[n];
		for(int i = 0;i < n;i++){
			if(rads[2*n-2-i] == i+1){
				suffix[n-1-i]++;
			}
		}
		for(int i = n-2;i >= 0;i--){
			suffix[i] += suffix[i+1];
		}
		
		long ret = 0;
		for(int i = 0;i+2 < n;i++){
			ret += dp[i]*suffix[i+2];
		}
		out.println(ret);
	}
	
//	static void check(long[] dp, char[] s)
//	{
//		int n = s.length;
//		for(int i = 0;i < n;i++){
//			int ct = 0;
//			inner:
//			for(int j = 1;j <= i;j++){
//				for(int k = 0, l = j-1;k < l;k++,l--){
//					if(s[k] != s[l])continue inner;
//				}
//				for(int k = j, l = i;k < l;k++,l--){
//					if(s[k] != s[l])continue inner;
//				}
//				ct++;
//			}
//			tr(i);
//			assert ct == dp[i];
//		}
//	}
	
	public static int[] palindrome(char[] str)
	{
		int n = str.length;
		int[] r = new int[2*n];
		int k = 0;
		for(int i = 0, j = 0;i < 2*n;i += k, j = Math.max(j-k, 0)){
			// normally
			while(i-j >= 0 && i+j+1 < 2*n && str[(i-j)/2] == str[(i+j+1)/2])j++;
			r[i] = j;
			
			// skip based on the theorem
			for(k = 1;i-k >= 0 && r[i]-k >= 0 && r[i-k] != r[i]-k;k++){
				r[i+k] = Math.min(r[i-k], r[i]-k);
			}
		}
		return r;
	}


	public static void main(String[] args) throws Exception {
		in = INPUT.isEmpty() ? new Scanner(System.in) : new Scanner(INPUT);
		out = new PrintWriter(System.out);

		solve();
		out.flush();
	}

	static int ni() {
		return Integer.parseInt(in.next());
	}

	static long nl() {
		return Long.parseLong(in.next());
	}

	static double nd() {
		return Double.parseDouble(in.next());
	}

	static void tr(Object... o) {
		if (INPUT.length() != 0)
			System.out.println(Arrays.deepToString(o));
	}
}