#include <bits/stdc++.h>
using lint = long long;
using namespace std;
lint Sum(lint a, lint b) { return (a + b) * (b - a + 1) / 2; }
lint permutation(lint n, lint k) {
  lint v = 1;
  if (0 < k && k <= n) {
    for (lint i = 0; i < k; i++) {
      v *= (n - i);
    }
  } else if (k > n) {
    v = 0;
  }
  return v;
}
lint factorial(lint n) { return permutation(n, n - 1); }
lint combination(lint n, lint k) { return permutation(n, k) / factorial(k); }
lint homogeneous(lint n, lint k) { return combination(n + k - 1, k); }
lint mini(lint a, lint b) {
  if (a > b) {
    return b;
  }
  return a;
}
lint maxf(double a, double b) {
  if (a > b) {
    return a;
  }
  return b;
}
lint maxi(lint a, lint b) {
  if (a > b) {
    return a;
  }
  return b;
}
lint pawf(double f, lint num) {
  double result = 1;
  for (lint i = 0ll; num > i; i++) {
    result *= f;
  }
  return result;
}
lint pawi(lint f, lint num) {
  lint result = 1;
  for (lint i = 0; num > i; i++) {
    result *= f;
  }
  return result;
}
vector<lint> atois(vector<string> str) {
  vector<lint> result((lint)str.size());
  for (lint i = 0; i < (lint)str.size(); i++) {
    std::sscanf(str[i].c_str(), "%lld", &result[i]);
  }
  return result;
}
vector<vector<lint>> alatois(vector<vector<string>> str) {
  vector<vector<lint>> result((lint)str.size());
  for (lint i = 0; i < (lint)str.size(); i++) {
    result[i] = atois(str[i]);
  }
  return result;
}
std::vector<string> split(std::string str, char del) {
  std::vector<std::string> result;
  std::string input = "";
  std::stringstream ss;
  ss << str;
  char now;
  for (;;) {
    now = ss.get();
    if (now == del) {
      result.push_back(input);
      input = "";
      continue;
    }
    if (now == std::istringstream::traits_type::eof()) {
      result.push_back(input);
      break;
    }
    input += now;
  }
  return result;
}
string readLine() {
  const lint readLen = 100000;
  char buf[readLen];
  string input = "";
  vector<string> result;
  for (;;) {
    fgets(buf, sizeof(buf), stdin);
    input += string(buf);
    if (input.find("\n") != std::string::npos) {
      break;
    }
  }
  return input;
}
std::vector<std::vector<string>> rLine(lint line) {
  std::vector<std::vector<string>> stringInput;
  std::string s;
  for (int i = 0; i < line; i++) {
    s = readLine();
    stringInput.push_back(split(s, ' '));
  }
  return stringInput;
}
vector<vector<lint>> irLine(int i) { return alatois(rLine(i)); }
tuple<vector<lint>, vector<vector<string>>> mrLine(lint line) {
  std::vector<std::vector<string>> stringInput;
  std::vector<lint> input;
  std::string s;
  s = readLine();
  std::vector<std::string> x = split(s, ' ');
  input = atois(x);
  stringInput = rLine(input[line - 1]);
  return forward_as_tuple(input, stringInput);
}
tuple<vector<lint>, vector<vector<lint>>> mirLine(lint line) {
  vector<lint> first;
  vector<vector<string>> input;
  std::tie(first, input) = mrLine(line);
  return forward_as_tuple(first, alatois(input));
}
lint gcd(lint a, lint b) {
  if (b == 0) {
    return a;
  }
  return gcd(b, a % b);
}
lint gcd3(lint a, lint b, lint c) { return gcd(gcd(a, b), c); }
string meds3(string x, string y, string z) {
  if (x < y) {
    if (x > z) {
      return x;
    } else if (z > y) {
      return y;
    } else {
      return z;
    }
  }
  if (z < y) {
    return y;
  } else if (x < z) {
    return x;
  } else {
    return z;
  }
}
lint medi3(lint x, lint y, lint z) {
  if (x < y) {
    if (x > z) {
      return x;
    } else if (z > y) {
      return y;
    } else {
      return z;
    }
  }
  if (z < y) {
    return y;
  } else if (x < z) {
    return x;
  } else {
    return z;
  }
}
void iQuicksort(vector<lint>& a, lint left, lint right) {
  if (left < right) {
    lint i = left;
    lint j = right;
    lint tmp = 0;
    lint pivot = medi3(a[i], a[i + (j - i) / 2], a[j]);
    for (;;) {
      for (; a[i] < pivot; i++) {
      }
      for (; pivot < a[j]; j--) {
      }
      if (i >= j) {
        break;
      }
      tmp = a[i];
      a[i] = a[j];
      a[j] = tmp;
      i++;
      j--;
    }
    iQuicksort(a, left, i - 1);
    iQuicksort(a, j + 1, right);
  }
}
void sQuicksort(vector<string>& a, lint left, lint right) {
  if (left < right) {
    lint i = left;
    lint j = right;
    string tmp = 0;
    string pivot = meds3(a[i], a[i + (j - i) / 2], a[j]);
    for (;;) {
      for (; a[i] < pivot; i++) {
      }
      for (; pivot < a[j]; j--) {
      }
      if (i >= j) {
        break;
      }
      tmp = a[i];
      a[i] = a[j];
      a[j] = tmp;
      i++;
      j--;
    }
    sQuicksort(a, left, i - 1);
    sQuicksort(a, j + 1, right);
  }
}
void qiSort(vector<lint>& a) { iQuicksort(a, 0, a.size() - 1); }
void qsSort(vector<string>& a) { sQuicksort(a, 0, a.size() - 1); }
lint absi(lint a) {
  if (a > 0) {
    return a;
  }
  return -a;
}
double absf(double a) {
  if (a > 0) {
    return a;
  }
  return -a;
}
int main() {
  auto input = irLine(1);
  double R = input[0][0];
  printf("%.9f", 2.0 * M_PI * R);
  return 0;
}
