package chelper;

import io.InputReader;
import io.OutputWriter;
import misc.GCJSolution;
import misc.SimpleSavingChelperSolution;


public class TaskD extends GCJSolution {

  public void solve(int testNumber, InputReader in, OutputWriter out) {
    wrapSolve(testNumber, in, out);
  }

  double[][][] dp;

  public TaskD() {
    super();
    dp = new double[101][101][101];

    for (int c = 0; c <= 100; c++) {
      for (int b = 0; b <= 100; b++) {
        for (int a = 0; a <= 100; a++) {
          dp[a][b][c] = Double.NaN;
        }
      }
    }

    dp[0][0][0] = 0;

    get(0, 0, 100);

//    for (int c = 0; c <= 2; c++) {
//      for (int b = 0; b <= 2; b++) {
//        for (int a = 0; a <= 2; a++) {
//          System.out.println(a + " " + b + " " + c + " " + dp[a][b][c]);
//        }
//      }
//    }
  }

  @Override
  public void solve(int testNumber) {
    int n = in.nextInt();

    out.println(get(0, 0, n));
  }

  double get(int a, int b, int c) {
    if (a < 0 || b < 0 || c < 0) {
      return 0;
    }

    if (Double.isNaN(dp[a][b][c])) {
      calc(a, b, c);
    }

    return dp[a][b][c];
  }

  void calc(int a, int b, int c) {
    double aa = a;
    double bb = 2 * b;
    double cc = 3 * c;

    double n = aa + bb + cc;

    //////////////

    dp[a][b][c] = 0;

    if (n >= 3) {
      dp[a][b][c] += (cc / n) * (2 / (n - 1)) * (1 / (n - 2))        * (get(a + 0, b + 0, c - 1) + 1 + 0);

      dp[a][b][c] += (cc / n) * (2 / (n - 1)) * (aa / (n - 2))       * (get(a + 0, b + 0, c - 1) + 1 + 1);
      dp[a][b][c] += (cc / n) * (2 / (n - 1)) * (bb / (n - 2))       * (get(a + 2, b - 1, c - 1) + 1 + 0);
      dp[a][b][c] += (cc / n) * (2 / (n - 1)) * ((cc - 3) / (n - 2)) * (get(a + 1, b + 1, c - 2) + 1 + 0);
    }

    if (n >= 2) {
      dp[a][b][c] += (cc / n) * (aa / (n - 1))                       * (get(a - 1, b + 1, c - 1) + 1 + 1);
      dp[a][b][c] += (cc / n) * (bb / (n - 1))                       * (get(a + 1, b + 0, c - 1) + 1 + 0);
      dp[a][b][c] += (cc / n) * ((cc - 3) / (n - 1))                 * (get(a + 0, b + 2, c - 2) + 1 + 0);
    }

    //////////////

    if (n >= 2) {
      dp[a][b][c] += (bb / n) * (1 / (n - 1))                        * (get(a + 0, b - 1, c + 0) + 1 + 0);

      dp[a][b][c] += (bb / n) * (aa / (n - 1))                       * (get(a + 0, b - 1, c + 0) + 1 + 1);
      dp[a][b][c] += (bb / n) * ((bb - 2) / (n - 1))                 * (get(a + 2, b - 2, c + 0) + 1 + 0);
      dp[a][b][c] += (bb / n) * (cc / (n - 1))                       * (get(a + 1, b + 0, c - 1) + 1 + 0);
    }

    //////////////

    dp[a][b][c] += (aa / n)                                          * (get(a - 1, b + 0, c + 0) + 1);

  }
}