#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<numeric>
#include<stack>
#include<map>
#include<queue>
#include<unordered_map>
#include<cmath>
#include<utility>

using ULL = unsigned long long;
using LL = long long;
using String = std::string;
using Ints = std::vector<int>;
using Doubles = std::vector<double>;
using Bools = std::vector<bool>;
using Strings = std::vector<std::string>;
using ULLs = std::vector<ULL>;
using LLs = std::vector<LL>;

// pythonのdictionary相当
template <typename T1, typename T2>
using Dict = std::unordered_map<T1,T2>;



template <class T>
class MOD{
private:
    ULL mod;
    T res;
    bool initializedCOM = false;  // COM計算用の初期化をしているか
    const ULL ComMax = 510000;  // 二項計算のnを最大どこまで考えるか
    ULLs fac, finv, inv;

    // mod世界での逆元を求めている
    T modinv(T a) {
        T b = mod, u = 1, v = 0;
        while (b) {
            T t = a / b;
            a -= t * b; std::swap(a, b);
            u -= t * v; std::swap(u, v);
        }
        u %= mod;
        if (u < 0) u += mod;
        return u;
    }

    // 二項係数テーブルを作るための前処理 O(n)
    void COMinit() {
        fac.resize(ComMax);
        finv.resize(ComMax);
        inv.resize(ComMax);

        fac[0] = fac[1] = 1;
        finv[0] = finv[1] = 1;
        inv[1] = 1;
        for (int i = 2; i < ComMax; i++){
            fac[i] = fac[i - 1] * i % mod;
            inv[i] = mod - inv[mod%i] * (mod / i) % mod;
            finv[i] = finv[i - 1] * inv[i] % mod;
        }
    }

public:
    MOD(){
        this->mod = std::numeric_limits<ULL>::max();
    }

    MOD(T mod){
        this->mod = mod;
    }

    void set(T a){
        this->res = a % mod;
    }

    void add(T a){
        this->res = (this->res + a) % mod;
    }

    void sub(T a){
        T tmp = (this->res - a % mod) % mod;
        if(tmp < 0){
            this->res = tmp + mod;
        }else{
            this->res = tmp;
        }
    }

    void mul(T a){
        this->res = a * this->res % mod;
    }

    void div(T a){
        // 逆元を用いて計算する
        this->res = this->res * modinv(a) % mod;
    }

    // 二分累乗法を用いる
    // 引数には指数exだけ与え、保持している値aに対しa^ex mod pを計算する
    void pow(LL n) {
        LL res = 1;
        while (n > 0) {
            if (n & 1) res = res * this->res % mod;
            this->res = this->res * this->res % mod;
            n >>= 1;
        }
        this->res = res;
    }

    // 二項係数　kだけを指定して保持している値を上書きする
    void com(int k) {
        if(!initializedCOM){
            COMinit();
            initializedCOM = true;
        }
        if (this->res < k) return;
        if (this->res < 0 || k < 0) return;
        std::cout << fac[this->res] << " " << k << std::endl;
        this->res = fac[this->res] * (finv[k] * finv[this->res - k] % mod) % mod;
    }

    // 二項係数　nとkを指定して保持している値を上書きする
    void com(int n, int k) {
        if(!initializedCOM){
            COMinit();
            initializedCOM = true;
        }
        if (n < k) return;
        if (n < 0 || k < 0) return;
        this->res = fac[n] * (finv[k] * finv[n - k] % mod) % mod;
    }

    T get(){
        return this->res;
    }
};

int main(void) {
    int K;
    std::cin >> K;

    MOD<int> mod(K);

    int i=1;
    mod.set(7);
    for(;i<10e+6+1;i++){
        if(mod.get()==0) break;
        mod.mul(10);
        mod.add(7);
    }

    if(i==10e+6+1) std::cout << -1 << std::endl;
    else std::cout << i << std::endl;

    return 0;
}

Measured memory_bytes: 3628