At a geometry lesson Bob learnt that a triangle is called right-angled if it is nondegenerate and one of its angles is right. Bob decided to draw such a triangle immediately: on a sheet of paper he drew three points with integer coordinates, and joined them with segments of straight lines, then he showed the triangle to Peter. Peter said that Bob's triangle is not right-angled, but is almost right-angled: the triangle itself is not right-angled, but it is possible to move one of the points exactly by distance 1 so, that all the coordinates remain integer, and the triangle become right-angled. Bob asks you to help him and find out if Peter tricks him. By the given coordinates of the triangle you should find out if it is right-angled, almost right-angled, or neither of these.

Input

The first input line contains 6 space-separated integers x1, y1, x2, y2, x3, y3 — coordinates of the triangle's vertices. All the coordinates are integer and don't exceed 100 in absolute value. It's guaranteed that the triangle is nondegenerate, i.e. its total area is not zero.

Output

If the given triangle is right-angled, output RIGHT, if it is almost right-angled, output ALMOST, and if it is neither of these, output NEITHER.

Examples

Input

0 0 2 0 0 1


Output

RIGHT


Input

2 3 4 5 6 6


Output

NEITHER


Input

-1 0 2 0 0 1


Output

ALMOST
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Locale;
import java.util.Scanner;
import java.util.regex.Pattern;

import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;

public class Main {

	public static void main(String[] args) throws Exception {
        solve(1);	
    }
     
    public static void solve(int testCases) throws Exception{
    	double epsilon = 0.01;
    	Point[] P = new Point[3];
    	for(int i = 0 ; i < 3 ; i++){
    		P[i] = new Point(StdIn.readInt(), StdIn.readInt());
    	}
    	double[] d = new double[3];
    	d[0] = P[0].distance(P[1]);
    	d[1] = P[0].distance(P[2]);
    	d[2] = P[1].distance(P[2]);
    	Arrays.sort(d);
    	if(Math.abs(d[2]*d[2] - (d[0]*d[0] + d[1]*d[1])) < epsilon){
    		StdOut.println("RIGHT");
    		return;
    	}
    	
    	//modify Point[0]
    	Point[] P_new = new Point[3];
    	for(int i = 0 ; i < 3 ; i++){
    		P_new[i] = new Point(P[i]);
    	}
    	
    	P_new[0].setX(1);
    	d[0] = P_new[0].distance(P_new[1]);
    	d[1] = P_new[0].distance(P_new[2]);
    	d[2] = P_new[1].distance(P_new[2]);
    	Arrays.sort(d);
    	//for(Point p : P_new) StdOut.print(p + " ");
		//StdOut.println(d[0] + " " + d[1] + " " +d[2]);
    	if(!P_new[0].equals(P_new[1]) && !P_new[0].equals(P_new[2]) && !P_new[1].equals(P_new[2]))
    	if(Math.abs(d[2]*d[2] - (d[0]*d[0] + d[1]*d[1])) < epsilon){
    		StdOut.println("ALMOST");
    		return;
    	}
    	
    	for(int i = 0 ; i < 3 ; i++){
    		P_new[i] = new Point(P[i]);
    	}
    	
    	P_new[0].setX(-1);
    	d[0] = P_new[0].distance(P_new[1]);
    	d[1] = P_new[0].distance(P_new[2]);
    	d[2] = P_new[1].distance(P_new[2]);
    	Arrays.sort(d);
    	//for(Point p : P_new) StdOut.print(p + " ");
		//StdOut.println(d[0] + " " + d[1] + " " +d[2]);
    	if(!P_new[0].equals(P_new[1]) && !P_new[0].equals(P_new[2]) && !P_new[1].equals(P_new[2]))
    	if(Math.abs(d[2]*d[2] - (d[0]*d[0] + d[1]*d[1])) < epsilon){
    		StdOut.println("ALMOST");
    		return;
    	}
    	
    	for(int i = 0 ; i < 3 ; i++){
    		P_new[i] = new Point(P[i]);
    	}
    	
    	P_new[0].setY(1);
    	d[0] = P_new[0].distance(P_new[1]);
    	d[1] = P_new[0].distance(P_new[2]);
    	d[2] = P_new[1].distance(P_new[2]);
    	Arrays.sort(d);
    	//for(Point p : P_new) StdOut.print(p + " ");
		//StdOut.println(d[0] + " " + d[1] + " " +d[2]);
    	if(!P_new[0].equals(P_new[1]) && !P_new[0].equals(P_new[2]) && !P_new[1].equals(P_new[2]))
    	if(Math.abs(d[2]*d[2] - (d[0]*d[0] + d[1]*d[1])) < epsilon){
    		StdOut.println("ALMOST");
    		return;
    	}
    	
    	for(int i = 0 ; i < 3 ; i++){
    		P_new[i] = new Point(P[i]);
    	}
    	
    	P_new[0].setY(-1);
    	d[0] = P_new[0].distance(P_new[1]);
    	d[1] = P_new[0].distance(P_new[2]);
    	d[2] = P_new[1].distance(P_new[2]);
    	Arrays.sort(d);
    	//for(Point p : P_new) StdOut.print(p + " ");
		//StdOut.println(d[0] + " " + d[1] + " " +d[2]);
    	if(!P_new[0].equals(P_new[1]) && !P_new[0].equals(P_new[2]) && !P_new[1].equals(P_new[2]))
    	if(Math.abs(d[2]*d[2] - (d[0]*d[0] + d[1]*d[1])) < epsilon){
    		StdOut.println("ALMOST");
    		return;
    	}
    	
    	
    	//modify Point[1]
    	for(int i = 0 ; i < 3 ; i++){
    		P_new[i] = new Point(P[i]);
    	}
    	
    	P_new[1].setX(1);
    	d[0] = P_new[0].distance(P_new[1]);
    	d[1] = P_new[0].distance(P_new[2]);
    	d[2] = P_new[1].distance(P_new[2]);
    	Arrays.sort(d);
    	//for(Point p : P_new) StdOut.print(p + " ");
		//StdOut.println(d[0] + " " + d[1] + " " +d[2]);
    	if(!P_new[0].equals(P_new[1]) && !P_new[0].equals(P_new[2]) && !P_new[1].equals(P_new[2]))
    	if(Math.abs(d[2]*d[2] - (d[0]*d[0] + d[1]*d[1])) < epsilon){
    		StdOut.println("ALMOST");
    		return;
    	}
    	
    	for(int i = 0 ; i < 3 ; i++){
    		P_new[i] = new Point(P[i]);
    	}
    	
    	P_new[1].setX(-1);
    	d[0] = P_new[0].distance(P_new[1]);
    	d[1] = P_new[0].distance(P_new[2]);
    	d[2] = P_new[1].distance(P_new[2]);
    	Arrays.sort(d);
    	//for(Point p : P_new) StdOut.print(p + " ");
		//StdOut.println(d[0] + " " + d[1] + " " +d[2]);
    	if(!P_new[0].equals(P_new[1]) && !P_new[0].equals(P_new[2]) && !P_new[1].equals(P_new[2]))
    	if(Math.abs(d[2]*d[2] - (d[0]*d[0] + d[1]*d[1])) < epsilon){
    		StdOut.println("ALMOST");
    		return;
    	}
    	
    	for(int i = 0 ; i < 3 ; i++){
    		P_new[i] = new Point(P[i]);
    	}
    	
    	P_new[1].setY(1);
    	d[0] = P_new[0].distance(P_new[1]);
    	d[1] = P_new[0].distance(P_new[2]);
    	d[2] = P_new[1].distance(P_new[2]);
    	Arrays.sort(d);
    	//for(Point p : P_new) StdOut.print(p + " ");
		//StdOut.println(d[0] + " " + d[1] + " " +d[2]);
    	if(!P_new[0].equals(P_new[1]) && !P_new[0].equals(P_new[2]) && !P_new[1].equals(P_new[2]))
    	if(Math.abs(d[2]*d[2] - (d[0]*d[0] + d[1]*d[1])) < epsilon){
    		StdOut.println("ALMOST");
    		return;
    	}
    	
    	for(int i = 0 ; i < 3 ; i++){
    		P_new[i] = new Point(P[i]);
    	}
    	
    	P_new[1].setY(-1);
    	d[0] = P_new[0].distance(P_new[1]);
    	d[1] = P_new[0].distance(P_new[2]);
    	d[2] = P_new[1].distance(P_new[2]);
    	Arrays.sort(d);
    	//for(Point p : P_new) StdOut.print(p + " ");
		//StdOut.println(d[0] + " " + d[1] + " " +d[2]);
    	if(!P_new[0].equals(P_new[1]) && !P_new[0].equals(P_new[2]) && !P_new[1].equals(P_new[2]))
    	if(Math.abs(d[2]*d[2] - (d[0]*d[0] + d[1]*d[1])) < epsilon){
    		StdOut.println("ALMOST");
    		return;
    	}
    	
    	//modify Point[2]
    	for(int i = 0 ; i < 3 ; i++){
    		P_new[i] = new Point(P[i]);
    	}
    	
    	P_new[2].setX(1);
    	d[0] = P_new[0].distance(P_new[1]);
    	d[1] = P_new[0].distance(P_new[2]);
    	d[2] = P_new[1].distance(P_new[2]);
    	Arrays.sort(d);
    	//for(Point p : P_new) StdOut.print(p + " ");
		//StdOut.println(d[0] + " " + d[1] + " " +d[2]);
    	if(!P_new[0].equals(P_new[1]) && !P_new[0].equals(P_new[2]) && !P_new[1].equals(P_new[2]))
    	if(Math.abs(d[2]*d[2] - (d[0]*d[0] + d[1]*d[1])) < epsilon){
    		StdOut.println("ALMOST");
    		return;
    	}
    	
    	for(int i = 0 ; i < 3 ; i++){
    		P_new[i] = new Point(P[i]);
    	}
    	
    	P_new[2].setX(-1);
    	d[0] = P_new[0].distance(P_new[1]);
    	d[1] = P_new[0].distance(P_new[2]);
    	d[2] = P_new[1].distance(P_new[2]);
    	Arrays.sort(d);
    	//for(Point p : P_new) StdOut.print(p + " ");
		//StdOut.println(d[0] + " " + d[1] + " " +d[2]);
    	if(!P_new[0].equals(P_new[1]) && !P_new[0].equals(P_new[2]) && !P_new[1].equals(P_new[2]))
    	if(Math.abs(d[2]*d[2] - (d[0]*d[0] + d[1]*d[1])) < epsilon){
    		StdOut.println("ALMOST");
    		return;
    	}
    	
    	for(int i = 0 ; i < 3 ; i++){
    		P_new[i] = new Point(P[i]);
    	}
    	
    	P_new[2].setY(1);
    	d[0] = P_new[0].distance(P_new[1]);
    	d[1] = P_new[0].distance(P_new[2]);
    	d[2] = P_new[1].distance(P_new[2]);
    	Arrays.sort(d);
    	//for(Point p : P_new) StdOut.print(p + " ");
		//StdOut.println(d[0] + " " + d[1] + " " +d[2]);
    	if(!P_new[0].equals(P_new[1]) && !P_new[0].equals(P_new[2]) && !P_new[1].equals(P_new[2]))
    	if(Math.abs(d[2]*d[2] - (d[0]*d[0] + d[1]*d[1])) < epsilon){
    		StdOut.println("ALMOST");
    		return;
    	}
    	
    	for(int i = 0 ; i < 3 ; i++){
    		P_new[i] = new Point(P[i]);
    	}
    	
    	P_new[2].setY(-1);
    	d[0] = P_new[0].distance(P_new[1]);
    	d[1] = P_new[0].distance(P_new[2]);
    	d[2] = P_new[1].distance(P_new[2]);
    	Arrays.sort(d);
    	//for(Point p : P_new) StdOut.print(p + " ");
		//StdOut.println(d[0] + " " + d[1] + " " +d[2]);
    	if(!P_new[0].equals(P_new[1]) && !P_new[0].equals(P_new[2]) && !P_new[1].equals(P_new[2]))
    	if(Math.abs(d[2]*d[2] - (d[0]*d[0] + d[1]*d[1])) < epsilon){
    		StdOut.println("ALMOST");
    		return;
    	}
    	
    	StdOut.println("NEITHER");
    }       
}

class Point{
	private int x;
	private int y;
	
	public Point(int a, int b){
		x = a;
		y = b;
	}
	
	public Point(Point p){
		this.x = p.getX();
		this.y = p.getY();
	}
	
	public int getX(){return x;}
	public int getY(){return y;}
	public void setX(int delta){
		x += delta;
	}
	public void setY(int delta){
		y += delta;
	}
	public double distance(Point that){
		int xDelta = this.getX() - that.getX();
		int yDelta = this.getY() - that.getY();
		return (double)Math.sqrt((xDelta*xDelta) + (yDelta*yDelta));
	}
	
	public String toString(){
		return "(" + x + "," + y + ")";
	}
	
	public boolean equals(Point that){
		return this.x == that.x && this.y == that.y;
	}
}


final class StdIn {
 
    private StdIn() { }
 
    private static Scanner scanner;
    
    private static final String CHARSET_NAME = "UTF-8";
 
    private static final Locale LOCALE = Locale.US;
 
    private static final Pattern WHITESPACE_PATTERN = Pattern.compile("\\p{javaWhitespace}+");
 
    private static final Pattern EMPTY_PATTERN = Pattern.compile("");
 
    private static final Pattern EVERYTHING_PATTERN = Pattern.compile("\\A");
 
    public static boolean isEmpty() {
        return !scanner.hasNext();
    }
 
    public static boolean hasNextLine() {
        return scanner.hasNextLine();
    }
 
    public static boolean hasNextChar() {
        scanner.useDelimiter(EMPTY_PATTERN);
        boolean result = scanner.hasNext();
        scanner.useDelimiter(WHITESPACE_PATTERN);
        return result;
    }
 
    public static String readLine() {
        String line;
        try                 { line = scanner.nextLine(); }
        catch (Exception e) { line = null;               }
        return line;
    }
 
    public static char readChar() {
        scanner.useDelimiter(EMPTY_PATTERN);
        String ch = scanner.next();
        assert (ch.length() == 1) : "Internal (Std)In.readChar() error!"
            + " Please contact the authors.";
        scanner.useDelimiter(WHITESPACE_PATTERN);
        return ch.charAt(0);
    }  
 
 
    public static String readAll() {
        if (!scanner.hasNextLine())
            return "";
 
        String result = scanner.useDelimiter(EVERYTHING_PATTERN).next();
        // not that important to reset delimeter, since now scanner is empty
        scanner.useDelimiter(WHITESPACE_PATTERN); // but let's do it anyway
        return result;
    }
 
    public static String readString() {
        return scanner.next();
    }
 
    public static int readInt() {
        return scanner.nextInt();
    }
 
    public static double readDouble() {
        return scanner.nextDouble();
    }
 
    public static float readFloat() {
        return scanner.nextFloat();
    }
 
    public static long readLong() {
        return scanner.nextLong();
    }
    
    public static short readShort() {
        return scanner.nextShort();
    }
 
    public static byte readByte() {
        return scanner.nextByte();
    }
 
    public static boolean readBoolean() {
        String s = readString();
        if (s.equalsIgnoreCase("true"))  return true;
        if (s.equalsIgnoreCase("false")) return false;
        if (s.equals("1"))               return true;
        if (s.equals("0"))               return false;
        throw new InputMismatchException();
    }
 
    public static String[] readAllStrings() {
        // we could use readAll.trim().split(), but that's not consistent
        // because trim() uses characters 0x00..0x20 as whitespace
        String[] tokens = WHITESPACE_PATTERN.split(readAll());
        if (tokens.length == 0 || tokens[0].length() > 0)
            return tokens;
 
        // don't include first token if it is leading whitespace
        String[] decapitokens = new String[tokens.length-1];
        for (int i = 0; i < tokens.length - 1; i++)
            decapitokens[i] = tokens[i+1];
        return decapitokens;
    }
 
    public static String[] readAllLines() {
        ArrayList<String> lines = new ArrayList<String>();
        while (hasNextLine()) {
            lines.add(readLine());
        }
        return lines.toArray(new String[0]);
    }
 
    public static int[] readAllInts() {
        String[] fields = readAllStrings();
        int[] vals = new int[fields.length];
        for (int i = 0; i < fields.length; i++)
            vals[i] = Integer.parseInt(fields[i]);
        return vals;
    }
 
    public static double[] readAllDoubles() {
        String[] fields = readAllStrings();
        double[] vals = new double[fields.length];
        for (int i = 0; i < fields.length; i++)
            vals[i] = Double.parseDouble(fields[i]);
        return vals;
    }
    
    static {
        resync();
    }
 
    private static void resync() {
        setScanner(new Scanner(new java.io.BufferedInputStream(System.in), CHARSET_NAME));
    }
    
    private static void setScanner(Scanner scanner) {
        StdIn.scanner = scanner;
        StdIn.scanner.useLocale(LOCALE);
    }
 
    public static int[] readInts() {
        return readAllInts();
    }
 
    public static double[] readDoubles() {
        return readAllDoubles();
    }
 
    public static String[] readStrings() {
        return readAllStrings();
    }
 
}
 
final class StdOut {
 
    private static final String CHARSET_NAME = "UTF-8";
 
    private static final Locale LOCALE = Locale.US;
 
    private static PrintWriter out;
 
    static {
        try {
            out = new PrintWriter(new OutputStreamWriter(System.out, CHARSET_NAME), true);
        }
        catch (UnsupportedEncodingException e) { System.out.println(e); }
    }
 
    private StdOut() { }
 
    public static void close() {
        out.close();
    }
 
    public static void println() {
        out.println();
    }
 
    public static void println(Object x) {
        out.println(x);
    }
 
    public static void println(boolean x) {
        out.println(x);
    }
 
    public static void println(char x) {
        out.println(x);
    }
 
    public static void println(double x) {
        out.println(x);
    }
 
    public static void println(float x) {
        out.println(x);
    }
 
    public static void println(int x) {
        out.println(x);
    }
 
    public static void println(long x) {
        out.println(x);
    }
 
    public static void println(short x) {
        out.println(x);
    }
 
    public static void println(byte x) {
        out.println(x);
    }
 
    public static void print() {
        out.flush();
    }
 
    public static void print(Object x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(boolean x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(char x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(double x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(float x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(int x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(long x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(short x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(byte x) {
        out.print(x);
        out.flush();
    }
 
    public static void printf(String format, Object... args) {
        out.printf(LOCALE, format, args);
        out.flush();
    }
 
    public static void printf(Locale locale, String format, Object... args) {
        out.printf(locale, format, args);
        out.flush();
    }
 
} 