opQ 3, C# - rextester

Language: Layout:

//Rextester.Program.Main is the entry point for your code. Don't change it.
//Compiler version 4.0.30319.17929 for Microsoft (R) .NET Framework 4.5

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
            //Your code goes here
            Random Rand = new Random();
            string[] op = new string[] {"+", "-", "*", "/"};
            
            List<string> opQ = new List<string>();
            
           
            int result;
            
            for (int j = 0; j < 120; j++) {
                
            int[] n = new int[5];
                for (int i = 0; i<n.Length; i++) {
                    n[i] = Rand.Next(1,90);
                }
            
            int a = Rand.Next(0,4);
            int b = Rand.Next(0,4);
            int c = Rand.Next(0,4);
            int d = Rand.Next(0,4);
            // 1st switch
            switch(op[a]) {                
                case "+":
				// 2nd switch +
				switch(op[b]) {
					case "+":
						// 3rd switch ++
						switch(op[c]) {
							case "+":
								// 4th switch +++
								switch(op[d]) {
									case "+":
										result = n[0] + n[1] + n[2] + n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
										result = n[0] + n[1] + n[2] + n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" + "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
										result = n[0] + n[1] + n[2] + n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" + "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
										double resultD = n[0] + n[1] + n[2] + ((double)n[3] /(double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break +++
							case "-": 
								// 4th switch ++-
								switch(op[d]) {
									case "+":
										result = n[0] + n[1] + n[2] - n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" - "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] + n[1] + n[2] - n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" - "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
										result = n[0] + n[1] + n[2] - n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" - "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] + n[1] + n[2] - ((double) n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break ++-
							case "*":
								// 4th switch ++*
								switch(op[d]) {
									case "+":
										result = n[0] + n[1] + n[2] * n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" * "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] + n[1] + n[2] * n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" * "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] + n[1] + n[2] * n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" * "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] + n[1] + ((double) n[2] * n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break ++*
							case "/":
								// 4th switch ++/
								switch(op[d]) {
									case "+":
									double resultD = n[0] + n[1] + ((double)n[2] /(double)n[3]) + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] + n[1] + ((double)n[2] /(double)n[3]) - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] + n[1] + ((double)n[2] /(double)n[3]) * n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] + n[1] + ((double) n[2] / (double)n[3] /(double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break ++/
						}
					break; // 2nd switch break ++
					case "-":
						//3rd switch +-
						switch(op[c]) {
							case "+":
								// 4th switch +-+
								switch(op[d]) {
									case "+":
									result = n[0] + n[1] - n[2] + n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] + n[1] - n[2] + n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" + "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] + n[1] - n[2] + n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" + "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] + n[1] - n[2] + ((double)n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break +-+
							case "-": 
								// 4th switch +--
								switch(op[d]) {
									case "+":
									result = n[0] + n[1] - n[2] - n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" - "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] + n[1] - n[2] - n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" - "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] + n[1] - n[2] - n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" - "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] + n[1] - n[2] - ((double)n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break +--
							case "*":
								// 4th switch +-*
								switch(op[d]) {
									case "+":
									result = n[0] + n[1] - n[2] * n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" * "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] + n[1] - n[2] * n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" * "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] + n[1] - n[2] * n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" * "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] + n[1] - ((double) (n[2] * n[3]) / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break +-*
							case "/":
								// 4th switch +-/
								switch(op[d]) {
									case "+":
									double resultD = n[0] + n[1] - ( (double)n[2] / (double)n[3]) + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] + n[1] - ((double) n[2] /(double) n[3]) - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] + n[1] - ((double) n[2] /(double) n[3] * n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] + n[1] -  ((double)n[2] / (double)n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break +-/
						}
					break; // 2nd switch break +-
					case "*":
						//3rd switch +*
						switch(op[c]) {
							case "+":
								// 4th switch +*+
								switch(op[d]) {
									case "+":
									result = n[0] + n[1] * n[2] + n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] + n[1] * n[2] + n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" + "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] + n[1] * n[2] + n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" + "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] + n[1] * n[2] + ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break +*+
							case "-": 
								// 4th switch +*-
								switch(op[d]) {
									case "+":
									result = n[0] + n[1] * n[2] - n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" - "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] + n[1] * n[2] - n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" - "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] + n[1] * n[2] - n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" - "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] + n[1] * n[2] - ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break +*-
							case "*":
								// 4th switch +**
								switch(op[d]) {
									case "+":
									result = n[0] + n[1] * n[2] * n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" * "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] + n[1] * n[2] * n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" * "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] + n[1] * n[2] * n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" * "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] + ((double) n[1] * n[2] * n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break +**
							case "/":
								// 4th switch +*/
								switch(op[d]) {
									case "+":
									double resultD = n[0] + ((double) n[1] * n[2] / (double) n[3]) + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] + ((double) n[1] * n[2] / (double) n[3]) - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] + ((double) (n[1] * n[2]) / (double) (n[3] * n[4]));
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] + ((double) (n[1] * n[2]) / (double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break +*/
						}
					break; // 2nd switch break +*
					case "/":
						//3rd switch +/
						switch(op[c]) {
							case "+":
								// 4th switch +/+
								switch(op[d]) {
									case "+":
									double resultD = n[0] + ((double) n[1] / (double) n[2]) + n[3] + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" + "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] + ((double) n[1] / (double) n[2]) + n[3] - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" + "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] + ((double) n[1] / (double) n[2]) + n[3] * n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" + "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] + ((double) n[1] / (double) n[2]) + ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break +/+
							case "-": 
								// 4th switch +/-
								switch(op[d]) {
									case "+":
									double resultD = n[0] + ((double) n[1] / (double) n[2]) - n[3] + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" - "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] + ((double) n[1] / (double) n[2]) - n[3] - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" - "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] + ((double) n[1] / (double) n[2]) - n[3] * n[4];
										if (resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" - "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] + ((double) n[1] / (double) n[2]) - ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break +/-
							case "*":
								// 4th switch +/*
								switch(op[d]) {
									case "+":
									double resultD = n[0] + ((double) n[1] / (double) n[2] * n[3]) + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" * "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] + ((double) n[1] / (double) n[2] * n[3]) - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" * "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] + ((double) n[1] / (double) n[2] * n[3] * n[4]);
										if (resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" * "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] + ((double) n[1] / (double) n[2] * (double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break +/*
							case "/":
								// 4th switch +//
								switch(op[d]) {
									case "+":
									double resultD = n[0] + ((double) n[1] / (double) n[2] / (double) n[3]) + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] + ((double) n[1] / (double) n[2] / (double) n[3]) - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] + ((double) n[1] / (double) n[2] / (double) n[3] * n[4]);
										if (resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] + ((double) n[1] / (double) n[2] / (double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break +//
						}
					break; // 2nd switch break +/
				}
                break; // 1st switch break +
                case "-":
				// 2nd switch -
				switch(op[b]) {
					case "+":
						// 3rd switch -+
						switch(op[c]) {
							case "+":
								// 4th switch -++
								switch(op[d]) {
									case "+":
										result = n[0] - n[1] + n[2] + n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
										result = n[0] - n[1] + n[2] + n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" + "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
										result = n[0] - n[1] + n[2] + n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" + "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
										double resultD = n[0] - n[1] + n[2] + ((double)n[3] /(double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break -++
							case "-": 
								// 4th switch -+-
								switch(op[d]) {
									case "+":
										result = n[0] - n[1] + n[2] - n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" - "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] - n[1] + n[2] - n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" - "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
										result = n[0] - n[1] + n[2] - n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" - "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] - n[1] + n[2] - ((double) n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break -+-
							case "*":
								// 4th switch -+*
								switch(op[d]) {
									case "+":
										result = n[0] - n[1] + n[2] * n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" * "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] - n[1] + n[2] * n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" * "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] - n[1] + n[2] * n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" * "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] - n[1] + ((double) n[2] * n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break -+*
							case "/":
								// 4th switch -+/
								switch(op[d]) {
									case "+":
									double resultD = n[0] - n[1] + ((double)n[2] /(double)n[3]) + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] - n[1] + ((double)n[2] /(double)n[3]) - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] - n[1] + ((double)n[2] /(double)n[3]) * n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] - n[1] + ((double) n[2] / (double)n[3] /(double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" + "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break -+/
						}
					break; // 2nd switch break -+
					case "-":
						//3rd switch --
						switch(op[c]) {
							case "+":
								// 4th switch --+
								switch(op[d]) {
									case "+":
									result = n[0] - n[1] - n[2] + n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] - n[1] - n[2] + n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" + "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] - n[1] - n[2] + n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" + "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] - n[1] - n[2] + ((double)n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break --+
							case "-": 
								// 4th switch ---
								switch(op[d]) {
									case "+":
									result = n[0] - n[1] - n[2] - n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" - "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] - n[1] - n[2] - n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" - "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] - n[1] - n[2] - n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" - "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] - n[1] - n[2] - ((double)n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break ---
							case "*":
								// 4th switch --*
								switch(op[d]) {
									case "+":
									result = n[0] - n[1] - n[2] * n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" * "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] - n[1] - n[2] * n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" * "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] - n[1] - n[2] * n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" * "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] - n[1] - ((double) (n[2] * n[3]) / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break --*
							case "/":
								// 4th switch --/
								switch(op[d]) {
									case "+":
									double resultD = n[0] - n[1] - ( (double)n[2] / (double)n[3]) + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] - n[1] - ((double) n[2] /(double) n[3]) - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] - n[1] - ((double) n[2] /(double) n[3] * n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] - n[1] -  ((double)n[2] / (double)n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" - "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break --/
						}
					break; // 2nd switch break --
					case "*":
						//3rd switch -*
						switch(op[c]) {
							case "+":
								// 4th switch -*+
								switch(op[d]) {
									case "+":
									result = n[0] - n[1] * n[2] + n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] - n[1] * n[2] + n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" + "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] - n[1] * n[2] + n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" + "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] - n[1] * n[2] + ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break -*+
							case "-": 
								// 4th switch -*-
								switch(op[d]) {
									case "+":
									result = n[0] - n[1] * n[2] - n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" - "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] - n[1] * n[2] - n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" - "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] - n[1] * n[2] - n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" - "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] - n[1] * n[2] - ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break -*-
							case "*":
								// 4th switch -**
								switch(op[d]) {
									case "+":
									result = n[0] - n[1] * n[2] * n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" * "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] - n[1] * n[2] * n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" * "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] - n[1] * n[2] * n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" * "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] - ((double) n[1] * n[2] * n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break -**
							case "/":
								// 4th switch -*/
								switch(op[d]) {
									case "+":
									double resultD = n[0] - ((double) n[1] * n[2] / (double) n[3]) + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] - ((double) n[1] * n[2] / (double) n[3]) - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] - ((double) (n[1] * n[2]) / (double) (n[3] * n[4]));
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] - ((double) (n[1] * n[2]) / (double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" * "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break -*/
						}
					break; // 2nd switch break -*
					case "/":
						//3rd switch -/
						switch(op[c]) {
							case "+":
								// 4th switch -/+
								switch(op[d]) {
									case "+":
									double resultD = n[0] - ((double) n[1] / (double) n[2]) + n[3] + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" + "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] - ((double) n[1] / (double) n[2]) + n[3] - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" + "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] - ((double) n[1] / (double) n[2]) + n[3] * n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" + "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] - ((double) n[1] / (double) n[2]) + ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break -/+
							case "-": 
								// 4th switch -/-
								switch(op[d]) {
									case "+":
									double resultD = n[0] - ((double) n[1] / (double) n[2]) - n[3] + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" - "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] - ((double) n[1] / (double) n[2]) - n[3] - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" - "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] - ((double) n[1] / (double) n[2]) - n[3] * n[4];
										if (resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" - "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] - ((double) n[1] / (double) n[2]) - ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break -/-
							case "*":
								// 4th switch -/*
								switch(op[d]) {
									case "+":
									double resultD = n[0] - ((double) n[1] / (double) n[2] * n[3]) + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" * "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] - ((double) n[1] / (double) n[2] * n[3]) - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" * "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] - ((double) n[1] / (double) n[2] * n[3] * n[4]);
										if (resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" * "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] - ((double) n[1] / (double) n[2] * (double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break -/*
							case "/":
								// 4th switch -//
								switch(op[d]) {
									case "+":
									double resultD = n[0] - ((double) n[1] / (double) n[2] / (double) n[3]) + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] - ((double) n[1] / (double) n[2] / (double) n[3]) - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] - ((double) n[1] / (double) n[2] / (double) n[3] * n[4]);
										if (resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] - ((double) n[1] / (double) n[2] / (double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" - "+n[1]+" / "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break -//
						}
					break; // 2nd switch break -/
				}
                break; // first switch break -
                case "*":
				// 2nd switch *
				switch(op[b]) {
					case "+":
						// 3rd switch *+
						switch(op[c]) {
							case "+":
								// 4th switch *++
								switch(op[d]) {
									case "+":
										result = n[0] * n[1] + n[2] + n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
										result = n[0] * n[1] + n[2] + n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" + "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
										result = n[0] * n[1] + n[2] + n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" + "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
										double resultD = n[0] * n[1] + n[2] + ((double)n[3] /(double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break *++
							case "-": 
								// 4th switch *+-
								switch(op[d]) {
									case "+":
										result = n[0] * n[1] + n[2] - n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" - "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] * n[1] + n[2] - n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" - "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
										result = n[0] * n[1] + n[2] - n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" - "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] * n[1] + n[2] - ((double) n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break *+-
							case "*":
								// 4th switch *+*
								switch(op[d]) {
									case "+":
										result = n[0] * n[1] + n[2] * n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" * "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] * n[1] + n[2] * n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" * "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] * n[1] + n[2] * n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" * "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] * n[1] + ((double) n[2] * n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break *+*
							case "/":
								// 4th switch *+/
								switch(op[d]) {
									case "+":
									double resultD = n[0] * n[1] + ((double)n[2] /(double)n[3]) + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] * n[1] + ((double)n[2] /(double)n[3]) - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] * n[1] + ((double)n[2] /(double)n[3]) * n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] * n[1] + ((double) n[2] / (double)n[3] /(double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" + "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break *+/
						}
					break; // 2nd switch break *+
					case "-":
						//3rd switch *-
						switch(op[c]) {
							case "+":
								// 4th switch *-+
								switch(op[d]) {
									case "+":
									result = n[0] * n[1] - n[2] + n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] * n[1] - n[2] + n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" + "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] * n[1] - n[2] + n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" + "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] * n[1] - n[2] + ((double)n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break *-+
							case "-": 
								// 4th switch *--
								switch(op[d]) {
									case "+":
									result = n[0] * n[1] - n[2] - n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" - "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] * n[1] - n[2] - n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" - "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] * n[1] - n[2] - n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" - "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] * n[1] - n[2] - ((double)n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break *--
							case "*":
								// 4th switch *-*
								switch(op[d]) {
									case "+":
									result = n[0] * n[1] - n[2] * n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" * "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] * n[1] - n[2] * n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" * "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] * n[1] - n[2] * n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" * "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] * n[1] - ((double) (n[2] * n[3]) / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break *-*
							case "/":
								// 4th switch *-/
								switch(op[d]) {
									case "+":
									double resultD = n[0] * n[1] - ( (double)n[2] / (double)n[3]) + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = n[0] * n[1] - ((double) n[2] /(double) n[3]) - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = n[0] * n[1] - ((double) n[2] /(double) n[3] * n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = n[0] * n[1] -  ((double)n[2] / (double)n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" - "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break *-/
						}
					break; // 2nd switch break *-
					case "*":
						//3rd switch **
						switch(op[c]) {
							case "+":
								// 4th switch **+
								switch(op[d]) {
									case "+":
									result = n[0] * n[1] * n[2] + n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] * n[1] * n[2] + n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" + "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] * n[1] * n[2] + n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" + "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] * n[1] * n[2] + ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break **+
							case "-": 
								// 4th switch **-
								switch(op[d]) {
									case "+":
									result = n[0] * n[1] * n[2] - n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" - "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] * n[1] * n[2] - n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" - "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] * n[1] * n[2] - n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" - "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = n[0] * n[1] * n[2] - ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break **-
							case "*":
								// 4th switch ***
								switch(op[d]) {
									case "+":
									result = n[0] * n[1] * n[2] * n[3] + n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" * "+n[3]+" + "+n[4]+" = "+result);
									break;
									case "-":
									result = n[0] * n[1] * n[2] * n[3] - n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" * "+n[3]+" - "+n[4]+" = "+result);
									break;
									case "*":
									result = n[0] * n[1] * n[2] * n[3] * n[4];
										if (result<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" * "+n[3]+" * "+n[4]+" = "+result);
									break;
									case "/":
									double resultD = ((double) (n[0] * n[1] * n[2] * n[3]) / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break ***
							case "/":
								// 4th switch **/
								switch(op[d]) {
									case "+":
									double resultD = ((double) (n[0] * n[1] * n[2]) / (double) n[3]) + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) (n[0] * n[1] * n[2]) / (double) n[3]) - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) (n[0] * n[1] * n[2]) / (double) (n[3] * n[4]));
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) (n[0] * n[1] * n[2]) / (double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" * "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break **/
						}
					break; // 2nd switch break **
					case "/":
						//3rd switch */
						switch(op[c]) {
							case "+":
								// 4th switch */+
								switch(op[d]) {
									case "+":
									double resultD = ((double) (n[0] * n[1]) / (double) n[2]) + n[3] + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" + "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) (n[0] * n[1]) / (double) n[2]) + n[3] - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" + "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) (n[0] * n[1]) / (double) n[2]) + n[3] * n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" + "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) (n[0] * n[1]) / (double) n[2]) + ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break */+
							case "-": 
								// 4th switch */-
								switch(op[d]) {
									case "+":
									double resultD = ((double) (n[0] * n[1]) / (double) n[2]) - n[3] + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" - "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) (n[0] * n[1]) / (double) n[2]) - n[3] - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" - "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) (n[0] * n[1]) / (double) n[2]) - n[3] * n[4];
										if (resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" - "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD =  ((double) (n[0] * n[1]) / (double) n[2]) - ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break */-
							case "*":
								// 4th switch */*
								switch(op[d]) {
									case "+":
									double resultD = ((double) (n[0] * n[1]) / (double) n[2] * n[3]) + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" * "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) (n[0] * n[1]) / (double) n[2] * n[3]) - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" * "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) (n[0] * n[1]) / (double) n[2] * n[3] * n[4]);
										if (resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" * "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) (n[0] * n[1]) / (double) n[2] * (double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break */*
							case "/":
								// 4th switch *//
								switch(op[d]) {
									case "+":
									double resultD = ((double) (n[0] * n[1]) / (double) n[2] / (double) n[3]) + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) (n[0] * n[1]) / (double) n[2] / (double) n[3]) - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) (n[0] * n[1]) / (double) n[2] / (double) n[3] * n[4]);
										if (resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) (n[0] * n[1]) / (double) n[2] / (double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" * "+n[1]+" / "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break *//
						}
					break; // 2nd switch break */
				}
                break; // 1st switch break *
                
                case "/":
				// 2nd switch /
				switch(op[b]) {
					case "+":
						// 3rd switch /+
						switch(op[c]) {
							case "+":
								// 4th switch /++
								switch(op[d]) {
									case "+":
										double resultD = ((double) n[0] / (double) n[1]) + n[2] + n[3] + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" + "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
										resultD = ((double) n[0] / (double) n[1]) + n[2] + n[3] - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" + "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
										resultD = ((double) n[0] / (double) n[1]) + n[2] + n[3] * n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" + "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
										resultD = ((double) n[0] / (double) n[1]) + n[2] + ((double)n[3] /(double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break /++
							case "-": 
								// 4th switch /+-
								switch(op[d]) {
									case "+":
										double resultD = ((double) n[0] / (double) n[1]) + n[2] - n[3] + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" - "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) n[0] / (double) n[1]) + n[2] - n[3] - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" - "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
										resultD = ((double) n[0] / (double) n[1]) + n[2] - n[3] * n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" - "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
                                        resultD = ((double) n[0] / (double) n[1]) + n[2] - ((double) n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break /+-
							case "*":
								// 4th switch /+*
								switch(op[d]) {
									case "+":
										double resultD = ((double) n[0] / (double) n[1]) + n[2] * n[3] + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" * "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
                                        resultD = ((double) n[0] / (double) n[1]) + n[2] * n[3] - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" * "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
                                        resultD = ((double) n[0] / (double) n[1]) + n[2] * n[3] * n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" * "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
                                        resultD = ((double) n[0] / (double) n[1]) + ((double) n[2] * n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break /+*
							case "/":
								// 4th switch /+/
								switch(op[d]) {
									case "+":
									double resultD = ((double) n[0] / (double) n[1]) + ((double)n[2] /(double)n[3]) + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) n[0] / (double) n[1]) + ((double)n[2] /(double)n[3]) - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) n[0] / (double) n[1]) + ((double)n[2] /(double)n[3]) * n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) n[0] / (double) n[1]) + ((double) n[2] / (double)n[3] /(double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" + "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break /+/
						}
					break; // 2nd switch break /+
					case "-":
						//3rd switch /-
						switch(op[c]) {
							case "+":
								// 4th switch /-+
								switch(op[d]) {
									case "+":
									double resultD = ((double) n[0] / (double) n[1]) - n[2] + n[3] + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" + "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) n[0] / (double) n[1]) - n[2] + n[3] - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" + "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) n[0] / (double) n[1]) - n[2] + n[3] * n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" + "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) n[0] / (double) n[1]) - n[2] + ((double)n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break /-+
							case "-": 
								// 4th switch /--
								switch(op[d]) {
									case "+":
									double resultD = ((double) n[0] / (double) n[1]) - n[2] - n[3] + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" - "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) n[0] / (double) n[1]) - n[2] - n[3] - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" - "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) n[0] / (double) n[1]) - n[2] - n[3] * n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" - "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) n[0] / (double) n[1]) - n[2] - ((double)n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break /--
							case "*":
								// 4th switch /-*
								switch(op[d]) {
									case "+":
									double resultD = ((double) n[0] / (double) n[1]) - n[2] * n[3] + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" * "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) n[0] / (double) n[1]) - n[2] * n[3] - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" * "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) n[0] / (double) n[1]) - n[2] * n[3] * n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" * "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) n[0] / (double) n[1]) - ((double) (n[2] * n[3]) / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break /-*
							case "/":
								// 4th switch /-/
								switch(op[d]) {
									case "+":
									double resultD = ((double) n[0] / (double) n[1]) - ( (double)n[2] / (double)n[3]) + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) n[0] / (double) n[1]) - ((double) n[2] /(double) n[3]) - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) n[0] / (double) n[1]) - ((double) n[2] /(double) n[3] * n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) n[0] / (double) n[1]) -  ((double)n[2] / (double)n[3] / (double)n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" - "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break /-/
						}
					break; // 2nd switch break /-
					case "*":
						//3rd switch /*
						switch(op[c]) {
							case "+":
								// 4th switch /*+
								switch(op[d]) {
									case "+":
									double resultD = ((double) n[0] / (double) n[1] * n[2]) + n[3] + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" + "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) n[0] / (double) n[1] * n[2]) + n[3] - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" + "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) n[0] / (double) n[1] * n[2]) + n[3] * n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" + "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) n[0] / (double) n[1] * n[2]) + ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break /*+
							case "-": 
								// 4th switch /*-
								switch(op[d]) {
									case "+":
									double resultD = ((double) n[0] / (double) n[1] * n[2]) - n[3] + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" - "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) n[0] / (double) n[1] * n[2]) - n[3] - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" - "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) n[0] / (double) n[1] * n[2]) - n[3] * n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" - "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) n[0] / (double) n[1] * n[2]) - ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break /*-
							case "*":
								// 4th switch /**
								switch(op[d]) {
									case "+":
									double resultD = ((double) n[0] / (double) n[1]) * n[2] * n[3] + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" * "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) n[0] / (double) n[1]) * n[2] * n[3] - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" * "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) n[0] / (double) n[1]) * n[2] * n[3] * n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" * "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = (((double) n[0] / (double) n[1]) * n[2] * n[3]) / (double) n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break /**
							case "/":
								// 4th switch /*/
								switch(op[d]) {
									case "+":
									double resultD = (((double) n[0] / (double) n[1] * n[2]) / (double) n[3]) + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) n[0] / (double) n[1] * n[2] / (double) n[3]) - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) n[0] / (double) n[1] * n[2] / (double) (n[3] * n[4]));
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) n[0] / (double) n[1] * n[2] / (double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" * "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break /*/
						}
					break; // 2nd switch break /*
					case "/":
						//3rd switch //
						switch(op[c]) {
							case "+":
								// 4th switch //+
								switch(op[d]) {
									case "+":
									double resultD = ((double) n[0] / (double) n[1] / (double) n[2]) + n[3] + n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" + "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) n[0] / (double) n[1] / (double) n[2]) + n[3] - n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" + "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) n[0] / (double) n[1] / (double) n[2]) + n[3] * n[4];
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" + "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) n[0] / (double) n[1] / (double) n[2]) + ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break //+
							case "-": 
								// 4th switch //-
								switch(op[d]) {
									case "+":
									double resultD = ((double) n[0] / (double) n[1] / (double) n[2]) - n[3] + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" - "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) n[0] / (double) n[1] / (double) n[2]) - n[3] - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" - "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) n[0] / (double) n[1] / (double) n[2]) - n[3] * n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" - "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD =  ((double) n[0] / (double) n[1] / (double) n[2]) - ((double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break //-
							case "*":
								// 4th switch //*
								switch(op[d]) {
									case "+":
									double resultD = ((double) n[0] / (double) n[1] / (double) n[2] * n[3]) + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" * "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) n[0] / (double) n[1] / (double) n[2] * n[3]) - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" * "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) n[0] / (double) n[1] / (double) n[2] * n[3] * n[4]);
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" * "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) n[0] / (double) n[1] / (double) n[2] * (double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break //*
							case "/":
								// 4th switch ///
								switch(op[d]) {
									case "+":
									double resultD = ((double) n[0] / (double) n[1] / (double) n[2] / (double) n[3]) + n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
									break;
									case "-":
									resultD = ((double) n[0] / (double) n[1] / (double) n[2] / (double) n[3]) - n[4];
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
									break;
									case "*":
									resultD = ((double) n[0] / (double) n[1] / (double) n[2] / (double) n[3] * n[4]);
										if (resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
									break;
									case "/":
									resultD = ((double) n[0] / (double) n[1] / (double) n[2] / (double) n[3] / (double) n[4]);
										if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" / "+n[1]+" / "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
									break;
								}
							break; // 3rd switch break ///
						}
					break; // 2nd switch break //
				}
                break; // 1st switch break /
                
            }
        }
        }
    }
}

Show compiler warnings [ + ] Show input
Compilation time: 0,25 sec, absolute running time: 0,19 sec, cpu time: 0,17 sec, average memory usage: 25 Mb, average nr of threads: 4