#include <bits/stdc++.h>
using namespace std;

// So sánh hai chuỗi số lớn
int cmp(const string &a, const string &b) {
    if (a.size() != b.size()) return a.size() < b.size() ? -1 : 1;
    if (a == b) return 0;
    return a < b ? -1 : 1;
}

// Nhân số lớn (string) với số lớn (string)
multiply(const string &a, const string &b) {
    int n = a.size(), m = b.size();
    vector<int> res(n + m, 0);
    for (int i = n - 1; i >= 0; i--) {
        for (int j = m - 1; j >= 0; j--) {
            int mul = (a[i] - '0') * (b[j] - '0');
            int sum = res[i + j + 1] + mul;
            res[i + j + 1] = sum % 10;
            res[i + j] += sum / 10;
        }
    }
    string s;
    for (int c : res) if (!(s.empty() && c == 0)) s.push_back(c + '0');
    return s.empty() ? "0" : s;
}

// Cộng 1 vào số lớn (string)
string addOne(const string &s) {
    string a = s;
    int i = a.size() - 1, carry = 1;
    while (i >= 0 && carry) {
        int d = a[i] - '0' + carry;
        a[i] = (d % 10) + '0';
        carry = d / 10;
        i--;
    }
    if (carry) a = '1' + a;
    return a;
}

// Chia đôi số lớn (string)
string divTwo(const string &s) {
    string res = "";
    int temp = 0;
    for (char c : s) {
        temp = temp * 10 + (c - '0');
        res += (temp / 2) + '0';
        temp %= 2;
    }
    while (res.size() > 1 && res[0] == '0') res.erase(res.begin());
    return res;
}

int main() {
    string n;
    cin >> n;
    string l = "1", r = n;
    // Tối ưu hóa biên: căn bậc hai của 10^100 là 10^50
    // Tuy nhiên, ta vẫn để r = n và dùng tìm kiếm nhị phân chuẩn

    while (cmp(l, r) <= 0) {
        string mid = divTwo(addOne(l + "0")); // (l+r)/2 nhưng an toàn
        // Tính mid = (l + r) / 2
        // Cách khác:
        string sum = "";
        // ... (cần hàm cộng)
        // Thay vào đó, dùng phép chia 2 trực tiếp sau khi cộng

        // Để đơn giản hóa code trong editorial:
        // Giả sử có hàm add, sub, div2
        // mid = div2(add(l, r));
    }
    // Code đầy đủ cần các hàm helper
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

// Các hàm cộng, trừ, nhân, chia số lớn (được tổng hợp từ các giải pháp)
// Hàm so sánh cmp(a, b)
// Hàm nhân multiply(a, b)
// Hàm cộng add(a, b)
// Hàm trừ subtract(a, b) (với a >= b)
// Hàm chia cho 2 divTwo(s)

string sqrtNewton(string n) {
    string x = n;
    string prev = "";
    // Chọn giá trị khởi tạo tốt: x0 ~ n
    // Công thức Newton: x_{k+1} = (x_k + n / x_k) / 2
    // Lặp cho đến khi x không thay đổi (đủ chính xác)

    // Lưu ý: Kiểm tra điều kiện dừng
    while (cmp(x, prev) != 0) {
        prev = x;
        // x = (x + n / x) / 2
        // Cần hàm chia số lớn: n / x
        // Nếu dùng thư viện tự cài, code sẽ rất dài.
        // Trong code mẫu, ta cần cài đặt hàm divide(string a, string b)
        // nhưng do phức tạp, người ta thường dùng Newton cho số lớn với các thao tác cơ bản.
        // Code mẫu dưới đây minh họa ý tưởng:
        /*
        string term = divide(n, x); // n / x
        string sum = add(x, term);  // x + n/x
        x = divTwo(sum);            // (x + n/x) / 2
        */
        // Tuy nhiên, phép chia số lớn rất phức tạp để cài đặt thủ công.
    }
    return x;
}

int main() {
    string n;
    cin >> n;
    // Xử lý n = "0" hoặc "1"
    // Gọi hàm sqrtNewton
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

// Sử dụng thư viện Boost hoặc tự định nghĩa class BigInt
// Code dưới đây là minh họa cho cách tiếp cận nếu ngôn ngữ hỗ trợ Big Integer nativly (như Python)
// Hoặc dùng thư viện Boost.Multiprecision trong C++

#include <boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;
using namespace std;

int main() {
    string s;
    cin >> s;
    cpp_int n(s);

    // Tính căn bậc hai bằng hàm sqrt của thư viện
    cpp_int root = sqrt(n);

    if (root * root == n) {
        cout << root << endl;
    } else {
        cout << "NO" << endl;
    }
    return 0;
}

// Nếu không dùng thư viện, phải tự cài đặt Class BigInt với phép nhân, chia, cộng, trừ.