#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:666000000")
using namespace std;
const int inf = (1 << 30) - 1;
const long double eps = 1e-9;
const long double pi = fabs(atan2(0.0, -1.0));
void ML(const bool v) {
  if (v) return;
  int *ass;
  for (;;) {
    ass = new int[2500000];
    for (int i = 0; i < 2500000; i++) ass[i] = rand();
  }
}
void TL(const bool v) {
  if (v) return;
  int *ass;
  ass = new int[250];
  for (;;) {
    for (int i = 0; i < 250; i++) ass[i] = rand();
  }
}
void PE(const bool v) {
  if (v) return;
  puts("ass 1 2 3 4 5 6 fuck");
  exit(0);
}
long long dmax;
bool LoAd() { return (1 == scanf("%d", &dmax)); }
long long gcd(long long a, long long b) {
  while (0 != b) {
    a %= b;
    swap(a, b);
  }
  return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
struct node {
  long long p, q, im;
  node() : p(0), q(1), im(0){};
  void norm() {
    long long g = gcd(im, gcd(p, q));
    p /= g;
    q /= g;
    im /= g;
  }
  node(const long long p) : p(p), q(1), im(0) {}
  node(const long long p, const long long q, const long long im,
       bool need_norm = true)
      : p(p), q(q), im(im) {
    if (need_norm) norm();
  };
  node operator+(const node &v) const {
    return node(p * v.q + v.p * q, q * v.q, im * v.q + v.im * q);
  }
  node operator-(const node &v) const {
    return node(p * v.q - v.p * q, q * v.q, im * v.q - v.im * q);
  }
  node operator*(const node &v) const {
    return node(p * v.p + 3 * im * v.im, q * v.q, p * v.im + im * v.p);
  }
  node operator-() const { return node(-p, q, -im); }
  node sq() const {
    return node(((p) * (p)) + 3 * ((im) * (im)), ((q) * (q)), 2 * p * im);
  }
  void epr(const string str = "") const { ; }
  node pow2() const {
    return node(p * p + 3 * im * im, q * q, p * im + im * p, false);
  }
};
long long lsq(const long long v) {
  return ((((long long)v)) * (((long long)v)));
}
long double dsq(const int v) {
  return ((((long double)v)) * (((long double)v)));
}
bool point_near(const node x, const node y) {
  node x2 = x.pow2();
  node y2 = y.pow2();
  node v = x2 + y2;
  long long d2 = ((dmax) * (dmax));
  return (((long double)v.p + sqrtl(3.0) * v.im) / v.q < d2 ||
          (fabsl(((long double)v.p + sqrtl(3.0) * v.im) / v.q - d2) < 1e-9));
  if (d2 * v.q - v.p < 0) return false;
  if (lsq(v.im) * 3 <= ((d2) * (d2)) * lsq(v.q) - d2 * 2 * v.p * v.q + lsq(v.p))
    return true;
  return false;
}
const node dx[] = {node(1, 2, 0),  node(1, 1, 0),  node(1, 2, 0),
                   -node(1, 2, 0), -node(1, 1, 0), -node(1, 2, 0)};
const node dy[] = {node(0, 2, 1),  0, -node(0, 2, 1),
                   -node(0, 2, 1), 0, node(0, 2, 1)};
void up(node &x, node &y) {
  y = y + node(0, 1, 1);
  y.norm();
}
void dn(node &x, node &y) {
  y = y - node(0, 1, 1);
  y.norm();
}
void up_rt(node &x, node &y) {
  x = x + node(3, 2, 0);
  y = y + node(0, 2, 1);
}
bool cell_near(const node x, const node y) {
  for (int i = 0; i < 2; i++) {
    node nx = x + dx[i];
    node ny = y + dy[i];
    if (!point_near(nx, ny)) return false;
  }
  return true;
}
void SoLvE() {
  long long mid = 0;
  node x = 0;
  node y = 0;
  long long res = 0;
  while (cell_near(x, y)) {
    up(x, y);
    mid++;
  }
  mid = mid * 2 - 1;
  dn(x, y);
  long long cur = mid;
  for (;;) {
    up_rt(x, y);
    cur++;
    while (cur > 0 && !cell_near(x, y)) {
      dn(x, y);
      cur -= 2;
    }
    if (cur <= 0) break;
    res += cur * 2;
  }
  res += mid;
  cout << res << endl;
}
int main() {
  srand((int)time(NULL));
  while (LoAd()) SoLvE();
  return 0;
}

### Prompt

Develop a solution in Cpp to the problem described below:

A breakthrough among computer games, "Civilization XIII", is striking in its scale and elaborate details. Let's take a closer look at one of them.

The playing area in the game is split into congruent cells that are regular hexagons. The side of each cell is equal to 1. Each unit occupies exactly one cell of the playing field. The field can be considered infinite. 

Let's take a look at the battle unit called an "Archer". Each archer has a parameter "shot range". It's a positive integer that determines the radius of the circle in which the archer can hit a target. The center of the circle coincides with the center of the cell in which the archer stays. A cell is considered to be under the archer’s fire if and only if all points of this cell, including border points are located inside the circle or on its border.

The picture below shows the borders for shot ranges equal to 3, 4 and 5. The archer is depicted as A. 

<image>

Find the number of cells that are under fire for some archer.

Input

The first and only line of input contains a single positive integer k — the archer's shot range (1 ≤ k ≤ 106).

Output

Print the single number, the number of cells that are under fire.

Please do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use the cout stream (also you may use the %I64d specificator).

Examples

Input

3


Output

7

Input

4


Output

13

Input

5


Output

19

### Response

```cpp
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:666000000")
using namespace std;
const int inf = (1 << 30) - 1;
const long double eps = 1e-9;
const long double pi = fabs(atan2(0.0, -1.0));
void ML(const bool v) {
  if (v) return;
  int *ass;
  for (;;) {
    ass = new int[2500000];
    for (int i = 0; i < 2500000; i++) ass[i] = rand();
  }
}
void TL(const bool v) {
  if (v) return;
  int *ass;
  ass = new int[250];
  for (;;) {
    for (int i = 0; i < 250; i++) ass[i] = rand();
  }
}
void PE(const bool v) {
  if (v) return;
  puts("ass 1 2 3 4 5 6 fuck");
  exit(0);
}
long long dmax;
bool LoAd() { return (1 == scanf("%d", &dmax)); }
long long gcd(long long a, long long b) {
  while (0 != b) {
    a %= b;
    swap(a, b);
  }
  return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
struct node {
  long long p, q, im;
  node() : p(0), q(1), im(0){};
  void norm() {
    long long g = gcd(im, gcd(p, q));
    p /= g;
    q /= g;
    im /= g;
  }
  node(const long long p) : p(p), q(1), im(0) {}
  node(const long long p, const long long q, const long long im,
       bool need_norm = true)
      : p(p), q(q), im(im) {
    if (need_norm) norm();
  };
  node operator+(const node &v) const {
    return node(p * v.q + v.p * q, q * v.q, im * v.q + v.im * q);
  }
  node operator-(const node &v) const {
    return node(p * v.q - v.p * q, q * v.q, im * v.q - v.im * q);
  }
  node operator*(const node &v) const {
    return node(p * v.p + 3 * im * v.im, q * v.q, p * v.im + im * v.p);
  }
  node operator-() const { return node(-p, q, -im); }
  node sq() const {
    return node(((p) * (p)) + 3 * ((im) * (im)), ((q) * (q)), 2 * p * im);
  }
  void epr(const string str = "") const { ; }
  node pow2() const {
    return node(p * p + 3 * im * im, q * q, p * im + im * p, false);
  }
};
long long lsq(const long long v) {
  return ((((long long)v)) * (((long long)v)));
}
long double dsq(const int v) {
  return ((((long double)v)) * (((long double)v)));
}
bool point_near(const node x, const node y) {
  node x2 = x.pow2();
  node y2 = y.pow2();
  node v = x2 + y2;
  long long d2 = ((dmax) * (dmax));
  return (((long double)v.p + sqrtl(3.0) * v.im) / v.q < d2 ||
          (fabsl(((long double)v.p + sqrtl(3.0) * v.im) / v.q - d2) < 1e-9));
  if (d2 * v.q - v.p < 0) return false;
  if (lsq(v.im) * 3 <= ((d2) * (d2)) * lsq(v.q) - d2 * 2 * v.p * v.q + lsq(v.p))
    return true;
  return false;
}
const node dx[] = {node(1, 2, 0),  node(1, 1, 0),  node(1, 2, 0),
                   -node(1, 2, 0), -node(1, 1, 0), -node(1, 2, 0)};
const node dy[] = {node(0, 2, 1),  0, -node(0, 2, 1),
                   -node(0, 2, 1), 0, node(0, 2, 1)};
void up(node &x, node &y) {
  y = y + node(0, 1, 1);
  y.norm();
}
void dn(node &x, node &y) {
  y = y - node(0, 1, 1);
  y.norm();
}
void up_rt(node &x, node &y) {
  x = x + node(3, 2, 0);
  y = y + node(0, 2, 1);
}
bool cell_near(const node x, const node y) {
  for (int i = 0; i < 2; i++) {
    node nx = x + dx[i];
    node ny = y + dy[i];
    if (!point_near(nx, ny)) return false;
  }
  return true;
}
void SoLvE() {
  long long mid = 0;
  node x = 0;
  node y = 0;
  long long res = 0;
  while (cell_near(x, y)) {
    up(x, y);
    mid++;
  }
  mid = mid * 2 - 1;
  dn(x, y);
  long long cur = mid;
  for (;;) {
    up_rt(x, y);
    cur++;
    while (cur > 0 && !cell_near(x, y)) {
      dn(x, y);
      cur -= 2;
    }
    if (cur <= 0) break;
    res += cur * 2;
  }
  res += mid;
  cout << res << endl;
}
int main() {
  srand((int)time(NULL));
  while (LoAd()) SoLvE();
  return 0;
}

```