Go: package main

import (
	"bufio"
	"os"
	"strings"
	"fmt"
)

var scanner = bufio.NewScanner(os.Stdin)

func nextString() string {
	scanner.Scan()
	return scanner.Text()
}

func cipher(text string, direction int, int_shift int) string {
	shift, offset := rune(int_shift), rune(26)
	runes := []rune(text)
	for index, char := range runes {
		switch direction {
		case 1:
			if char >= 'a' && char <= 'z'-shift || char >= 'A' && char <= 'Z'-shift {
				char = char + shift
			} else if char > 'z'-shift && char <= 'z' || char > 'Z'-shift && char <= 'Z' {
				char = char + shift - offset
			}
		case -1:
			if char >= 'a'+shift && char <= 'z' || char >= 'A'+shift && char <= 'Z' {
				char = char - shift
			} else if char >= 'a' && char < 'a'+shift || char >= 'A' && char < 'A'+shift {
				char = char - shift + offset
			}
		}
		runes[index] = char
	}
	return string(runes)
}

func main() {
	for {
		infos := strings.Split(nextString(), " ")
		plain := make([]string, len(infos))
		if len(infos) == 0 {
			break
		}
		// println(infos)
		Decryption:
			for i := 0; i < 26; i++ {
				for j := range infos {
					plain[j] = cipher(infos[j], 1, i)
				}
				for j := range plain {
					if plain[j] == "this" || plain[j] == "that" || plain[j] == "the" {
						break Decryption
					}
				}
			}
			fmt.Println(strings.Join(plain, " "))
	}
}

Python: x=[i for i in input()]
i=0
y=[0 for i in range(4)]
dif1=0
while(i<len(x)-1):
    s=0
    for j in range(4):
        if (x[j]!=' ')and (x[j]!='.')and (x[j]!='\n'):
            y[j]=x[j]
            s=j
        else:
            s=j
            break       
    if s==3 or s==2:
        dif1=ord(y[0])-ord('t')
        dif2=ord(y[1])-ord('h')
        if dif1==dif2:
            if s==2 and ord(y[2])-dif1==ord('e'):
                break
            else:
                if ord(y[2])-dif1==ord('a') :
                    if y[0]==y[3]:
                        break
                    else:
                        i=i+s+1
                elif ord(y[2])-dif1==ord('i'):
                    if ord(y[3])-dif1==ord('s'):
                        break
                    else:
                        i=i+s+1
                else:
                    i=i+s+1
        else:
            i=i+s+1
            
    else:
        i=i+s+1
for i in range(len(x)):
    if (x[i]!=' ')and (x[i]!='.')and (x[i]!='\n'):
        print(chr(int(ord(x[i]))-dif1),end="")
    else:
        print(x[i],end="")
print(" ",end="")

Python: def decode(s, n):
    a = ""
    for i in s:
        if i.islower():
            a += chr((ord(i) - 97 + n) % 26 + 97)
        else:
            a += i
    return a

def judge(s):
    a = s.split()
    return "the" in a or "this" in a or "that" in a

while True:
    try:
        s = input()
    except:
        break
    for i in range(1, 26):
        a = decode(s, i)
        if judge(a):
            print(a)
            break

Python: import sys


def _rot(c, i):
    if ord("a") < ord(c) and ord(c) < ord("z"):
        return chr((ord(c) - ord("a") + i) % 26 + ord("a"))
    if ord("A") < ord(c) and ord(c) < ord("Z"):
        return chr((ord(c) - ord("A") + i) % 26 + ord("A"))
    return c


def rot(str, i):
    g = [_rot(c, i) for c in str]
    return "".join(g)


def caesar(str):
    for i in range(26):
        s=rot(str, i)
        if s.find("this")!=-1 or s.find("the")!=-1 or s.find("that")!=-1:
            return s
    return 'none'

for line in sys.stdin:
    print(caesar(line.rstrip()))

Python: t = ord("t")
z = ord("z")
a = ord("a")

def _decode(tv, v):
    spam = ord(v)
    if not (a <= spam <= z):
        return v

    x = t - ord(tv)
    y = spam + x

    if y > z:
        y = a + (y % z) - 1
    elif y < a:
        y = z - (a - y - 1)

    return chr(y)

while 1:
    try:
        txt = input()
        for s in [x for x in txt.split() if 3 <= len(x) <= 4]:
            tv = s[0]
            dec_val = ''.join(list(map(lambda x:_decode(tv,x),s)))

            if (dec_val in ('this', 'the', 'that')):
                print(''.join(list(map(lambda x:_decode(tv,x),txt))))
                break
    except:
        break

Python: string='abcdefghijklmnopqrstuvwxyz'
def shifttext(shift,inp):
    s=[]
    for i in inp:
        if i.strip() and i in string:
            s.append(string[(string.index(i) + shift) % 26])
        else:
            s.append(i)
    output = ''.join(s)
    print (output)
inp=input('')
c=[]
words=inp.split()
for word in words:
    if(len(word)==3):
        for i in word:
            print("i is",i)
            if i in string:
                k=string.index(i)-20
                if(k>0):
                    k=26-string.index(i)-1+20
                    shift=((k))
                    break
                elif(k<0):
                    shift=(-1*k)
                else:
                    shift=k
print(shift)
shifttext(shift,inp)

Python: l = 'abcdefghijklmnopqrstuvwxyz'

while True:
    try:
        s = input()
    except:
        exit()
    for d in range(1,27):
        t = s[:-1].translate(str.maketrans(l,l[d:] + l[:d]))
        if 'that' in t or 'this' in t or 'that' in t:
            print(t + '.')
            break

Python: def rot(s, n):
    anslet = ''
    for let in s:
        if let in alp:
            anslet = anslet + chr(ord('a') + (ord(let) - ord('a') + n) % 26)
        else:
            anslet = anslet + let

    return anslet

alp = 'abcdefghijklmnopqrstuvwxyz'

while True:
    try:
        letlst = input()

    except:
        break

    for i in range(27):
        word = rot(letlst, i)
        if ('this' in  word) or('that' in word) or ('the' in word):
            num = i

    letlst = rot(letlst, num)
    print(letlst)

Python: import string


def check_exists(word_set, rotate_dict, search):
    for word in word_set:
        rotated_word = ''.join(rotate_dict[s] for s in word)
        if rotated_word == search:
            return True
    return False


s0 = input().strip()
alphabets = string.ascii_lowercase
frequency = sorted([(s0.count(s), 101 - ord(s)) for s in alphabets], reverse=True)
ss = s0.strip('.').split()
sl3, sl4 = set(s for s in ss if len(s) == 3), set(s for s in ss if len(s) == 4)

i, rotate_dict = 0, None
for t in frequency:
    i = t[1]
    rotate_dict = {a: b for a, b in zip(alphabets, alphabets[i:] + alphabets[:i])}
    if (check_exists(sl3, rotate_dict, 'the')
            + check_exists(sl4, rotate_dict, 'this')
            + check_exists(sl4, rotate_dict, 'that')) > 0:
        break
print(''.join(rotate_dict[s] if s.isalpha() else s for s in s0))

Python: import sys
def unzip(instd):
    for i in range(26):
        search = ""
        for idx in instd:
            if 97 <= ord(idx) <= 122:
                if ord(idx) + i <= 122:
                    search += chr(ord(idx) + i)
                else:
                    search += chr(ord(idx) + i - 26)
            else:
                search += idx
        if 'the' in search or 'this' in search or 'that' in search:
            return search


for line in sys.stdin:
    print(unzip(line.rstrip()))

Python: s = input()
for i in range(1,27):
    ans = ""
    for j in range(len(s)):
        ch = s[j]
        if "a" <= ch <= "z":
            ans += chr((ord(ch) - ord("a") + i)%26 + ord("a"))
        else:
            ans += ch
    if "this" in ans or "that" in ans or"the" in ans:
        break
print(ans)