package main

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

var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) { fmt.Fprintf(writer, f, a...) }
func scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }

func main() {
	defer writer.Flush()

	var (
		n int
	)

	scanf("%d\n", &n)

	printf("I hate ")
	for i := 1; i < n; i++ {
		if i%2 == 0 {
			printf("that I hate ")
		} else {
			printf("that I love ")
		}
	}

	printf("it\n")
}

package main

import "fmt"

func main() {
	h1 := "I hate it "
	h2 := "I hate that "
	l1 := "I love it "
	l2 := "I love that "

	var size int
	fmt.Scan(&size)

	flag := true
	for size > 0 {
		if size == 1 && flag == true {
			fmt.Print(h1)
			size--
		} else if size == 1 && flag == false {
			fmt.Print(l1)
			size--
		} else {
			if flag == true {
				fmt.Print(h2)
				flag = false
				size--
			} else {
				fmt.Print(l2)
				flag = true
				size--
			}
		}

	}
}

package main

import "fmt"

func main() {
    var n int
    fmt.Scan(&n)
    /*str1 := "I hate"
    str2 := "I love"*/
    var str3 string
    /*if n == 0 {
        str3 = str3 + "I hate it"
    } */
    for i := 0; i < n; i++ {
        if i%2 == 0 && i != n-1 {
            str3 = str3 + "I hate that "
        }
        if i%2 == 0 && i == n-1 {
            str3 = str3 + "I hate it"
		}
        if i%2 == 1 && i != n-1 {
            str3 = str3 + "I love that "
        }
        if i%2 == 1 && i == n-1 {
            str3 = str3 + "I love it"
        }
	}
	fmt.Println(str3)
}

package main

import "fmt"

func main() {
    var n int
    fmt.Scanf("%d\n", &n)
    if n == 1 {
        fmt.Println("I hate it")
        return
    }
    res := "I hate"
    for i := 2; i <= n; i ++ {
        if i%2 == 0 {
            res += " that I love"
        } else {
            res += " that I hate"
        }
    }
    res += " it"
    fmt.Println(res)
}

package main

import "fmt"

func main() {
   var n int
   fmt.Scan(&n)
   var ans string
   for i := 0; i < n - 1; i ++ {
      if i % 2 == 0 {
         ans += "I hate that"
      } else {
         ans += " I love that "
      }
   }
   if (n - 1) % 2 == 0 {
      ans += "I hate it"
   } else {
      ans += " I love it "
   }
   fmt.Println(ans)
}

package main

import (
	"fmt"
)

func main() {

	var n int
	fmt.Scanf("%d\n", &n)

	love := "I love"
	hate := "I hate"
	i:=0
	for ; i < n - 1; i+=1 {
		if i%2 == 0 {
			fmt.Print(hate, " that ")
		} else {
			fmt.Print(love, " that ")
		}
	}
	if i%2 == 0 {
		fmt.Print(hate, " it")
	} else {
		fmt.Print(love, " it")
	}
}

package main

import (
	"fmt"
)

func main() {
	var n int
	s := "I hate"
	fmt.Scanf("%d \n", &n)
	for i := 1; i < n; i++ {
		s += " that I "
		if i % 2 == 1 {
			s += "love"
		} else {
			s += "hate"
		}
	}
	s += " it"
	fmt.Print(s)
}

package main

import "fmt"

func main(){
	var n int
	fmt.Scan(&n)
	if n%2==0{
		for i:=1;i<n/2;i++{
			fmt.Print("I hate that I love that ")
		}
		fmt.Println("I hate that I love it")
	}else{
		for i:=0;i<n/2;i++{
			fmt.Print("I hate that I love that ")
		}
		fmt.Println("I hate it")
	}
}

package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	for i:=0;i<n;i++{
		if i%2==0 && i!=n-1 {
			fmt.Printf("I hate that ")
		} else if i%2==1 && i!=n-1 {
			fmt.Printf("I love that ")
		} else if i==n-1 && i%2==0{
			fmt.Printf("I hate it")
		} else if i==n-1 && i%2==1 {
			fmt.Printf("I love it")
		}
	}
}

package  main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scanf("%d",&n)
	ans := "";
	for i := 0 ; i < n; i++ {
		if len(ans) > 0{
			ans += " that ";
		}
		if i & 1 == 1 {
			ans += "I love"
		} else {
			ans += "I hate"
		}
	}
	ans += " it";
	fmt.Println(ans);
}

package main

import "fmt"

func main() {
	var n int
	fmt.Scanln(&n)

	for i := 0; i < n; i++ {
		if i%2 == 0 {
			fmt.Print("I hate ")
		} else {
			fmt.Print("I love ")
		}
		if i == n-1 {
			fmt.Print("it")
		} else {
			fmt.Print("that ")
		}
	}
	fmt.Print("\n")
}

package main

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

func main() {
	reader := bufio.NewReaderSize(os.Stdin, 1024 * 1024)
	var n int
	fmt.Sscanf(readLine(reader), "%d", &n)
	var s []string
	for i:=1; i<=n; i++ {
		if i % 2 != 0 {
			s = append(s, "I hate")
		} else {
			s = append(s, "I love")
		}
	}
	res := strings.Join(s, " that ")
	fmt.Printf("%s it\n", res)
}

func readLine(reader *bufio.Reader) string {
	str, _, err := reader.ReadLine()
	if err == io.EOF {
		return ""
	}

	return strings.TrimRight(string(str), "\r\n")
}

func checkError(err error) {
	if err != nil {
		panic(err)
	}
}

package main

import "fmt"

func main() {
	var n int
	var str string
	fmt.Scan(&n)
	str = str + "I hate "
	for i:=0; i<n-1; i++ {
		if i % 2 == 0 {
			str = str + "that I love "
		} else {
			str = str + "that I hate "
		}
	}
	fmt.Println(str + "it")
}

package main

import (
	"fmt"
)

func main() {
	var n, k uint
	var st string
	k = 1
	fmt.Scan(&n)
	for k <= n {
		if k%2 == 0 {
			st += "I love that "
		} else {
			st += "I hate that "
		}

		k++
	}
	st = st[:len(st)-5] + "it"
	fmt.Println(st)
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	var n int
	fmt.Scanf("%d\n", &n)
	var output = make([]string, n)
	if n%2 == 1 {
		output[n-1] = "I hate it"
	} else {
		output[n-1] = "I love it"
	}
	n--
	for n > 0 {

		if n%2 == 0 {
			output[n-1] = " I love that"
		} else {
			output[n-1] = " I hate that"
		}
		n--

	}
	fmt.Print(strings.Join(output, " "))
}

package main

import (
	"fmt"
	"strings"
)
func main() {
	var a int
	res := []string{}
	fmt.Scan(&a)
	b := a / 2
	c := a % 2
	for i := 0; i<b; i++ {
		res = append(res, "I hate that I love")
	}
	stro := strings.Join(res, " that ")
	if c == 0 {
		fmt.Println(stro, "it")
	} else {
		if a != 1 {
			fmt.Println(stro, "that I hate it")
		} else {
			fmt.Println("I hate it")
		}
	}
}

package main

import (
    "bufio"
    "fmt"
    "os"
	"strconv"
)

func main() {
	var n int
	var scanner *bufio.Scanner = bufio.NewScanner(os.Stdin)

	scanner.Scan()
	n, _ = strconv.Atoi(scanner.Text())

	for i := 0; i < n; i++ {

		if i & 1 == 0 {
			fmt.Print("I hate")
		} else {
			fmt.Print("I love")
		}

		if i < n - 1 {
			fmt.Print(" that ")
		} else {
			fmt.Println(" it")
		}
	}
}

package main
import "fmt"

func main(){
	var n int
	fmt.Scan(&n)
	for i:=1;i<=n;i++ {
		if i==1 {
			fmt.Printf("I hate")
		} else if i%2==0 {
			fmt.Printf(" that I love")
		} else {
			fmt.Printf(" that I hate")
		}
	}
	fmt.Printf(" it")
}

package main

import "fmt"

func main()  {
	var n int
	fmt.Scan(&n)
	for i := 1; i <= n; i ++{
		fmt.Print("I ")
		if i % 2 == 1 {
			fmt.Print("hate ")
		}else {
			fmt.Print("love ")
		}
		if i == n {
			fmt.Print("it ")
		} else{
			fmt.Print("that ")
		}
	}
}

package main

import "fmt"

func main() {
	var a int
	var output string
	fmt.Scan(&a)
	for i := 0; i < a; i++ {
		if i%2 == 0 {
			output = output + "I hate "
		} else if i%2 == 1 {
			output = output + "I love "
		}
		if i+1 != a {
			output = output + "that "
		} else {
			output = output + "it"
		}
	}
	fmt.Println(output)
}

package main

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

func I(i interface{}, delim string) error {
	_, err := fmt.Fscanf(r, "%v"+delim, i)
	return err
}

func O(o interface{}, delim string) {
	fmt.Fprintf(w, "%v"+delim, o)
}

var (
	r *bufio.Reader
	w *bufio.Writer
)

func init() {
	if f, err := os.Open("in.txt"); err == nil {
		r = bufio.NewReader(f)
	} else {
		r = bufio.NewReader(os.Stdin)
	}
	w = bufio.NewWriter(os.Stdout)
}

func main() {
	defer w.Flush()
	var n int
	for I(&n, "\n") == nil {
		solve(n)
	}
}

func solve(n int) {
	a := "I love that"
	b := "I hate that"
	c := "I hate it"
	d := "I love it"
	for i := 1; i <= n; i++ {
		if i == n {
			if i%2 == 1 {
				O(c, "")
			} else {
				O(d, "")
			}
		} else {
			if i%2 == 1 {
				O(b, " ")
			} else {
				O(a, " ")
			}
		}
	}
	O("", "\n")
}

package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	fmt.Print("I hate ")
	for i := 2; i <= n; i++ {
		if i % 2 == 0 {
			fmt.Print("that I love ")
		} else {
			fmt.Print("that I hate ")
		}
	}
	fmt.Println("it")
}

package main

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

func main() {
	var n int
	in := bufio.NewReader(os.Stdin)
	fmt.Fscan(in, &n)
	var ans strings.Builder
	ans.WriteString("I hate ")
	for i := 1; i < n; i++ {
		ans.WriteString("that ")
		if i%2 == 0 {
			ans.WriteString("I hate ")
		} else {
			ans.WriteString("I love ")
		}
	}
	ans.WriteString("it")
	fmt.Println(ans.String())
}

// A. Hulk
/*
Dr. Bruce Banner hates his enemies (like others don't). As we all know,
he can barely talk when he turns into the incredible Hulk.
That's why he asked you to help him to express his feelings.

Hulk likes the Inception so much, and like that his feelings are complicated.
They have n layers. The first layer is hate, second one is love,
third one is hate and so on...

For example if n = 1, then his feeling is "I hate it" or if n = 2 it's
"I hate that I love it", and if n = 3 it's "I hate that I love that I hate it"
and so on.

Please help Dr. Banner.

Input
The only line of the input contains a single integer n (1 ≤ n ≤ 100) —
the number of layers of love and hate.

Output
Print Dr.Banner's feeling in one line.

Examples
Input
1

Output
I hate it

Input
2

Output
I hate that I love it

Input
3

Output
I hate that I love that I hate it
*/
package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	input, _, _ := reader.ReadLine()

	i, _ := strconv.Atoi(string(input))
	fmt.Println(sol795A(i))
}

func sol795A(c int) string {
	output := []string{}
	for i := 1; i <= c; i++ {
		s := ""
		if i%2 == 1 {
			if i == c {
				s = "I hate it"
			} else {
				s = "I hate that"
			}
		} else {
			if i == c {
				s = "I love it"
			} else {
				s = "I love that"
			}
		}
		output = append(output, s)
	}

	return strings.Join(output, " ")
}

// A. Hulk
/*
Dr. Bruce Banner hates his enemies (like others don't). As we all know,
he can barely talk when he turns into the incredible Hulk.
That's why he asked you to help him to express his feelings.

Hulk likes the Inception so much, and like that his feelings are complicated.
They have n layers. The first layer is hate, second one is love,
third one is hate and so on...

For example if n = 1, then his feeling is "I hate it" or if n = 2 it's
"I hate that I love it", and if n = 3 it's "I hate that I love that I hate it"
and so on.

Please help Dr. Banner.

Input
The only line of the input contains a single integer n (1 ≤ n ≤ 100) —
the number of layers of love and hate.

Output
Print Dr.Banner's feeling in one line.

Examples
Input
1

Output
I hate it

Input
2

Output
I hate that I love it

Input
3

Output
I hate that I love that I hate it
*/
package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	input, _, _ := reader.ReadLine()

	i, _ := strconv.Atoi(string(input))
	// fmt.Println(sol705A(i))
	sol2_705A(i)
}

func sol705A(c int) string {
	output := []string{}
	for i := 1; i <= c; i++ {
		s := ""
		if i%2 == 1 {
			if i == c {
				s = "I hate it"
			} else {
				s = "I hate that"
			}
		} else {
			if i == c {
				s = "I love it"
			} else {
				s = "I love that"
			}
		}
		output = append(output, s)
	}

	return strings.Join(output, " ")
}

func sol2_705A(c int) {
	for i := 1; i <= c; i++ {
		if i%2 == 1 {
			fmt.Print("I hate ")
		} else {
			fmt.Print("I love ")
		}
		if i == c {
			fmt.Print("it")
		} else {
			fmt.Print("that ")
		}
	}
}

package main

import (
	"bufio"
	"os"
	"strconv"
)

func main() {
	in := bufio.NewScanner(os.Stdin)
	out := bufio.NewWriter(os.Stdout)

	in.Split(bufio.ScanWords)
	defer out.Flush()

	a := []string{"I hate", "I love"}

	in.Scan()
	n, _ := strconv.Atoi(in.Text())

	for i := 0; i < n; i++ {
		out.WriteString(a[i&1])
		if i < n-1 {
			out.WriteString(" that ")
		} else {
			out.WriteString(" it")
		}
	}
	out.WriteByte('\n')
}

package main

import (
	"fmt"
)

func main() {
	var n int
	var answer string
	fmt.Scan(&n)
	for k := 1; k < n+1; k++ {
		if k%2 == 1 {
			answer += "I hate "
		} else {
			answer += "I love "
		}
		if n == k {
			answer += "it"
		} else {
			answer += "that "
		}
	}
	fmt.Println(answer)
}

package main

import (
	"fmt"
)

func main(){
	var n int
	fmt.Scan(&n)
	fmt.Println(solve("I hate",1,n))
}

func solve(s string, n int, N int) string{
	//fmt.Println("inside ",n)
	if n == N{
		return s+" it"
	}else if n%2 == 1{
		s = s + " that I love"
		return solve(s,n+1,N)
	}else{
		s = s + " that I hate"
		return solve(s,n+1,N)
	}
}

package main

import "fmt"

func main() {
	a := "I hate"
	b := "I love"
	e := " it"
	plus := " that "
	s := "I hate"
	var n int
	fmt.Scan(&n)
	for i := 1; i < n; i++ {
		if i%2 == 1 {
			s = s + plus + b
		} else {
			s = s + plus + a
		}
	}
	s = s + e
	fmt.Println(s)
}

package main

import(
    "fmt"
)

type u16 uint16

func main(){
    var(
        n,i u16
        s1,s2,s3,s4 = "I hate it","I hate that","I love it","I love that"
    )
    fmt.Scan(&n)
    if n==1{
        fmt.Println(s1)
    }else{
        for i=0;i<n-1;i++{
            if (i+1)%2==1{
                fmt.Print(s2," ")
            }else{
                fmt.Print(s4," ")
            }
        }
        if n%2==0{
            fmt.Println(s3)
        }else{
            fmt.Println(s1)
        }
    }
}

package main

import (
	"fmt"
)

func main() {
	var n int
	var ans = ""
	_, _ = fmt.Scan(&n)

	for i := 1; i <= n; i++ {
		if i % 2 == 1 {
			ans += "I hate "
		} else {
			ans += "I love "
		}
		if i != n {
			ans += "that "
		}
	}
	ans += "it"
	fmt.Println(ans)
}

package main

import "fmt"

func main() {
	var n int
	fmt.Scanf("%d", &n)

	odd := "I hate"
	even := "I love"
	s := ""

	for i := 1; i <= n; i++ {
		if i != 1 {
			s += " that "
		}
		if i%2 == 1 {
			s += odd
		} else {
			s += even
		}
	}
	s += " it"
	fmt.Println(s)
}

package main

import "fmt"

func main() {

	var n int
	fmt.Scanf("%d", &n)

	for i := 0; i < n; i++ {
		if i > 0 {
			fmt.Print("that ")
		}
		if i%2 != 0 {
			fmt.Print("I love ")
		} else {
			fmt.Print("I hate ")
		}
	}
	fmt.Println("it")
}

package main

import "fmt"

func main() {
	var a uint8
	var b string
	fmt.Scanf("%d", &a)
	for i := uint8(1); i <= a; i++ {
		if i%2 == 0 {
			b += "I love "
		} else {
			b += "I hate "
		}
		if i != a {
			b += "that "
		} else {
			b += "it"
		}
	}
	fmt.Println(b)
}

package main

import (
	"fmt"
)

func main() {
	var n, i int
	fmt.Scan(&n)
	hIt := "I hate it"
	lIt := "I love it"
	hThat := "I hate that"
	lThat := "I love that"
	if n == 1 {
		fmt.Println(hIt)
	} else if n == 2 {
		fmt.Println(hThat + " " + lIt)
	} else {
		if n%2 == 1 {
			for i = 1; i < n-1; i+=2 {
				fmt.Print(hThat)
				fmt.Print(" " + lThat + " ")
			}
			fmt.Print(hIt)
		} else {
			fmt.Print(hThat)
			for i = 1; i < n-2; i+=2 {
				fmt.Print(" " + lThat + " ")
				fmt.Print(hThat)
			}
			fmt.Print(" " + lIt)
		}
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func getNextInt(scanner *bufio.Scanner) int {
	scanner.Scan()
	i, _ := strconv.Atoi(string(scanner.Bytes()))
	return i
}

func getNextInt64(scanner *bufio.Scanner) int64 {
	scanner.Scan()
	i, _ := strconv.ParseInt(string(scanner.Bytes()), 10, 64)
	return i
}

func main() {

	reader := bufio.NewReader(os.Stdin)
	scanner := bufio.NewScanner(reader)
	// Set the split function for the scanning operation.
	scanner.Split(bufio.ScanWords)
	nbCase := getNextInt(scanner)

	messages := []string{"I hate that","I love that"}
	lastMessages := []string{"I hate it","I love it"}

	for i:=0; i<nbCase; i++ {
		if i > 0 {
			fmt.Print(" ")
		}
		if i == nbCase-1 {
			fmt.Print(lastMessages[i%2])
		} else {
			fmt.Print(messages[i%2])
		}
	}

}

package main

import (
	"fmt"
)

func main() {

	var n int
	storage := "I hate"
	fmt.Scanln(&n)
	for i := 1; i <= n; i++ {
		if i == n {
			storage += " it"
			break
		} else {
			storage += " that"
		}
		if i%2 == 0 {
			storage += " I hate"
		} else {
			storage += " I love"
		}
	}
	fmt.Println(storage)
}

package main

import "fmt"

func main() {
  var n int
  fmt.Scanf("%d", &n)

  var feelings string
  for i := 1; i <= n-1; i++ {
    if i%2 == 1 {
      feelings += "I hate that "
      continue
    }
    feelings += "I love that "
  }
  if n%2 == 1 {
    fmt.Println(feelings + "I hate it")
    return
  }
  fmt.Println(feelings + "I love it")
}

package main

import "fmt"

func main() {
	var n int
	var str string
	fmt.Scan(&n)
	str = str + "I hate "
	for i:=0; i<n-1; i++ {
		if i % 2 == 0 {
			str = str + "that I love "
		} else {
			str = str + "that I hate "
		}
	}
	fmt.Println(str + "it")
}

package main

import (
	"fmt"
)

func main() {

	var phrase1 string = "I hate"
	var phrase2 string = "I love"
	var number int
	fmt.Scan(&number)
	var count int = 0
	for count+1 < number {
		if count+1 < number {
			count = count + 1
			fmt.Print(phrase1, " that ")
		}
		if count+1 < number {
			count = count + 1
			fmt.Print(phrase2, " that ")
		}
	}
	if count%2 == 1 {
		fmt.Print(phrase2, " it ")
	} else if count%2 == 0 {
		fmt.Print(phrase1, " it ")
	}
}

package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scan(&n)
	for i:=1;i<=n;i++ {
        if (i%2==1) {
            fmt.Print(" I hate ")
        } else {
            fmt.Print(" I love ")
        }
        if (i==n) {
            fmt.Print("it")
        } else {
            fmt.Print("that")
        }
	}
}

package main

import "fmt"

func main() {
	var n int
	fmt.Scanf("%d", &n)
	delim := ""
	for i := 0; i < n; i++ {
		fmt.Printf(delim + "I ")
		if i%2 == 0 {
			fmt.Printf("hate ")
		} else {
			fmt.Printf("love ")
		}
		delim = "that "
	}
	fmt.Printf("it\n")
}

package main

import "fmt"

var t int
var s string

func main() {
    fmt.Scanf("%d", &t)
    for i := 0; i < t; i++ {
        if i % 2 == 0 {
            s += "I hate"
        } else {
            s += "I love"
        }
        if i == t - 1 {
            s += " it"
        } else {
            s += " that "
        }
    }
    fmt.Println(s)
}

package main

import (
	"fmt"
)

func main() {

	var n int
	storage := "I hate"
	fmt.Scanln(&n)
	for i := 1; i <= n; i++ {
		if i == n {
			storage += " it"
			break
		}
		if i%2 == 0 {
			storage += " that I hate"
		} else {
			storage += " that I love"
		}
	}
	fmt.Println(storage)
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	count := 0
	for scanner.Scan() {
		count, _ = strconv.Atoi(scanner.Text())
	}
	for i := 1; i < count; i++ {
		if i%2 == 0 {
			fmt.Print("I love that ")
		} else {
			fmt.Print("I hate that ")
		}
	}
	if count%2 == 0 {
		fmt.Print("I love it ")
	} else {
		fmt.Print("I hate it ")
	}
}

package main
import "fmt"
func main(){
	var n int
	fmt.Scanf("%d", &n)
	for i := 0; i < n; i++{
		if i%2==1 {
			fmt.Printf("I love ")
		} else {
			fmt.Printf("I hate ")
		}
		if i != n-1{
			fmt.Printf("that ")
		}
	}
	fmt.Printf("it\n")
}

package main

import (
	"fmt"
	"strings"
)

func main() {

	var level int
	_, err := fmt.Scanf("%d", &level)
	if err != nil {
		panic(err)
	}

	var levels = []string{"I hate", "I love"}

	var result []string
	for i := 0; i < level; i++ {
	    result = append(result, levels[i % 2])
	}

	fmt.Println(strings.Join(result, " that "), "it")
}

package main

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

var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)

func scanf(f string, a... interface{}) {
	fmt.Fscanf(reader, f, a...)
}

func printf(f string, a... interface{}) {
	fmt.Fprintf(writer, f, a...)
}

const (
	HATE = "I hate it"
	LOVE = "I love it"
)

func main() {

	var T, i uint

	scanf("%d\n", &T)

	result := "I hate it"
	for i=2; i<=T; i++ {

		if i % 2 == 0 {
			result = strings.ReplaceAll(result, "it", "that " + LOVE )
		}else {
			result = strings.ReplaceAll(result, "it", "that " + HATE )
		}

	}

	fmt.Println(result)

}

package main
import "fmt"
func main() {
	var n int
	fmt.Scan(&n)
	n+=1
	for i := 1; i < n; i++ {
	    if i%2 == 0 {
	        fmt.Print("I love ")
	        if i == n-1 { fmt.Print("it") }
	        if i != n-1 { fmt.Print("that") }
	        if i != n-1 { fmt.Print(" ") }
	    } else {
	        fmt.Print("I hate ")
	        if i == n-1 { fmt.Print("it") }
	        if i != n-1 { fmt.Print("that") }
	        if i != n-1 { fmt.Print(" ") }

	    }
	}
	fmt.Println()
}

package main

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

var scanner *bufio.Scanner
func read() string {
    if !scanner.Scan() {
		panic("Scan returned false")
	}
	return scanner.Text()
}
func readInt() int {
	num, _ := strconv.Atoi(read())
	return num
}
func main() {
    scanner = bufio.NewScanner(os.Stdin)
    scanner.Split(bufio.ScanWords)
    n := readInt()

    f := []string{"I hate", "I love"}
    var fls []string

    for i := 0 ; i < n; i++ {
        fls =  append(fls, f[i % 2])
    }

    fmt.Println(strings.Join(fls, " that "), "it")
}

package main
import "fmt"

func print(t string) {
	fmt.Print("I " + t)
}

func main() {
	var n int
	fmt.Scanf("%d", &n)
	for i := 1; i < n; i++ {
		if i % 2 == 0 {
			print("love that ")
		} else {
			print("hate that ")
		}
	}
	if n % 2 == 0 {
		print("love it")
	} else {
		print("hate it")
	}
}

package main
import (
	"fmt"
	"strings"
)

var types = []string{"I love", "I hate"}

func main() {
	var n int
	fmt.Scanln(&n)
	var result []string
	for i := 1; i <= n; i++ {
		result = append(result, types[i % 2])
	}
	fmt.Println(strings.Join(result, " that "), "it")
}

package main

import "fmt"

func main() {
	var feelings []string
	var layers int

	fmt.Scan(&layers)
	for i := 0; i<layers; i++ {
		if i%2 == 0 {
			feelings = append(feelings, "I hate")
		} else {
			feelings = append(feelings, "I love")
		}
		if i != layers-1 {
			feelings = append(feelings, " that ")
		}
	}
	if layers > 0{
		feelings = append(feelings, " it")
	}

	for _, val := range feelings {
		fmt.Printf("%s", val)
		// if ind != layers -1 {
		// 	fmt.Printf(" ")
		// }
	}
}

package main

import	"fmt"

func main(){
	var n int
	fmt.Scanln(&n)

	for i:=1;i<n;i++ {
		if i%2 == 1 {
			fmt.Print("I hate that ")
		} else {
			fmt.Print("I love that ")
		}
	}
	if n%2==0{
		fmt.Print("I love it ")
	}else{
		fmt.Print("I hate it ")
}

}

package main

import (
	"fmt"
	"strings"
)

func main() {
	layer := 0
	fmt.Scan(&layer)
	var phrase []string
	love, hate := "I love", "I hate"
	for l:=1; l<=layer; l++ {
		if l % 2 == 0 {phrase = append(phrase, love)} else {phrase = append(phrase, hate)}
		if l != layer {phrase = append(phrase, "that")}
	}
	phrase = append(phrase, "it")
	fmt.Println(strings.Join(phrase, " "))
}

package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)

	var hol bool //hate or love

	var sum string
	sum = "I hate "
	for i := 1; i < n; i++ {
		var holstr string
		if hol {
			holstr = "hate "
			hol = !hol
		} else {
			holstr = "love "
			hol = !hol
		}
		sum += "that I " + holstr
	}
	sum += "it"
	fmt.Print(sum)
}

//package FirstGoProj
package main

import (
	"fmt"
)

func main(){
	var firstNum int
	var s1, s2 = "I hate", "I love"
	fmt.Scan(&firstNum)
	for i := 0; i<firstNum; i++ {
		if i>0{
			fmt.Print(" that ")
		}
		if i%2 == 0 {
			fmt.Print(s1)
		} else {
			fmt.Print(s2)
		}
	}
	fmt.Print(" it")
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	var a int
	s := []string{}
	fmt.Scan(&a)
	b := a / 2
	c := a % 2
	for i := 0; i<b; i++ {
		s = append(s, "I hate that I love")
	}
	stro := strings.Join(s, " that ")
	if c == 0 {
		fmt.Println(stro, "it")
	} else {
		if a != 1 {
			fmt.Println(stro, "that I hate it")
		} else {
			fmt.Println("I hate it")
		}
	}
}

package main

import (
	"fmt"
	"strings"
)

const (
	hate      = "I hate"
	love      = "I love"
	delimiter = " that "
	end       = " it"
)

func main() {
	var n int

	fmt.Scanf("%d", &n)
	fmt.Printf("%s", hulk(n))
}

func hulk(n int) string {
	var retSlice []string
	for i := 0; i < n; i++ {
		if i%2 == 0 {
			retSlice = append(retSlice, hate)
		} else {
			retSlice = append(retSlice, love)
		}
	}
	ret := strings.Join(retSlice, delimiter)
	return ret + end
}

package main

import (
	"fmt"
)

func main() {
	var N int
	fmt.Scan(&N)
	ans := ""
	for i := 0; i < N; i++ {
		if len(ans) > 0 {
			ans += " that "
		}
		if i % 2 == 0 {
			ans += "I hate"
		} else {
			ans += "I love"
		}
	}
	ans += " it"
	fmt.Println(ans)

}

package main

import (
	"fmt"
)

func main() {
	var (
		n int
		ans string
	)

	fmt.Scanf("%d", &n)

	for i := n-1; i >= 1; i-- {

		if i % 2 == 0 {
			ans = "I love that " + ans
		}else {
			ans = "I hate that " + ans
		}

	}

	if n % 2 == 0 {
		//even, ends with "I love it"
		ans += "I love it"
	} else {
		//odd, ends with "I hate it"
		ans += "I hate it"
	}

	fmt.Println(ans)
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	var n int

	fmt.Scan(&n)

	s := []string{}

	for i := 0; i < n; i++ {
		if ((i + 1) % 2) == 0 {
			s = append(s, "I love")
		} else {
			s = append(s, "I hate")
		}

		if (n - i) == 1 {
			s = append(s, " it")
		} else {
			s = append(s, " that ")
		}
	}

	result := strings.Join(s, "")

	fmt.Println(result)
}

package main

// https://codeforces.com/problemset/problem/705/A

import "fmt"

func taskSolution(n int) (ans string) {
	ans = "I hate"
	a := []string{" that I love", " that I hate"}
	for i := 2; i <= n; i += 1 {
		ans += a[i%2]
	}
	return ans + " it"
}

func main() {
	var n int
	if _, err := fmt.Scan(&n); err != nil {
		panic(err)
	}

	fmt.Println(taskSolution(n))
}

package main

import "fmt"

func main() {
	h1:="I hate it "
	h2:="I hate that "
	l1:="I love it "
	l2:="I love that "

	var size int
	fmt.Scan(&size)

	flag:=true
	for size>0  {
		if size ==1 &&flag==true{
			fmt.Print(h1)
			size--
		}else if size ==1 &&flag==false{
			fmt.Print(l1)
			size--
		}else {
			if flag ==true{
				fmt.Print(h2)
				flag=false
				size--
			}else {
				fmt.Print(l2)
				flag=true
				size--
			}
		}

	}

}

package main
import "fmt"
func main() {
    var n int
    i := 0
    fmt.Scan(&n)
    fmt.Print("I hate")
    for i < n-1{
        if i % 2 == 0{
            fmt.Print(" that I love ")
        }else{
            fmt.Print(" that I hate")
        }
        i++
    }
    fmt.Print(" it");
}

package main
import "fmt"
func main() {
    var n, i int
    i = 0
    fmt.Scan(&n)
    fmt.Print("I hate")
    for i < n-1{
        if i % 2 == 0{
            fmt.Print(" that I love ")
        }else{
            fmt.Print(" that I hate")
        }
        i++
    }
    fmt.Print(" it");
}

package main
import (
    "fmt"
)
var print = fmt.Println
func main(){
	var n int
	fmt.Scan(&n)

	var s string = ""

	for i:=0; i<n ;i++ {
		if i%2 == 0{
			s += "I hate that "
		}else if i%2 == 1{
			s += "I love that "
		}
	}
	s = string(s[:len(s)-5])+"it"
	print(s)
}

package main

import "fmt"

func hulk(t int){

	for i:= 1 ; i <= t ; i++ {
		if i == t {
				if t % 2 == 0 {
							fmt.Print("I love it")
				} else{
							fmt.Print("I hate it")
				}
		}
		if i < t {
			if i % 2 == 1 {
					fmt.Print("I hate that ")
			}else {
					fmt.Print("I love that ")
			}
		}
	}
return
}

func main(){

		var t int
		fmt.Scan(&t)
		hulk(t)
}

package main

import (
	"os"
	"bufio"
	"strconv"
	"fmt"
)

var scanner *bufio.Scanner

func getI64() int64 {
	scanner.Scan()
	x, _ := strconv.ParseInt(scanner.Text(), 10, 64)
	return x
}
func getI() int {
	return int(getI64())
}
func getF() float64 {
	scanner.Scan()
	x, _ := strconv.ParseFloat(scanner.Text(), 64)
	return x
}
func getS() string {
	scanner.Scan()
	return scanner.Text()
}

func max(a,b int) int { if a > b { return a } else { return b } }

func min(a,b int) int { if a < b { return a } else { return b } }

func printf(format string, x ...interface{}) {
	fmt.Fprintf(os.Stdout, format, x...)
}

const alphabets = "abcdefghijklmnopqrstuvwxyz"

func main() {
	scanner = bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	Problem705A()
}

func Problem705A() {
	n := getI()
	str := ""
	for i:=0;i<n;i++ {
		if i % 2 == 0 {
			str += "I hate "
		}else {
			str += "I love "
		}
		if i + 1 < n {
			str += "that "
		}else {
			str += "it"
		}
	}
	printf(str)
}

package main

import (
	"fmt"
	"strings"
)

var love string = "I love"
var hate string = "I hate"
var end string = "it"
var conj string = "that"

func main() {
	var layers int
	fmt.Scanf("%d\n", &layers)

	response := make([]string, 0)

	for i:= 1; i <= layers; i++ {
		if i > 1 {
			response = append(response, conj)
		}
		if i % 2 == 1 {
			response = append(response, hate)
		} else {
			response = append(response,love)
		}
	}
	response = append(response, end)

	fmt.Printf("%+v\n", strings.Join(response," "))

}

package main

import "fmt"

func so(n int ) {
	for i:=0; i<n; i++ {
		if i%2==0&&i!=n-1 {
			fmt.Print(" I hate that")
		}
		if i%2==1&&i!=n-1 {
			fmt.Print(" I love that")
		}
		if i%2==0&&i==n-1 {
			fmt.Print("  I hate it")

		}
		if i%2==1&&i==n-1 {
			fmt.Print(" I love it ")
		}
	}
}
func main(){
 var n int
 fmt.Scan(&n)
	so(n)
	}

package main

import "fmt"

func main() {
	n := 0

	fmt.Scan(&n)

	for i := 0; i < n; i++ {
		if i % 2 == 0 {
			fmt.Print("I hate")
		} else {
			fmt.Print("I love")
		}

		if i + 1 < n {
			fmt.Print(" that ")
		}
	}

	fmt.Println(" it")
}

package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Scanf("%d\n", &n)

	var feeling string
	for i := 1; i <= n; i++ {
		var layer string

		if i%2 == 1 {
			layer = "hate"
		} else {
			layer = "love"
		}

		end := " that "
		if i == n {
			end = " it "
		}

		feeling = feeling + "I " + layer + end
	}

	fmt.Println(feeling)
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

import "strings"

func main() {
	reader := bufio.NewReader(os.Stdin)
	text, _ := reader.ReadString('\n')
	text = strings.TrimRight(text, "\r\n")
	s := strings.Split(text, " ")

	c, _ := strconv.Atoi(s[0])
	//x, _ := strconv.ParseInt(s[1], 10, 64)
	for i := 0; i < c; i++ {
		fmt.Print("I ")
		if (i % 2) == 0 {
			fmt.Print("hate ")
		} else {
			fmt.Print("love ")
		}
		if i == c-1 {
			fmt.Println("it")
		} else {
			fmt.Print("that ")
		}

		text, _ := reader.ReadString('\n')
		text = strings.TrimRight(text, "\r\n")
	}

}

package main

import "fmt"

func main() {
	var n int
	fmt.Scanf("%d", &n)
	str := ""
	for i := 1; i <= n; i++ {
		if i&1 == 1 {
			str += "I hate"
		} else {
			str += "I love"
		}
		if i != n {
			str += " that "
		}
	}
	str += " it"
	fmt.Println(str)
}

package main

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

// https://codeforces.com/problemset/problem/705/A
// A. Hulk
// time limit per test
// 1 second
// memory limit per test
// 256 megabytes
// input
// standard input
// output
// standard output

// Dr. Bruce Banner hates his enemies (like others don't). As we all know, he can barely talk when he turns into the incredible Hulk. That's why he asked you to help him to express his feelings.

// Hulk likes the Inception so much, and like that his feelings are complicated. They have n layers. The first layer is hate, second one is love, third one is hate and so on...

// For example if n = 1, then his feeling is "I hate it" or if n = 2 it's "I hate that I love it", and if n = 3 it's "I hate that I love that I hate it" and so on.

// Please help Dr. Banner.
// Input

// The only line of the input contains a single integer n (1 ≤ n ≤ 100) — the number of layers of love and hate.
// Output

// Print Dr.Banner's feeling in one line.

func main() {
	solveTheProblem()
}

func solveTheProblem() {
	bufStdin := bufio.NewReader(os.Stdin)

	var n int
	fmt.Fscan(bufStdin, &n)

	var feeling strings.Builder
	feeling.Grow(4096)

	feeling.WriteString("I hate")
	for i := 1; i < n; i++ {
		feeling.WriteString(" that")
		if i%2 == 0 {
			feeling.WriteString(" I hate")
		} else {
			feeling.WriteString(" I love")
		}
	}
	feeling.WriteString(" it")

	fmt.Print(feeling.String())
}

package main

import "fmt"

func main(){
	result := ""
	var1 := "I hate"
	var2 := "I love"
	var n int
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		if i % 2 == 0 {
			result += var1 + " "
			if i == n - 1 {
				result += "it"
			}else {
				result += "that" + " "
			}
		}else {
			result += var2 + " "
			if i == n - 1 {
				result += "it"
			}else {
				result += "that" + " "
			}
		}
	}
	fmt.Println(result)
}

package main

import "fmt"

func main()  {
	s := ""
	var n int
	fmt.Scanf("%d\n", &n)
	for i := 0; i < n; i++ {
		if i % 2 == 0 {
			s += "I hate "
		} else {
			s += "I love "
		}
		if i == n-1 {
			s += "it"
		} else {
			s += "that "
		}
	}
	fmt.Println(s)
}

package main

import "fmt"

// https://codeforces.com/problemset/problem/705/A
// комментарий к решению
//
func taskSolution(n int) string {
	ans := []byte("I hate")
	a := [][]byte{[]byte(" that I love"), []byte(" that I hate")}
	for i := 2; i <= n; i += 1 {
		ans = append(ans, a[i%2]...)
	}
	ans = append(ans, " it"...)
	return string(ans)
}

func main() {
	var n int
	if _, err := fmt.Scan(&n); err != nil {
		panic(err)
	}

	fmt.Println(taskSolution(n))
}

package main

import "fmt"

func main(){
    var n int
	fmt.Scan(&n)
	for i := 1 ; i <= n ; i++ {
		if i == 1 {
			fmt.Printf("I hate")
		} else if i % 2 == 0 {
			fmt.Printf(" that I love")
		} else {
			fmt.Printf(" that I hate")
		}
	}
	fmt.Printf(" it")
}

package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)

	str := ""
	for i := range make([]struct{}, n) {
		if i != 0 {
			str += "that "
		}
		if i%2 == 0 {
			str += "I hate "
		} else {
			str += "I love "
		}
	}
	str += "it"
	fmt.Println(str)
}

package main

import "fmt"

func main() {
	var n int
	s1 := "I love"
	s2 := "I hate"

	fmt.Scan(&n)

	r := ""
	for i := 1; i <= n; i++ {
		if i%2 == 0 {
			r = r + s1
			if i != n {
				r = r + " that "
			}
		} else {
			r = r + s2
			if i != n {
				r = r + " that "
			}
		}
	}
	r = r + " it"
	fmt.Print(r)
}

package main

import (
	"fmt"
)

func main() {
	hate := "I hate"
	love := "I love"
	var c int
	fmt.Scan(&c)
	finalString := ""
	for i := 1; i <= c; i++ {
		if i%2 == 0 {
			if i != c {
				finalString = finalString + love + " that "
			} else {
				finalString = finalString + love + " it"
			}
		} else {
			if i != c {
				finalString = finalString + hate + " that "
			} else {
				finalString = finalString + hate + " it"
			}
		}
	}
	fmt.Printf(finalString + "")
}

// Халк
//Например, для n = 1 чувства Халка выражаются как "I hate it", для n = 2 это уже "I hate that I love it", а для n = 3 — "I hate that I love that I hate it".
package main

import "fmt"

func main() {
	var n int
	var th string
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		if i%2 == 0 {
			th += "I hate "
		} else {
			th += "I love "
		}
		if i != n-1 {
			th += "that "
		} else {
			th += "it"
		}
	}
	fmt.Println(th)
}

package main

import "fmt"

func main(){
        hateStatement := "I hate "
        loveStatement := "I love "
        var n int
        fmt.Scanf("%d",&n)
        for i:=0;i<n;i++{
                if i%2==0{
                        fmt.Print(hateStatement)
                        if i!=n-1{
                                fmt.Print("that ")
                        } else {
                                fmt.Println("it")
                        }
                } else {
                        fmt.Print(loveStatement)
                        if i!=n-1{
                                fmt.Print("that ")
                        } else {
                                fmt.Println("it")
                        }
                }
        }
}

package main

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

var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)

func scan(a ...interface{}) {
	fmt.Fscan(reader, a...)
}

func Println(a ...interface{}) {
	fmt.Println(a...)
}

func main() {
	var n int
	scan(&n)
	fmt.Print("I hate ")
	for i:=0; i<n-1;i++{
		if i%2==0{
			fmt.Print("that I love ")
		} else {
			fmt.Print("that I hate ")
		}
	}
	fmt.Print("it")
}

package main

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

func I(i interface{}, delim string) error {
	_, err := fmt.Fscanf(r, "%v"+delim, i)
	return err
}

func O(o interface{}, delim string) {
	fmt.Fprintf(w, "%v"+delim, o)
}

var (
	r *bufio.Reader
	w *bufio.Writer
)

func init() {
	if f, err := os.Open("in.txt"); err == nil {
		r = bufio.NewReader(f)
	} else {
		r = bufio.NewReader(os.Stdin)
	}
	w = bufio.NewWriter(os.Stdout)
}

func main() {
	defer w.Flush()
	var n int
	for I(&n, "\n") == nil {
		solve(n)
	}
}

func solve(n int) {
	O("I hate that", "")
	a := " I love it"
	b := " I hate it"
	for i := 0; i < n-1; i++ {
		if i%2 == 0 {
			O(a, "")
		} else {
			O(b, "")
		}
	}
	O("", "\n")
}

package main

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

func main() {
	var n int
	in := bufio.NewReader(os.Stdin)
	fmt.Fscan(in, &n)
	var ans strings.Builder
	ans.WriteString("i hate ")
	for i := 1; i < n; i++ {
		ans.WriteString("that ")
		if i%2 == 0 {
			ans.WriteString("i hate ")
		} else {
			ans.WriteString("i love ")
		}
	}
	ans.WriteString("it")
	fmt.Println(ans.String())
}

package main

import "fmt"

func main() {
	var a int
	var output string
	fmt.Scan(&a)
	for i := 0; i > a; i++ {
		if i%2 == 0 {
			output = output + "I hate "
		} else if i%2 == 1 {
			output = output + "I love "
		}
		if i+1 != a {
			output = output + "that "
		} else {
			output = output + "it"
		}
	}
	fmt.Println(output)
}

package main

import (
	"fmt"
)

func main() {
	hate := "I hate"
	love := "I love"
	var c int
	fmt.Scan(&c)
	finalString := ""
	for i := 1; i <= c; i++ {
		if i%2 == 0 {
			if i != c {
				finalString = finalString + love + " that "
			} else {
				finalString = finalString + love + " this"
			}
		} else {
			if i != c {
				finalString = finalString + hate + " that "
			} else {
				finalString = finalString + hate + " this"
			}
		}
	}
	fmt.Printf(finalString + "")
}

package main

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

var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)

func scan(a ...interface{}) {
	fmt.Fscan(reader, a...)
}

func Println(a ...interface{}) {
	fmt.Println(a...)
}

func main() {
	var n int
	scan(&n)
	fmt.Print("I hate ")
	for i:=0; i<n-1;i++{
		if i%2==0{
			fmt.Print("that i love ")
		} else {
			fmt.Print("that i hate ")
		}
	}
	fmt.Print("it")
}

package main

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

var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)

func scan(a ...interface{}) {
	fmt.Fscan(reader, a...)
}

func Println(a ...interface{}) {
	fmt.Println(a...)
}

func main() {
	var n int
	scan(&n)
	fmt.Print("i hate ")
	for i:=0; i<n-1;i++{
		if i%2==0{
			fmt.Print("that i love ")
		} else {
			fmt.Print("that i hate ")
		}
	}
	fmt.Print("it")
}

package main

import "fmt"

func main() {
    var n int
    fmt.Scanf("%d\n", &n)
    if n == 1 {
        fmt.Println("I hate it")
    }
    res := "I hate"
    for i := 2; i <= n; i ++ {
        if i%2 == 0 {
            res += " that I love"
        } else {
            res += " that I hate"
        }
    }
    res += " it"
    fmt.Println(res)
}

package main

import "fmt"

func main() {
   var n int
   fmt.Scan(&n)
   var ans string
   for i := 0; i < n; i ++ {
      if i % 2 == 0 {
         ans += "I hate it"
      } else {
         ans += " I love it "
      }
   }
   fmt.Println(ans)
}

package main

import (
	"fmt"
)

func main() {

	var n int
	fmt.Scanf("%d\n", &n)

	love := "I love it"
	hate := "I hate it"
	i:=0
	for ; i < n - 1; i+=1 {
		if i%2 == 0 {
			fmt.Print(hate, " ")
		} else {
			fmt.Print(love, " ")
		}
	}
	if i%2 == 0 {
		fmt.Print(hate)
	} else {
		fmt.Print(love)
	}
}

package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	if n==1{
		fmt.Printf("I hate it")
	} else if n==2 {
		fmt.Printf("I hate that I love it")
	}else {
		fmt.Printf("I hate that I love that I hate it")
	}
}

package main

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

func main() {
	reader := bufio.NewReaderSize(os.Stdin, 1024 * 1024)
	var n int
	fmt.Sscanf(readLine(reader), "%d", &n)
	var s []string
	for i:=1; i<=n; i++ {
		if i % 2 != 0 {
			s = append(s, "I hate it")
		} else {
			s = append(s, "I love it")
		}
	}
	fmt.Println(strings.Join(s, " "))
}

func readLine(reader *bufio.Reader) string {
	str, _, err := reader.ReadLine()
	if err == io.EOF {
		return ""
	}

	return strings.TrimRight(string(str), "\r\n")
}

func checkError(err error) {
	if err != nil {
		panic(err)
	}
}

//package FirstGoProj
package main

import (
	"fmt"
)

func main(){
	var firstNum int
	var s1, s2 = "I hate it", "I love it"
	fmt.Scan(&firstNum)
	for i := 0; i<firstNum; i++ {
		if i>0{
			fmt.Print(" that ")
		}
		if i%2 == 0 {
			fmt.Print(s1)
		} else {
			fmt.Print(s2)
		}
	}
}

package main

import "fmt"

func main() {
	var n int
	var str string
	fmt.Scan(&n)
	str = str + "i hate "
	for i:=0; i<n-1; i++ {
		if i % 2 == 0 {
			str = str + "that I love "
		} else {
			str = str + "that I hate "
		}
	}
	fmt.Println(str + "it")
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	var n int
	fmt.Scanf("%d\n", &n)
	var output = make([]string, n)
	if n%2 == 1 {
		output[n-1] = "I hate it"
	} else {
		output[n-1] = "I love it"
	}
	n--
	for n > 0 {

		if n%2 == 0 {
			output[n-1] = " I love that"
		} else {
			output[n-1] = " I hate that"
		}
		n--

	}
	fmt.Print(strings.Join(output, " ")[1:])
}

package main

import (
	"fmt"
)

func main() {
	var n, i int
	fmt.Scan(&n)
	hIt := "I hate it"
	lIt := "I love it"
	hThat := "I hate that"
	lThat := "I love that"
	if n == 1 {
		fmt.Println(hIt)
	} else if n == 2 {
		fmt.Println(hThat + " " + lIt)
	} else {
		if n%2 == 1 {
			for i = 1; i < n-1; i++ {
				fmt.Print(hThat)
				fmt.Print(" " + lThat + " ")
			}
			fmt.Print(hIt)
		} else {
			fmt.Print(hThat)
			for i = 1; i < n-2; i++ {
				fmt.Print(" " + lThat + " ")
				fmt.Print(hThat)
			}
			fmt.Print(" " + lIt)
		}
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func getNextInt(scanner *bufio.Scanner) int {
	scanner.Scan()
	i, _ := strconv.Atoi(string(scanner.Bytes()))
	return i
}

func getNextInt64(scanner *bufio.Scanner) int64 {
	scanner.Scan()
	i, _ := strconv.ParseInt(string(scanner.Bytes()), 10, 64)
	return i
}

func main() {

	reader := bufio.NewReader(os.Stdin)
	scanner := bufio.NewScanner(reader)
	// Set the split function for the scanning operation.
	scanner.Split(bufio.ScanWords)
	nbCase := getNextInt(scanner)

	messages := []string{"I hate it","I love it"}

	for i:=0; i<nbCase; i++ {
		if i > 0 {
			fmt.Print(" ")
		}
		fmt.Print(messages[i%2])
	}

}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func getNextInt(scanner *bufio.Scanner) int {
	scanner.Scan()
	i, _ := strconv.Atoi(string(scanner.Bytes()))
	return i
}

func getNextInt64(scanner *bufio.Scanner) int64 {
	scanner.Scan()
	i, _ := strconv.ParseInt(string(scanner.Bytes()), 10, 64)
	return i
}

func main() {

	reader := bufio.NewReader(os.Stdin)
	scanner := bufio.NewScanner(reader)
	// Set the split function for the scanning operation.
	scanner.Split(bufio.ScanWords)
	nbCase := getNextInt(scanner)

	messages := []string{"I hate it ","I love it "}

	for i:=0; i<nbCase; i++ {
		fmt.Print(messages[i%2])
	}

}

package main

import "fmt"

func main() {
  var n int
  fmt.Scan(&n)

  for i := 1; i <= n; i++ {
    if i%2 == 1 {
      fmt.Print("I hate that ")
      continue
    }
    fmt.Print("I love that ")
  }
  fmt.Print("it")
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	count := 0
	for scanner.Scan() {
		count, _ = strconv.Atoi(scanner.Text())
	}
	for i := 1; i <= count; i++ {
		if i%2 == 0 {
			fmt.Print("I love that ")
		} else {
			fmt.Print("I hate it ")
		}
	}
}

package main
import "fmt"
func main() {
	var n int
	fmt.Scan(&n)
	n+=1
	for i := 1; i < n; i++ {
	    if i%2 == 0 {
	        fmt.Print("I love it")
	        fmt.Print(" ")
	    }else {
	        fmt.Print("I hate that")
	        if i != n-1 { fmt.Print(" ") }
	    }
	}
	fmt.Println()
}

package main

import	"fmt"

func main(){
	var n int
	fmt.Scanln(&n)

		if n%3==1{
			fmt.Print("I hate it")
		}else if n%3==2{
			fmt.Print("I hate that I love it")
		}else{
			fmt.Print("I hate that I love that I hate it")
		}

}

package main

import (
	"fmt"
	"strings"
)

const (
	hate      = "I hate"
	love      = "I love"
	delimiter = " that "
	end       = " it"
)

func main() {
	var n int

	fmt.Scanf("%d", &n)
	hulk(n)
}

func hulk(n int) string {
	var retSlice []string
	for i := 0; i < n; i++ {
		if i%2 == 0 {
			retSlice = append(retSlice, hate)
		} else {
			retSlice = append(retSlice, love)
		}
	}
	ret := strings.Join(retSlice, delimiter)
	return ret + end
}

package main

import (
	"fmt"
)

func main() {
	var N int
	fmt.Scan(&N)
	ans := ""
	for i := 0; i < N; i++ {
		if len(ans) > 0 {
			ans += " that "
		}
		if i % 2 == 0 {
			ans += "I hate"
		} else {
			ans += "I love"
		}
	}
	ans += " it."
	fmt.Println(ans)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

const (
	maxn = 40000
	top  = 1000000001
)

func main() {
	in := bufio.NewScanner(os.Stdin)
	in.Split(bufio.ScanWords)
	in.Buffer(nil, 1e9)

	nextInt := func() int {
		in.Scan()
		vv, _ := strconv.Atoi(in.Text())
		return vv
	}
	z := make([]int, maxn)
	z[0] = 0
	z[1] = 0
	up := 0
	for i := 2; i < maxn; i++ {
		t := i / 3
		m := i % 3
		a := t
		b := t
		c := t
		if m == 2 {
			a++
			b++
		}
		if m == 1 {
			a++
		}
		z[i] = 2 * (a*b + b*c + a*c)
		if z[i] > top {
			up = i
			break
		}
	}
	t := nextInt()
	sol := func() int {
		n := nextInt()
		l, h := 0, up
		for l < h {
			m := (l + h + 1) / 2
			if z[m] < n {
				l = m
			} else {
				h = m - 1
			}
		}
		return h + 1
	}
	for ; t > 0; t-- {
		fmt.Println(sol())
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

const (
	maxn = 40000
	top  = 1000000001
)

func main() {
	in := bufio.NewScanner(os.Stdin)
	in.Split(bufio.ScanWords)
	in.Buffer(nil, 1e9)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	nextInt := func() int {
		in.Scan()
		vv, _ := strconv.Atoi(in.Text())
		return vv
	}
	z := make([]int, maxn)
	z[0] = 0
	z[1] = 0
	up := 0
	for i := 2; i < maxn; i++ {
		t := i / 3
		m := i % 3
		a := t
		b := t
		c := t
		if m == 2 {
			a++
			b++
		}
		if m == 1 {
			a++
		}
		z[i] = 2 * (a*b + b*c + a*c)
		if z[i] > top {
			up = i
			break
		}
	}
	t := nextInt()
	sol := func() int {
		n := nextInt()
		l, h := 0, up
		for l < h {
			m := (l + h + 1) / 2
			if z[m] < n {
				l = m
			} else {
				h = m - 1
			}
		}
		return h + 1
	}
	for ; t > 0; t-- {
		fmt.Fprintln(out, sol())
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

const (
	maxn = 1000000
)

func main() {
	in := bufio.NewScanner(os.Stdin)
	in.Split(bufio.ScanWords)
	in.Buffer(nil, 1e9)

	nextInt := func() int {
		in.Scan()
		vv, _ := strconv.Atoi(in.Text())
		return vv
	}
	z := make([]int64, maxn)
	z[0] = 0
	z[1] = 0
	for i := 2; i < maxn; i++ {
		t := int64(i / 3)
		m := i % 3
		a := t
		b := t
		c := t
		if m == 2 {
			a++
			b++
		}
		if m == 1 {
			a++
		}
		z[i] = 2 * (a*b + b*c + a*c)
		// fmt.Println(i, z[i])
	}

	t := nextInt()
	sol := func() int {
		n := int64(nextInt())
		l, h := 0, maxn-1
		for l < h {
			m := (l + h + 1) / 2
			if z[m] < n {
				l = m
			} else {
				h = m - 1
			}
		}
		return h + 1
	}
	for ; t > 0; t-- {
		fmt.Println(sol())
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

var r = bufio.NewReader(os.Stdin)
var w = bufio.NewWriter(os.Stdout)

func slove(T int) {

}

type entry struct {
	x, y int
}

func main() {
	defer w.Flush()
	var T int
	fmt.Fscan(r, &T)
	reme := make([]entry, 0)
	i := 0
	cnt := 0
	diff := 0
	for {
		if i % 3 != 2 {
			diff += 2
		}
		cnt += diff
		i += 1
		reme = append(reme, entry{cnt, i})
		if cnt > 1e9 {
			break
		}
	}
	for t:=1;t<=T;t++ {
		var n int
		fmt.Fscan(r, &n)
		i := sort.Search(len(reme), func(i int) bool {
			return reme[i].x >= n
		})
		fmt.Fprintln(w, reme[i].y + 1)
	}
}

package main

import (
	"bufio"
	. "fmt"
	"os"
	"sort"
)

type Int int64

const (
	INF = 3e5 + 10
	L0  = Int(0)
	L1  = Int(1)
)

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var t int
	Fscan(in, &t)

	f := make([]Int, 0, 100000)

	var a, b, c Int

	for {
		s := (a*b + a*c + b*c) << 1
		if s <= 1e9 {
			f = append(f, s)
		} else {
			break
		}
		c++
		a, b, c = b, c, a
	}

	for tt := 0; tt < t; tt++ {
		var n Int
		Fscan(in, &n)
		ans := sort.Search(len(f), func(i int) bool {
			return f[i] >= n
		})
		Fprintln(out, ans)
	}

}

func MakeGrid(h, w int) [][]Int {
	index := make([][]Int, h)
	data := make([]Int, h*w)
	for i := 0; i < h; i++ {
		index[i] = data[i*w : (i+1)*w]
	}
	return index
}

func Abs(x Int) Int {
	if x > 0 {
		return x
	}
	return -x
}

func Min(nums ...Int) Int {
	return nums[MinIdx(nums...)]
}

func MinIdx(nums ...Int) Int {
	maxNumIdx := L0
	for i, num := range nums {
		if num < nums[maxNumIdx] {
			maxNumIdx = Int(i)
		}
	}
	return maxNumIdx
}

func Max(nums ...Int) Int {
	return nums[MaxIdx(nums...)]
}

func MaxIdx(nums ...Int) Int {
	maxNumIdx := L0
	for i, num := range nums {
		if num > nums[maxNumIdx] {
			maxNumIdx = Int(i)
		}
	}
	return maxNumIdx
}

var (
	mod  Int
	fmod func(Int) Int = doNothing
)

// SetMod sets the mod. It must be called first.
func SetMod(newMod Int) {
	mod = newMod
	fmod = dynamicMod
}

func dynamicMod(m Int) Int {
	m %= mod
	if m < 0 {
		return m + mod
	}
	return m
}

func doNothing(m Int) Int {
	return m
}

// Mod returns m % mod.
func (m Int) Mod() Int {
	return fmod(m)
}

// Inv returns modular multiplicative inverse
func (m Int) Inv() Int {
	return m.Pow(Int(0).Sub(2))
}

// Pow returns m^n
func (m Int) Pow(n Int) Int {
	p := Int(1)
	for n > 0 {
		if n&1 == 1 {
			p.MulAs(m)
		}
		m.MulAs(m)
		n >>= 1
	}
	return p
}

// Add returns m+x
func (m Int) Add(x Int) Int {
	return (m + x).Mod()
}

// Sub returns m-x
func (m Int) Sub(x Int) Int {
	return (m - x).Mod()
}

// Mul returns m*x
func (m Int) Mul(x Int) Int {
	return (m * x).Mod()
}

// Div returns m/x
func (m Int) Div(x Int) Int {
	return m.Mul(x.Inv())
}

// AddAs assigns *m + x to *m and returns m
func (m *Int) AddAs(x Int) *Int {
	*m = m.Add(x)
	return m
}

// SubAs assigns *m - x to *m and returns m
func (m *Int) SubAs(x Int) *Int {
	*m = m.Sub(x)
	return m
}

// MulAs assigns *m * x to *m and returns m
func (m *Int) MulAs(x Int) *Int {
	*m = m.Mul(x)
	return m
}

// DivAs assigns *m / x to *m and returns m
func (m *Int) DivAs(x Int) *Int {
	*m = m.Div(x)
	return m
}

func (m *Int) MaxAs(x ...Int) *Int {
	*m = Max(append(x, *m)...)
	return m
}

func (m *Int) MinAs(x ...Int) *Int {
	*m = Min(append(x, *m)...)
	return m
}

package main

import (
	"bufio"
	. "fmt"
	"os"
	"sort"
)

type Int int64

const (
	INF = 3e5 + 10
	L0  = Int(0)
	L1  = Int(1)
)

func check(i Int) Int {
	m := i - 1
	k := m/3 - 1

	ans := 3 + (1+k)*k/2*3*2 + k*3

	if m%3 == 0 {
		ans += m / 3 * 2
		ans += 0
	} else if m%3 == 1 {
		ans += m / 3 * 4
		ans += 1
	} else if m%3 == 2 {
		ans += m / 3 * 6
		ans += 3
	}
	return ans * 2

}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var t int
	Fscan(in, &t)

	for tt := 0; tt < t; tt++ {
		var n Int
		Fscan(in, &n)

		ans := sort.Search(100000, func(i int) bool {
			return check(Int(i)) >= n
		})
		Fprintln(out, ans)
	}

}

func MakeGrid(h, w int) [][]Int {
	index := make([][]Int, h)
	data := make([]Int, h*w)
	for i := 0; i < h; i++ {
		index[i] = data[i*w : (i+1)*w]
	}
	return index
}

func Abs(x Int) Int {
	if x > 0 {
		return x
	}
	return -x
}

func Min(nums ...Int) Int {
	return nums[MinIdx(nums...)]
}

func MinIdx(nums ...Int) Int {
	maxNumIdx := L0
	for i, num := range nums {
		if num < nums[maxNumIdx] {
			maxNumIdx = Int(i)
		}
	}
	return maxNumIdx
}

func Max(nums ...Int) Int {
	return nums[MaxIdx(nums...)]
}

func MaxIdx(nums ...Int) Int {
	maxNumIdx := L0
	for i, num := range nums {
		if num > nums[maxNumIdx] {
			maxNumIdx = Int(i)
		}
	}
	return maxNumIdx
}

var (
	mod  Int
	fmod func(Int) Int = doNothing
)

// SetMod sets the mod. It must be called first.
func SetMod(newMod Int) {
	mod = newMod
	fmod = dynamicMod
}

func dynamicMod(m Int) Int {
	m %= mod
	if m < 0 {
		return m + mod
	}
	return m
}

func doNothing(m Int) Int {
	return m
}

// Mod returns m % mod.
func (m Int) Mod() Int {
	return fmod(m)
}

// Inv returns modular multiplicative inverse
func (m Int) Inv() Int {
	return m.Pow(Int(0).Sub(2))
}

// Pow returns m^n
func (m Int) Pow(n Int) Int {
	p := Int(1)
	for n > 0 {
		if n&1 == 1 {
			p.MulAs(m)
		}
		m.MulAs(m)
		n >>= 1
	}
	return p
}

// Add returns m+x
func (m Int) Add(x Int) Int {
	return (m + x).Mod()
}

// Sub returns m-x
func (m Int) Sub(x Int) Int {
	return (m - x).Mod()
}

// Mul returns m*x
func (m Int) Mul(x Int) Int {
	return (m * x).Mod()
}

// Div returns m/x
func (m Int) Div(x Int) Int {
	return m.Mul(x.Inv())
}

// AddAs assigns *m + x to *m and returns m
func (m *Int) AddAs(x Int) *Int {
	*m = m.Add(x)
	return m
}

// SubAs assigns *m - x to *m and returns m
func (m *Int) SubAs(x Int) *Int {
	*m = m.Sub(x)
	return m
}

// MulAs assigns *m * x to *m and returns m
func (m *Int) MulAs(x Int) *Int {
	*m = m.Mul(x)
	return m
}

// DivAs assigns *m / x to *m and returns m
func (m *Int) DivAs(x Int) *Int {
	*m = m.Div(x)
	return m
}

func (m *Int) MaxAs(x ...Int) *Int {
	*m = Max(append(x, *m)...)
	return m
}

func (m *Int) MinAs(x ...Int) *Int {
	*m = Min(append(x, *m)...)
	return m
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)
var wrtr = bufio.NewWriterSize(os.Stdout, 10_000_000)
var rdr = bufio.NewScanner(os.Stdin)
func gs() string  { rdr.Scan(); return rdr.Text() }
func gi() int     { i,e := strconv.Atoi(gs()); if e != nil {panic(e)}; return i }
func vecintstring(a []int) string { astr := make([]string,len(a)); for i,a := range a { astr[i] = strconv.Itoa(a) }; return strings.Join(astr," ") }
func main() {
	//f1, _ := os.Create("cpu.prof"); pprof.StartCPUProfile(f1); defer pprof.StopCPUProfile()
	defer wrtr.Flush()
	infn := ""; if infn == "" && len(os.Args) > 1 {	infn = os.Args[1] }
	if infn != "" {	f, e := os.Open(infn); if e != nil { panic(e) }; rdr = bufio.NewScanner(f) }
	rdr.Split(bufio.ScanWords); rdr.Buffer(make([]byte,1024),1_000_000_000)
	// PROGRAM STARTS HERE
	T := gi()
	for tt:=1;tt<=T;tt++ {
		N := gi()
		check := func(k int) bool {
			i1 := k/3; i2 := i1; i3 := i1; m := k%3; if m > 0 { i1++ }; if m > 1 { i2++ }
			return 2*i1*i2+2*i1*i3+2*i2*i3 >= N
		}
		l,r := 1,39000
		for r-l > 1 { m := (r+l)>>1; if check(m) { r = m } else { l = m } }
		fmt.Fprintln(wrtr,r)
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

var in, out = bufio.NewReader(os.Stdin), bufio.NewWriter(os.Stdout)

func main() {
	defer out.Flush()

	triangles := []int{0, 0, 2, 6}
	var a, b, c int = 1, 1, 1
	var cross, plus int = 0, 3
	for i := 4; triangles[len(triangles)-1] < 1e9; i++ {
		a, b, c = c+1, a, b
		cross++
		plus += b + c - 3
		triangles = append(triangles, cross*6+plus*2)
	}

	var tc int
	for fmt.Fscan(in, &tc); tc > 0; tc-- {
		var n int
		fmt.Fscan(in, &n)
		fmt.Fprintln(out, sort.SearchInts(triangles, n))
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

func main() {
	var reader *bufio.Reader = bufio.NewReader(os.Stdin)
	var writer *bufio.Writer = bufio.NewWriter(os.Stdout)
	defer writer.Flush()
	var T int
	fmt.Scan(&T)
	var n int
	precalc := make([]int, 0)
	vals := []int{0, 0, 0}
	cur := 0
	for i := 0; ; i++ {
		x := i % 3
		lines := vals[(x+1)%3] + vals[(x+2)%3]
		lines *= 2
		cur += lines
		precalc = append(precalc, cur)
		if cur > 1000000000 {
			break
		}
		vals[x]++
	}
	for t := 0; t < T; t++ {
		fmt.Fscan(reader, &n)
		ans := sort.SearchInts(precalc, n)
		fmt.Fprintln(writer, ans+1)
	}
}


package main

import "fmt"

func main() {
	var s string
	var n int
	fmt.Scan(&n)
	fmt.Scan(&s)
	l := len(s)
	flag := 0
	fmt.Printf("%c", s[0])
	if (s[0] == 'e') {
	        flag += 1
	    } else  if (s[0] == 'o') {
	        flag += 1
	    }
	for i := 1; i < l; i++ {
	    if (s[i] != s[i - 1]) {
	        if (flag == 2) {
                fmt.Printf("%c", s[i - 1])
            }
            fmt.Printf("%c", s[i])
            flag = 0
	    } else if (s[i] != 'a') {
	        if (s[i] != 'o') {
	            if (s[i] != 'e') {
	                if (s[i] != 'i') {
	                    if (s[i] != 'u') {
	                        if (s[i] != 'y') {
	                            fmt.Printf("%c", s[i])
	                        }
	                    }
	                }
	            }
	        }
	    }
	    if (s[i] == 'e') {
	        flag += 1
	    } else  if (s[i] == 'o') {
	        flag += 1
	    }
    }
    if (flag == 2) {
        fmt.Printf("%c", s[l - 1])
    }
}

package main

import (
	"fmt"
)

func main() {
	var n int
    var s string

    fmt.Scanf("%d\n", &n)
    fmt.Scanf("%s", &s)

    s += "."

    last := s[0]
    cnt := 1

    for i:=1; i <=n; i++ {
        if s[i] == last {
            cnt++
        } else {
            if (last == 'a' || last == 'e' || last == 'o' || last == 'u' || last == 'i' || last == 'y') {
                if (cnt == 2 && (last == 'e' || last == 'o')) {
                    cnt = 2
                } else {
                    cnt = 1
                }
	       }

            for j:=1; j <= cnt; j++ {
                fmt.Printf("%c", last)
            }

            cnt = 1
            last = s[i]
        }
    }
}

package main

import (
	"fmt"
	"bytes"
	"strings"
)

func main() {
	var n int
	fmt.Scan(&n)
	var line string;
	fmt.Scan(&line)
        vowel := "aeiouy";
        var last string = "";
        count := 0;
        var builder bytes.Buffer
        for i := 0; i < n; i++ {
            if string(line[i]) != last {
                if count > 0 {
                    if last == "e" || last == "o" {
                        if count == 2 {
                            for j := 0; j < count; j++ {
                                builder.WriteString(last);
                            }
                        } else {
                            builder.WriteString(last);
                        }
                    } else if strings.ContainsAny(vowel, last){
                        builder.WriteString(last);
                    } else {
                        for j := 0; j < count; j++ {
                            builder.WriteString(last);
                        }
                    }
                }
                count = 0;
            }
            last = string(line[i]);
            count++;
        }
        if count > 0 {
            if last == "e" || last == "o" {
                if count == 2 {
                    for j := 0; j < count; j++ {
                        builder.WriteString(last);
                    }
                } else {
                    builder.WriteString(last);
                }
            } else if strings.ContainsAny(vowel, last) {
                builder.WriteString(last);
            } else {
                for j := 0; j < count; j++ {
                    builder.WriteString(last);
                }
            }
        }
	fmt.Println(builder.String())
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	var n int
    var s string
    fmt.Scanf("%d\n", &n)
    fmt.Scanln(&s)
    res := ""
    //fmt.Printf("%d; %s\n", n, s)

    prev := '0'
    cnt := 0
    vowels := "aeoiuy"
    special := "eo"
    for _, char := range s {
    	//fmt.Printf("%c %d\n", char, no)
    	if prev != char {
    		if ( cnt == 2 && strings.ContainsRune(special, prev) ) {
    			res += string(prev)
    		}
    		res += string(char)
    		prev = char
    		cnt = 1
    	} else {
    	    if ( ! strings.ContainsRune(vowels, char) ) {
    	        res += string(char)
    	    }
    		cnt++
    	}
    	//fmt.Println(string(char), cnt)
    }
    if ( cnt == 2 && strings.ContainsRune(special, prev) ) {
    	res += string(prev)
    }
    fmt.Println(res)
    return
}

package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	var s string
	fmt.Scan(&s)

	for i := 0; i < n; i++ {
		if s[i]!='a'&&s[i]!='e'&&s[i]!='i'&&s[i]!='o'&&s[i]!='u'&&s[i]!='y' {
			fmt.Printf("%c", s[i])
		} else {
			cnt := 0
			j :=i
		    for  ;j<n&&s[i]==s[j];j++{
		        cnt++
			}
			if cnt==2 && s[i]=='o'{
		        fmt.Printf("%c%c", s[i],s[i])
		        i=j-1
			}else{
			    if cnt==2 && s[i]=='e'{
			        fmt.Printf("%c%c", s[i],s[i])
			        i=j-1
			    }else{
			        fmt.Printf("%c", s[i])
			        i=j-1
			    }
			}
		}
	}
}

package main

import "fmt"

func main() {
	var n, i int
	fmt.Scan(&n)
	var s string
	fmt.Scan(&s)
	for i = 0; i < n; i++ {
	    fmt.Printf("%c", s[i])
	    if s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' || s[i] == 'u' || s[i] == 'y' {
	        var ch = s[i]
	        var cc = 0
	        for ; i < n && ch == s[i]; i++ {
	            cc += 1
	        }
	        if cc == 2 && (s[i - 1] == 'e' || s[i - 1] == 'o') {
	            fmt.Printf("%c", ch)
	            i--
	            continue
	        }
	        i--
	    }
	}
}

package main
import "fmt"
import "regexp"

func main(){
	var n int
	fmt.Scan(&n)
	var s string
	fmt.Scan(&s)
	r := regexp.MustCompile("a+")
	s = r.ReplaceAllString(s, "a")
	r = regexp.MustCompile("i+")
	s = r.ReplaceAllString(s, "i")
	r = regexp.MustCompile("u+")
	s = r.ReplaceAllString(s, "u")
	r = regexp.MustCompile("y+")
	s = r.ReplaceAllString(s, "y")
	r = regexp.MustCompile("ooo+")
	s = r.ReplaceAllString(s, "o")
	r = regexp.MustCompile("eee+")
	s = r.ReplaceAllString(s, "e")
	fmt.Println(s)
}

package main

import (
    "bytes"
    "fmt"
)

func isVowel(x uint8) bool{
    if(x=='a') {return true};
    if(x=='e') {return true};
    if(x=='i') {return true};
    if(x=='o') {return true};
    if(x=='u') {return true};
    if(x=='y') {return true};
    return false;
}

func main(){
    var n int
    var str string
    var s string
    fmt.Scan(&n)
    fmt.Scan(&str)
    var buffer bytes.Buffer
    var out bytes.Buffer
    var prev uint8
    prev=0;
    for i:=0; i<n; i++{
        if(prev!=0&&prev!=str[i]){
            s=buffer.String();
            //fmt.Println(s);
            if(len(s)!=0){
                if(isVowel(s[0])&&s!="oo"&&s!="ee"){
                    out.WriteByte(s[0])
                } else{
                    out.WriteString(s)
                }
            }
            buffer.Reset();
        }
        buffer.WriteByte(str[i])
        prev=str[i];
    }
    s=buffer.String();
    if(len(s)!=0){
        if(isVowel(s[0])&&s!="oo"&&s!="ee"){
            out.WriteByte(s[0])
        } else{
            out.WriteString(s)
        }
    }
    fmt.Println(out.String())

}

package main

import "fmt"
func in(a byte, list []byte) bool {
    for _, b := range list {
        if b == a {
            return true
        }
    }
    return false
}
func main() {
	var s string
	var ss string
	var n int
	fmt.Scan(&n)
	fmt.Scan(&s)
	cc := s[0]
	glass := []byte{'e','u','i','o','a','y'}
	count := 1
	for i := 1; i < len(s); i++ {
	    c := s[i]
	    if c == cc {
	        count++
	    } else if(in(cc, glass)) {
	        if (count == 2 && (cc == 'e' || cc == 'o')) {
	            ss += string(cc)
	            ss += string(cc)
	        } else {
	            ss += string(cc)
	        }
	        cc = c
	        count = 1
	    } else {
	        for l := 0; l < count; l++ {
	            ss += string(cc)
	        }
	        cc = c
	        count = 1
	    }
	}
	if(in(cc, glass)) {
	        if (count == 2 && (cc == 'e' || cc == 'o')) {
	            ss += string(cc)
	            ss += string(cc)
	        } else {
	            ss += string(cc)
	        }
	    } else {
	        for l := 0; l < count; l++ {
	            ss += string(cc)
	        }
	    }
	fmt.Println(ss)
}

package main

import "fmt"

func main() {
	var s string
	var n int
	fmt.Scan(&n)
	fmt.Scan(&s)
	l := len(s)
	flag := 0
	fmt.Printf("%c", s[0])
	for i := 1; i < l; i++ {
	    if (s[i] != s[i - 1]) {
	        if (flag == 2) {
                fmt.Printf("%c", s[i - 1])
            }
            fmt.Printf("%c", s[i])
            flag = 0
	    }
	    if (s[i] == 'e') {
	        flag += 1
	    } else  if (s[i] == 'o') {
	        flag += 1
	    }
    }
    if (flag == 2) {
        fmt.Printf("%c", s[l - 1])
    }
}

package main

import "fmt"

func main() {
	var s string
	var n int
	fmt.Scan(&n)
	fmt.Scan(&s)
	l := len(s)
	fmt.Printf("%c", s[0])
	for i := 1; i < l; i++ {
	    if (s[i] != s[i - 1]) {
            fmt.Printf("%c", s[i])
	    }
    }
}

package main

import "fmt"

func main() {
	var s string
	var n int
	fmt.Scan(&n)
	fmt.Scan(&s)
	l := len(s)
	flag := 0
	fmt.Printf("%c", s[0])
	for i := 1; i < l; i++ {
	    if (s[i] != s[i - 1]) {
	        if (flag == 2) {
                fmt.Printf("%c", s[i - 1])
            }
            fmt.Printf("%c", s[i])
            flag = 0
	    } else if (s[i] != 'a') {
	        if (s[i] != 'o') {
	            if (s[i] != 'e') {
	                if (s[i] != 'i') {
	                    if (s[i] != 'u') {
	                        if (s[i] != 'y') {
	                            fmt.Printf("%c", s[i])
	                        }
	                    }
	                }
	            }
	        }
	    }
	    if (s[i] == 'e') {
	        flag += 1
	    } else  if (s[i] == 'o') {
	        flag += 1
	    }
    }
    if (flag == 2) {
        fmt.Printf("%c", s[l - 1])
    }
}

package main

import "fmt"
func in(a byte, list []byte) bool {
    for _, b := range list {
        if b == a {
            return true
        }
    }
    return false
}
func main() {
	var s string
	var ss string
	var n int
	fmt.Scan(&n)
	fmt.Scan(&s)
	cc := s[0]
	glass := []byte{'e','u','i','o','a','y'}
	count := 0
	for i := 1; i < len(s); i++ {
	    c := s[i]
	    if c == cc {
	        count++
	    } else if(in(cc, glass)) {
	        if (count == 2 && (cc == 'e' || cc == 'o')) {
	            ss += string(cc)
	            ss += string(cc)
	        } else {
	            ss += string(cc)
	        }
	        cc = c
	        count = 1
	    } else {
	        for l := 0; l < count; l++ {
	            ss += string(cc)
	        }
	        cc = c
	        count = 1
	    }
	}
	if(in(cc, glass)) {
	        if (count == 2 && (cc == 'e' || cc == 'o')) {
	            ss += string(cc)
	            ss += string(cc)
	        } else {
	            ss += string(cc)
	        }
	    } else {
	        for l := 0; l < count; l++ {
	            ss += string(cc)
	        }
	    }
	fmt.Println(ss)
}

package main

import "fmt"

func main() {
	var s string
	var ss string
	var n int
	fmt.Scan(&n)
	fmt.Scan(&s)
	cc := s[0]
	count := 0
	for i := 1; i < len(s); i++ {
	    c := s[i]
	    if c == cc {
	        count++
	    } else {
	        if (count == 2 && (cc == 'e' || cc == 'o')) {
	            ss += string(cc)
	            ss += string(cc)
	        } else {
	            ss += string(cc)
	        }
	        cc = c
	        count = 1
	    }
	}
	if (count == 2 && (cc == 'e' || cc == 'o')) {
	    ss += string(cc)
	    ss += string(cc)
	} else {
	    ss += string(cc)
	}
	fmt.Println(ss)
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	var n int
    var s string
    fmt.Scanf("%d\n", &n)
    fmt.Scanln(&s)
    res := ""
    //fmt.Printf("%d; %s\n", n, s)

    prev := '0'
    cnt := 0
    vowels := "aeoiuy"
    for _, char := range s {
    	//fmt.Printf("%c %d\n", char, no)
    	if strings.ContainsRune(vowels, char) {
	    	if prev != char {
	    		if cnt == 2 {
	    			res += string(prev)
	    		}
	    		res += string(char)
	    		prev = char
	    		cnt = 1
	    	} else {
	    		cnt++
	    	}
    	} else {
    	    res += string(char)
    	}
    }
    if cnt == 2 {
    	res += string(prev)
    }
    fmt.Println(res)
    return
}

package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	var s string
	fmt.Scan(&s)
	fmt.Printf("%c", s[0]);
	for i := 1; i < n; i++ {
	    if s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' || s[i] == 'u' || s[i] == 'y' {
		    if s[i] != s[i-1] {
			    fmt.Printf("%c", s[i]);
		    } else {

		    }
	    } else {
	        fmt.Printf("%c", s[i]);
	    }
	}
}