def counter_game(n):
    # Time complexity: O(log(n))
    # Space complexity (ignoring input): O(1)
    if n == 1:
        return "Louise"

    count = 0
    while n > 1:
        is_power_of_2 = (n & (n - 1)) == 0
        if is_power_of_2:
            while n > 1:
                n = n / 2
                count += 1
        else:
            power_of_2 = 2
            while power_of_2 * 2 < n:
                power_of_2 = power_of_2 * 2
            n = n - power_of_2
            count += 1
    if count % 2 == 0:
        return "Richard"

    return "Louise"

fn counter_game(n: i64) -> String {
    //Time complexity: O(log(n))
    //Space complexity (ignoring input): O(1)
    let mut n = n;
    let mut count_turns = 0;
    while n > 1 {
        let n_is_power_2 = n & (n - 1) == 0;
        if n_is_power_2 {
            while n > 1 {
                n = n >> 1;
                count_turns += 1;
            }
        } else {
            let mut pow_2 = 1;
            while pow_2 * 2 < n {
                pow_2 = pow_2 << 1;
            }
            n = n - pow_2;
            count_turns += 1;
        }
    }

    if count_turns % 2 == 0 {
        return String::from("Richard");
    } else {
        return String::from("Louise");
    }
}

#Python 3
def counterGame(n):
    turns = 0
    while n > 1:
        power = 1 << (n.bit_length() - 1) #uses bit length to quickly calculate the largest power of 2 <= n
        if n == power:
            n >>=1 #use a bit shift to quickly divide by 2
        else: 
            n -= power
        turns += 1
           
    return "Louise" if turns %2 != 0 else "Richard"

import itertools
import typing


def counterGame(n: int) -> typing.Literal["Louise", "Richard"]:
    other_player = {"Louise": "Richard", "Richard": "Louise"}
    for player in itertools.cycle(("Louise", "Richard")):
        if n == 1:
            return other_player[player]
        power = n.bit_length() - 1
        if f"{n:b}".endswith(zeros := power * "0", 1):
            return player if power % 2 else other_player[player]
        n -= int(f"1{zeros}", 2)

// Problem Understanding:
// Players: Two players take turns, starting with Player 1.
// Objective: Start with a number n and on each turn, a player can either:
// Halve the number (if it's even).
// Subtract 1 from the number (if it's odd).
// The game continues until the number becomes 1. The player who makes the number reach 1 wins.
// The goal is to determine the winner, assuming both players play optimally.
// Steps to Solve:
// Input and Output:

// Input: A number n.
// Output: The winner (either "Richard" or "Louise").
// Alternating Moves:

// Players alternate turns, starting with Player 1 (often called "Louise").
// If the number is even, the optimal move is to halve it.
// If the number is odd, the optimal move is to subtract 1 to make it even, so the next player can halve it.
// Determining the Winner:

// Keep track of the number of moves.
// The game ends when n becomes 1. The player who makes the last move is the winner.
// Approach:
// Game Simulation: Simulate the game with a while loop until n becomes 1.
// If n is even, halve it.
// If n is odd, subtract 1.
// Count the number of moves.
// Decide the Winner: The winner depends on the number of moves:
// If the number of moves is odd, the first player ("Louise") wins.
// If the number of moves is even, the second player ("Richard") wins.
#include <stdio.h>

int popcount(unsigned long long int n) {
  int count = 0;
  while (n) {
    n &= (n - 1);
    count++;
  }
  return count;
}

int main() {
  int t;
  scanf("%d\n", &t);
  while (t--) {
    unsigned long long int n;
    scanf("%llu\n", &n);
    printf("%s\n", popcount(n - 1) & 1 ? "Louise" : "Richard");
  }
  return 0;
}