import java.util.Scanner;

class TreeNode {
    int value;
    TreeNode left, right;
    int height;

    TreeNode(int value) {
        this.value = value;
        this.height = 1;
        this.left = this.right = null;
    }
}

class AVLTree {
    private TreeNode root;

    public AVLTree() {
        this.root = null;
    }

    private int getHeight(TreeNode node) {
        if (node == null) return 0;
        return node.height;
    }

    private void updateHeight(TreeNode node) {
        if (node != null) {
            node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));
        }
    }

    private int getBalanceFactor(TreeNode node) {
        if (node == null) return 0;
        return getHeight(node.left) - getHeight(node.right);
    }

    private TreeNode rotateRight(TreeNode y) {
        TreeNode x = y.left;
        TreeNode T2 = x.right;

        x.right = y;
        y.left = T2;

        updateHeight(y);
        updateHeight(x);

        return x;
    }

    private TreeNode rotateLeft(TreeNode x) {
        TreeNode y = x.right;
        TreeNode T2 = y.left;

        y.left = x;
        x.right = T2;

        updateHeight(x);
        updateHeight(y);

        return y;
    }

    private TreeNode balance(TreeNode node) {
        if (node == null) return null;

        updateHeight(node);
        int balance = getBalanceFactor(node);

        if (balance > 1) {
            if (getBalanceFactor(node.left) < 0) {
                node.left = rotateLeft(node.left);
            }
            return rotateRight(node);
        }

        if (balance < -1) {
            if (getBalanceFactor(node.right) > 0) {
                node.right = rotateRight(node.right);
            }
            return rotateLeft(node);
        }

        return node;
    }

    private TreeNode insert(TreeNode node, int value) {
        if (node == null) return new TreeNode(value);

        if (value < node.value) {
            node.left = insert(node.left, value);
        } else {
            node.right = insert(node.right, value);
        }

        return balance(node);
    }

    public void insertRoot(int value) {
        root = insert(root, value);
    }

    public int searchNode(int height, String road) {
        int rootValue = (int) Math.pow(2, height + 1) - 1;

        if (road.isEmpty()) {
            return rootValue;
        }

        TreeNode node = root;
        for (char move : road.toCharArray()) {
            if (move == 'L' || move == 'l') {
                if (node.left != null) {
                    node = node.left;
                } else {
                    return -1; 
                }
            } else if (move == 'R' || move == 'r') {
                if (node.right != null) {
                    node = node.right;
                } else {
                    return -1;
                }
            }
        }

        return (node != null) ? node.value : -1;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        AVLTree avlTree = new AVLTree();

        String line = scanner.nextLine().trim();
        String[] parts = line.split(" ");

        int height = Integer.parseInt(parts[0]);
        String road = (parts.length > 1) ? parts[1] : "";

        // Inserir n\xf3s na \xe1rvore com base na altura
        int numNodes = (int) Math.pow(2, height + 1) - 1;
        for (int i = 1; i <= numNodes; i++) {
            avlTree.insertRoot(i);
        }

        System.out.println(avlTree.searchNode(height, road));
    }
}

TreeNode.java:141: error: unmappable character (0xF3) for encoding UTF-8
        // Inserir n�s na �rvore com base na altura
                    ^
TreeNode.java:141: error: unmappable character (0xE1) for encoding UTF-8
        // Inserir n�s na �rvore com base na altura
                          ^
2 errors