static double UniqueFract()
{
    double result = 0;
    for (int i = 2; i < 10; i++)
    {
        for (int j = 1; j < i; j++)
        {
            if (i % 2 == 0 && j% 2 == 0 || i % 3 == 0 && j % 3 == 0)
            {
                continue;
            }
            else
            {
                result += (double)j / (double)i;
            }
        }
    }
    return result;
}

 static double UniqueFract() {
    double sum=0;
    for (int ch=1; ch<=9; ch++){
        for (int zn=1; zn<=9; zn++){
            if (ch< zn){
                int nsd=1;
                for (int i=1; i<=ch; i++){
                    if (ch%i==0 && zn%i==0){
                        nsd=i;
                    }
                }
            if (nsd==1){
                double drib=(double)ch/zn;
                sum+=drib;
            }
            }
        }
    }
    return sum;
}

 static double UniqueFract() 
{
    return 13.5;
}

 static double UniqueFract() {
 double[] arr = new double[30];
            double sum = 0, tmp = 0;
            for (int i = 1, k = 0; i < 9; i++)
                for (double j = i+1; j < 10; j++)
                {
                    tmp = i / j;
                    if(!arr.Contains(tmp)) 
                    { 
                        arr[k] = tmp; 
                        k++; 
                    }
                }
            for (int i = 0; i < arr.Length; i++)
                sum += arr[i];
            return sum;
        }

 public static double UniqueFract()
{
    double sum = 0;
    int count = 0;

    for (int denom = 2; denom <= 9; denom++)
    {
        for (int num = 1; num < denom; num++)
        {
            if (GCD(num, denom) == 1)
            {
                count++;
                sum += (double)num / denom;
            }
        }
    }

    return sum;
}

private static int GCD(int a, int b)
{
    if (b == 0)
    {
        return a;
    }
    else
    {
        return GCD(b, a % b);
    }
}

 static double UniqueFract() {
  bool flag = true;
            double sum = 0;
            for (double i = 1; i <= 9; i++)
            {
                for (double j = 1; j < i; j++)
                {
                    flag = true;
                    for (int k = 2; k <= j; k++)
                    {
                        if (i % k == 0 && j % k == 0)
                        {
                            flag = false;
                            break;
                        }
                    }
                    if (flag) sum += j / i;
                }
            }
            return sum;
}

 static double UniqueFract(){
    double sum = 0;
    for (int i = 1; i < 9; i++)
    {
        for (int j = i + 1; j < 10; j++)
        {
            bool k = false;
            for (int l = 2; l < 5; l++)
            {
                if (i % l == 0 && j % l == 0)
                {
                    k = true;
                    break;
                }
            }
            if (!k) sum += (double)i / j;
        }
    }
    return sum;
}

 static double UniqueFract()
{
    double res = 0;
    for (double i = 2; i < 10; i++)
    {
        for (double j = 1; j < i; j++)
        {
            if (i % j == 0 && j != 1 || i % 2 == 0 && j % 2 == 0 || i % 3 == 0 && j % 3 == 0) { continue; }
            else
            {
                res += j / i;
            }
        }
    }
    return res;
}

 public static double UniqueFract()
{
    double sum = 0;
    
    for (int numerator = 1; numerator <= 9; numerator++)
    {
        for (int denominator = numerator + 1; denominator <= 9; denominator++)
        {
            if (GCD(numerator, denominator) == 1)
            {
                sum += (double)numerator / denominator;
            }
        }
    }
    
    return sum;
}

private static int GCD(int a, int b)
{
    if (b == 0)
    {
        return a;
    }
    else
    {
        return GCD(b, a % b);
    }
}

 static double UniqueFract()
    {
        double sum = 0;
        for (short i = 1; i < 9; i++)
        {
            for (short j = (short)(i + 1); j < 10; j++)
            {
                if ((i % 2 != 0 || j % 2 != 0) && (i % 3 != 0 || j % 3 != 0))
                {
                    sum += (double)(i) / (double)(j);
                }
            }
        }
        
        return sum;
    }

 static double UniqueFract() {
    double sum = 0;
    for(double i = 1; i <= 8;i++)
    {
        for(double j = i+1; j <= 9;j++)
        {
            if(i == 1)
            {
                sum += i/j;
            }
            else if(i % 2 == 0 && j % 2 == 0)
            {
            }
            else if(i % 3 == 0 && j % 3 == 0)
            {
            }
            else
            {
                sum += i/j;
            }
        }
    }
    return sum;
}

 static double UniqueFract() 
{
    double n = 0;
    for(double i = 1; i < 9; i++)
        for(double j = 2; j < 10; j++){
            if(i != j && i < j)
                if(i % 2 == 0 && j % 2 == 0 || i % 3 == 0 && j % 3 == 0)
                    n += 0;
                else n += i / j;
        }
        return n;
}

 static double UniqueFract()
        {
            double znam = 1;
            double chis = 2;
            
            //double sbl = 8;
            double sum = 0;
            for (double i = 8; i <= 8 && i != 0; i--, chis++)
            {
                //if ((znam % 2 != 0 || chis % 2 != 0) && (znam / chis != 6 / 9)  && (znam / chis != 3 / 9))
                if((((chis/znam)%1!=0) || chis / znam== chis) &&  (znam % 2 != 0 || chis % 2 != 0) )
                {
                    //if (znam / chis != (6/9)) {
                     //   Console.WriteLine(znam + " / " + chis);
                       // sum = sum + znam / chis;
                    //}
                    Console.WriteLine(znam + " / "+ chis);
                    sum = sum + znam / chis;
                }
                if (i == 1)
                {
                    i = chis - znam;
                    //sbl--;
                    znam++;
                    chis = znam;
                }
                
            }

            //Console.WriteLine(sum + "," + s);
            //Console.WriteLine();
            sum = sum - 6.0 / 9.0;
            return sum ;
        }

 static double UniqueFract() {
double a=0;
for(int i=1;i< 9;i++)
{
    for(double j=i+1;j< 10;j++){
        if((i%2==0 && j%2==0) || (i%3==0 && j%3==0) || (i%5==0 && j%5==0) || (i%7==0 && j%7==0))
        continue;
        else
        a+=i/j;
    }
}
return a;
}

 static double UniqueFract() {
double sum = 0.00;

for(double i = 1;i <= 8;i++){
    for(double j = 1;j <= 9;j++){
    if(i % 2 == 0 && j % 2 == 0||i % 3 == 0 && j % 3 == 0){
            continue;
        }
        if (i < j) {
            sum = sum + (i / j);
        }
    }
}
return sum;
}

 static double UniqueFract() {
double sum = 0;
for(short i=1; i< 9; i++){
    for(short j = (short)(i+1); j< 10; j++){
        if((i%2 !=0 || j%2 != 0) && (i%3 != 0 || j%3 != 0)){
            sum += (double)(i)/(double)(j);
        }
    }
    }
    return sum;
}

 static double UniqueFract(){
                double sum = 0;
                double i2;
                double j2;
                for (double i = 1; i < 10; i++)
                {
                    for (double j = i + 1; j < 10; j++)
                    {
                        i2 = i;
                        j2 = j;
                        for(; ; )
                        {
                            if(i2<=1||j2<=1)
                            {
                                break;
                            }
                            else if(j2<=i2)
                            {
                                i2 -= j2;
                            }
                            else
                            {
                                j2 -= i2;
                            }
                        }
                        if(i2==1||j2==1)
                        {
                            sum += i / j;
                        }
                    }
                }
                return sum;
            }

 static double UniqueFract()
        {
            double sum = 0;
            int denominator = 2;
            while (denominator < 10)
            {
                int numerator = 1;
                while (numerator < denominator)
                {
                    int divisor = GCD(numerator, denominator);
                    if (divisor == 1)
                    {
                        sum += ((double)numerator / (double)denominator);
                    }
                    numerator++;
                }
                denominator++;
            }
            return sum;
        }

        static int GCD(int x, int y)
        {
            if (y == 0) return x;

            return GCD(y, x % y);
        }

 static double UniqueFract()
{
    double sum = 0;

    for (int i = 1; i < 9; i++)
    {
        for (int j = i + 1; j <= 9; j++)
        {
            if ((i % 2 == 0 && j % 2 == 0) || (i % 3 == 0 && j % 3 == 0))
            {
                continue;
            }
            else
            {
                sum += (double)i / (double)j;
            }

        }
    }
    return sum;
}

 static double UniqueFract() {
    double sum = 0;
    for (int i = 1; i <= 9; i++) 
        for (int j = i + 1; j <= 9; j++)
            if (gcd(i, j) == 1) 
                if (Math.Floor(Math.Log10(i)) == 0 && Math.Floor(Math.Log10(j)) == 0) 
                    sum += (double)i / j;
    return sum;
}
static int gcd(int a, int b) {
    while (b != 0) {
        int r = a % b;
        a = b;
        b = r;
    }
    return a;
}

 static int GCD(int a, int b)
{
    while (b != 0)
    {
        int r = a % b;
        a = b;
        b = r;
    }
    return a;
}

static double UniqueFract()
{
    double sum = 0;
    for (int i = 1; i < 10; i++)
    {
        for (int j = i + 1; j < 10; j++)
        {
            if (GCD(i, j) == 1)
            {
                sum += (double)i / j;
            }
        }
    }
    return sum;
}

 static double UniqueFract()
{
double sum = 0;
for (double a = 2; a < 10; a++)
{
    for (double b = 1; b < a; b++)
        {
            if ((b % 2 != 0 || a % 2 != 0) && (b % 3 != 0 || a % 3 != 0))
               {
                  sum = sum + (b / a);
                }
    }   
}
 return sum;  
}

 static double UniqueFract() { double sum = 0;

    for (int denom = 2; denom <= 9; denom++)
    {
        for (int numer = 1; numer < denom; numer++)
        {
          
            if (numer < 10 && denom < 10)
            {
               
                if (GCD(numer, denom) == 1)
                {
                    sum += (double)numer / denom;
                }
            }
        }
    }

    return sum;
}

static int GCD(int a, int b)
{
    if (b == 0)
    {
        return a;
    }
    else
    {
        return GCD(b, a % b);
    }
}

 static double UniqueFract()
{
    double sum = 0.0;
    for (int num = 1; num <= 9; num++)
    {
        for (int den = num + 1; den <= 9; den++)
        {
            if (GCD(num, den) == 1)
            {
                sum += (double)num / den;
            }
        }
    }
    return sum;
}

private static int GCD(int a, int b)
{
    while (b != 0)
    {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

 public static double UniqueFract()
{
    double sum = 0;
    for (int i = 1; i <= 9; i++) 
    {
        for (int j = i + 1; j <= 9; j++) 
        {
            if (GCD(i, j) == 1) 
            {
                sum += (double)i / j; 
            }
        }
    }
    return sum;
}

public static int GCD(int a, int b)
{
    if (b == 0)
    {
        return a;
    }
    else
    {
        return GCD(b, a % b);
    }
}

 static double UniqueFract() 
{
double sum = 0;
for (int i = 2; i <= 9; i++)
{
for (int j = 1; j < i; j++)
{
if (GCD(i, j) == 1)
{
sum += (double)j / i;
}
}
}
return sum;
}
public static int GCD(int a, int b)
{
if (b == 0)
{
return a;
}
else
{
return GCD(b, a % b);
}
}

 static double UniqueFract()
{
    double[] arr = new double[30];
    double sum = 0;
    for (int i = 1, k = 0; i < 9; i++)
        for (double j = i+1; j < 10; j++)
        {
            if(!arr.Contains(i / j)) 
            { 
                arr[k] = i / j; 
                k++; 
            }
        }
    for (int i = 0; i < arr.Length; i++)
        sum += arr[i];
    return sum;
}

 static double UniqueFract() 
{
   double result = 0;
   for(int i = 1; i <= 9; i++)
   {
       for(int j = i+1; j <= 9; j++)
       {
            if(GCD(i, j) == 1)
            {
                result += (double) i/j;
            }
       }
   }
   return result;
}
public static int GCD(int a, int b)
{
    while (b != 0) 
    {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

 static double UniqueFract()
{
    double result = 0;
    double fraction;
    for (double i = 1; i < 10; i++)
    {
        for (double j = i + 1; j < 10; j++)
        {
            fraction = i / j;
            if (j % i == 1 || i == 1)
            {
                result += fraction;
            }
            else if (j % i == 0  || (j % (j % i) == 0 && i % (j % i) == 0))
            {
                continue;
            }
            else
            {
                result += fraction;
            }
        }
    }
    return result;
}

 static int nod(int a, int b)
{
    if (b > a) (a, b) = (b, a);
    while (a > 0) (a, b) = (b % a, a);
    return b;
}
static double UniqueFract()
{
    double sum = 0;
    for (int a = 1; a <= 8; a++)
        for (int b = a + 1; b <= 9; b++)
            if (nod(a,b) == 1) sum += (double)a / b;
    return sum;
}

 static double UniqueFract() {
    double answ = 0;
    
    for(int i = 2; i <= 9; i++){
        for(int j = 1; j < i; j++){
            if(GCD(j, i) == 1){answ += (double)j/(double)i;}
        }
    }
    return answ;
}
static int GCD(int a, int b){
    while(b>0){
        int rem = a%b;
        a=b;
        b=rem;
    }
    return a;
}

 static double UniqueFract(){
    double sum = 0;
    double i2;
    double j2;
    for (double i = 1; i < 10; i++){
        for (double j = i + 1; j < 10; j++){
            i2 = i;
            j2 = j;
            for(;;){
                if(i2<=1||j2<=1) {break;} 
                    else if(j2<=i2) {i2 -= j2;}
                    else {j2 -= i2;}
                }
            if(i2==1||j2==1) {sum += i / j;}
        }
    }
    return sum;
}

 static double UniqueFract()
{
    double sum = 0;
    for (int i = 1; i <= 9; i++)
        for (int j = i + 1; j < 10; j++)
            if ((j % 2 != 0 || i % 2 != 0) && (j % 3 != 0 || i % 3 != 0))
                sum += (double) i / j;
    return sum;
}

 static double UniqueFract() {
    return 13.5;
}

 static double UniqueFract()
            {
                double sum = 0;
                for (double i = 2; i <= 9; i++)
                {
                    for (double j = 1; j < i; j++)
                    {
                        if (j == 1 || nsd(Convert.ToInt32(i), Convert.ToInt32(j)))
                        {
                            sum += j / i;
                        }

                    }
                }
                return sum;
            }
            static bool nsd(int num1, int num2)
            {
                for(int i = 2; i <= Math.Min(num1, num2); i++)
                {
                    if(num1%i == 0 && num2%i == 0)
                    {
                        return false;
                    }
                }
                return true;
            }

 static double UniqueFract() {
    double sum = 0;
    for (int i = 1; i < 10; i++) {
        for (int j = i + 1; j < 10; j++) {
            if (IsReducedFraction(i, j)) {
                sum += (double)i / j;
            }
        }
    }
    return sum;
}

static bool IsReducedFraction(int i, int j) {
    int test = Test(i, j);
    return (test == 1) || (j == 1);
}

static int Test(int a, int b) {
    while (b != 0) {
        int r = a % b;
        a = b;
        b = r;
    }
    return a;
}

 static double UniqueFract()
        {
            double sum = 0;
            for (int i = 1; i < 9; i++)
            {
                for (int j = i + 1; j <= 9; j++)
                {
                    if (Gcd(i, j) == 1)
                    {
                        sum += (double)i / j;
                    }
                }
            }
            return sum;
        }
        static int Gcd(int a, int b)
        {
            if (b == 0)
            {
                return a;
            }
            else
            {
                return Gcd(b, a % b);
            }
        }

 static double UniqueFract() {
    double sum = 0;
    for (int zn = 2; zn < 10; zn++) {
        for (int chs = 1; chs < zn; chs++) {
            int a = zn;
            int b = chs;
            while (b != 0) {
                int r = a % b;
                a = b;
                b = r;
            }
            if (a == 1) {
                sum += (double) chs / zn;
            }
        }
    }
    return sum;
}

 static double UniqueFract() {
    double result = 0;
    for(double i = 2; i < 10; i++)
        for(double j = 1; j < i; j++) 
        {
            if(!isIrreducibleFraction(j, i))
                result += j / i;
        }
    return result;
}
static bool isIrreducibleFraction(double a, double b)
{
    for(int i = 2; i < 9; i++)
    {
        if(a % i == 0 && b % i == 0) return true;
    }
    return false;
}

 static bool LinearlyDependent(int a, int b) {
    int min = Math.Min(a, b);
    for (int i = 2; i <= min; i++)
        if (a % i == 0 && b % i == 0) return true;
    return false;
}

static double UniqueFract() {
    double sum = 0;
    for (int denumerator = 2; denumerator < 10; denumerator++) {
        for (int numerator = 1; numerator < denumerator; numerator++) {
            if (LinearlyDependent(numerator, denumerator)) continue;
            sum += (double) numerator / denumerator;
        }
    }
    return sum;
}

 static double UniqueFract() {
    return 13.5;
}

 static double UniqueFract() {
    return 13.5;
}

static double UniqueFract() {
    double result = 0;
    double[] results = new double[32];
    int lastIdx = 0;
    for(int i = 1; i < 9; i++) {
        for(int j = 2; j <= 9; j++) {
            if(j > i) {
                double res = (double)i/j;
                if(!results.Contains(res)) {
                    result += res;
                    results[lastIdx] = res;
                    lastIdx++;
                }
            }
        }
    }
    return result;
}

 static double UniqueFract()
        {
            double res = 0;
            for (int denominator = 2; denominator <= 9; denominator++)
            {
                for (int numerator = 1; numerator < denominator; numerator++)
                {

                    if (Test(numerator, denominator) == 1)
                    {
                        res += (double)numerator / denominator;
                    }
                }
            }
            return res;
        }
        static int Test(int a, int b)
        {
            if (b == 0)
                return a;
            else
                return Test(b, a % b);
        }

 static double UniqueFract(){
double sum = 0;
for(int i = 1; i < 9; i++){
    for(double j = i+1; j < 10; j++){
        if((j % 2 != 0 || i % 2 != 0) && (j % 3 != 0 || i % 3 != 0))
        sum += i/j;
    }
}
return sum;
}

 static double UniqueFract()
        {
            bool Boba(double i, double q)
            {
                if(i%2==0&&q%2==0||i%3==0&&q%3==0)
                {
                    return false;
                }
                return true;
            }
            double result = 0;
            for (double i = 1; i < 10; i++)
            {
                for (double q = 2; q < 10; q++)
                {
                    if (q > i && (q / i) % 1 != 0 && Boba(i, q) || i == 1)
                    {
                        Console.WriteLine(i+"/"+q);
                        result += (i / q);
                    }

                }

            }
            return result;
        }

 static double UniqueFract() {

        double sum = 0;
               for (int i = 2; i<=9; i++) {
            sum += 1.0/i;
        }

        for (int i = 2; i <= 8; i++) {
            for (int j = (i+1); j <= 9; j++) {
                if (((i % 2 != 0) || (j % 2 != 0)) && ((i % 3 != 0) || (j % 3 != 0))) {
                    sum += (1.0 * i / j);
                }
            }
        }
        return sum;
    }

 static double UniqueFract() {
    double sum = 0;
    for (int i = 1; i <= 9; i++) 
        for (int j = i + 1; j <= 9; j++)
            if (gcd(i, j) == 1) 
                sum += (double)i / j;
    return sum;
}

static int gcd(int a, int b) {
    while (b != 0) {
        int r = a % b;
        a = b;
        b = r;
    }
    return a;
}

 static double UniqueFract() {
    static bool CheckUnique(int div1, int div2){
        for(int i=2; i< 5; i++){
            if(div1%i==0&&div2%i==0){
                return false;
            }
        }
        return true;
    }
    double sum=0;
    for(int i=1;i< 10;i++){
        for(int j=i+1;j< 10;j++){
            if(CheckUnique(i,j)){
                sum+=(double)i/j;
            }
        }
    }
    return sum;
}

 static double UniqueFract()
{
    double sum = 0;
    for (int i = 2; i <= 9; i++)
    {
        for (int j = 1; j < i; j++)
        {
            if (Chek(i, j) == 1)
            {
                sum += (double)j / i;
            }
        }
    }
    return sum;
}

static int Chek(int a, int b)
{
    while (b != 0)
    {
        int remainder = a % b;
        a = b;
        b = remainder;
    }
    return a;
}

 static double UniqueFract() {
    double sum = 0;

    for (double i = 9; i > 1; i--) {
        double tempSum = 0;

        for (double j = i - 1; j > 0; j--) {
            if((j % 2 != 0 || i % 2 != 0 ) && (j % 3 != 0 || i % 3 != 0 ) || j ==1) {
                tempSum += j;
            }
        }

        sum += tempSum / i;
    }
    return sum;
}

 static double UniqueFract() {
double sum = 0;
    for (int i = 2; i <= 9; i++) 
    {
        for (int j = 1; j < i; j++) 
        {
            int gcd = 1;
            for (int k = 2; k <= j && k <= i; k++) 
            {
                if (j % k == 0 && i % k == 0) 
                {
                    gcd = k;
                }
            }
            if (gcd == 1) 
            {
                sum += (double)j / i;
            }
        }
    }
    return sum;
}

 static double UniqueFract()
    {
        double sum = 0;
        for (short i = 1; i < 9; i++)
        {
            for (short j = (short)(i + 1); j < 10; j++)
            {
                if ((i % 2 != 0|| j % 2 != 0) && (i % 3 != 0 || j % 3 != 0))
                {
                    sum += (double)(i) / (double)(j);
                }
            }
        }
        
        return sum;
    }

 public static double UniqueFract()
{
    double sum = 0;
    for (int b = 2; b <= 9; b++)
    {
        for (int a = 1; a < b; a++)
        {
            if (GCD(a, b) == 1)
            {
                sum += (double)a / b;
            }
        }
    }
    return sum;
}

private static int GCD(int a, int b)
{
    while (b != 0)
    {
        int t = b;
        b = a % b;
        a = t;
    }
    return a;
}

 static double nsd (double a, double b)
{
    double r = a % b;
    while (r != 0)
    {
        a = b;
        b = r;
        r = a % b;
    }
    return b;
}
static double UniqueFract() 
{
    double sum = 0;
    for (double i = 1; i <= 8; i++)
    {
        for (double j = i + 1; j <= 9; j++)
        {
            if (nsd(i, j) == 1)
                sum += i/j;
        }
    }
    return sum;
}

 static bool IsFractionsReduction(double j, double i)
    {
        bool b = false;
        for (int k = 2; k <= j; k++)
        {
            if (j % k == 0 && i % k == 0)
            {
                b = true;
                break;
            }
        }
        return b;
    }

static double UniqueFract() {
    {
        double ans = 0.0;
        for (double i = 9; i > 0; i--)                          // j/i
        {
            for (double j = i - 1; j > 0; j--)
            {
                if(IsFractionsReduction(j, i) != true)
                {
                    ans += j / i;
                }
            }
        }
        return ans;
    }
}