#include "bits/stdc++.h"
#include <atcoder/all>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
inline ll gcd(ll a, ll b) { return b ? gcd(b, a%b) : a; }
inline ll lcm(ll a, ll b) { return a / gcd(a, b)*b; }
template<class S,class T> ostream& operator << (ostream& out,const pair<S,T>& o){ out << "(" << o.first << "," << o.second << ")"; return out; }
template<class T> ostream& operator << (ostream& out,const vector<T>& V){ for(int i = 0; i < V.size(); i++){ out << V[i]; if(i!=V.size()-1) out << " ";} return out; }
template<class T> ostream& operator << (ostream& out,const vector<vector<T> >& Mat){ for(int i = 0; i < Mat.size(); i++) { if(i != 0) out << endl; out << Mat[i];} return out; }
template<class S,class T> ostream& operator << (ostream& out,const map<S,T>& mp){ out << "{ "; for(auto it = mp.begin(); it != mp.end(); it++){ out << it->first << ":" << it->second; if(mp.size()-1 != distance(mp.begin(),it)) out << ", "; } out << " }"; return out; }
template<typename T>vector<T> make_v(size_t a){return vector<T>(a);}
template<typename T,typename... Ts>auto make_v(size_t a,Ts... ts){return vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));}
template<typename T,typename V> typename enable_if<is_class<T>::value==0>::type fill_v(T &t,const V &v){t=v;}
template<typename T,typename V> typename enable_if<is_class<T>::value!=0>::type fill_v(T &t,const V &v){for(auto &e:t) fill_v(e,v);}
/*
 <url:>
 問題文============================================================
 =================================================================
 解説=============================================================
 ================================================================
 */
// using namespace atcoder;


/**
 * Smalest number m such that m(m+1)/2 is divisible by n.
 * https://oeis.org/A011772
 *
 * Func : fix
 *  INPUT : N (<= 10^15)
 *  OUTPOT : Smalest number m such that m(m+1)/2 is divisible by N.
 * O(√N log N)
 */
class FindSmallestNumber_Sum_is_divisible_by_N{
private:
    ll LatestSmallestNumber;
    vector<ll> divisors;
public:
    FindSmallestNumber_Sum_is_divisible_by_N():LatestSmallestNumber(-1){}
    FindSmallestNumber_Sum_is_divisible_by_N(ll N){
        fix(N);
    }
    ll fix(ll N){
        LatestSmallestNumber = numeric_limits<ll>::max();
        calcdivisor(2*N);
        for(auto x:divisors){
            ll y = 2*N/x;
            
            ll cand = CRT(vector<ll>{0,-1},vector<ll>{x,y}).first;
            if(cand == 0) continue;
            LatestSmallestNumber = min(LatestSmallestNumber,cand);
        }
        assert(LatestSmallestNumber != numeric_limits<ll>::max());
        return LatestSmallestNumber;
    }
    ll getSmallestNumber(){ return LatestSmallestNumber; }
private:
    void calcdivisor(ll n){
        divisors.clear();
        for(ll i = 1; i*i <= n;i++){
            if(n%i == 0) {
                divisors.push_back(i);
                if(n/i != i) divisors.push_back(n/i);
            }
        }
        sort(divisors.begin(),divisors.end());
    }
    
    inline ll mod(ll a,ll m){ return (a%m + m)%m;}
    /* 拡張ユークリッドの互除法 extgcd */
    static ll extgcd(ll a, ll b, ll& x, ll& y){
        ll g = a; x = 1; y = 0;
        if(b!=0) { g = extgcd(b, a%b, y, x); y -= (a/b)*x;}
        return g;
    }
    pll CRT(const vector<ll>& b,const vector<ll>& m){
        ll r = 0, M = 1;
        for(int i = 0; i < (int)b.size();i++){
            ll p,q;
            ll d = extgcd(M,m[i],p,q);
            if((b[i]-r)%d != 0) return make_pair(0,-1);
            ll tmp = (b[i]-r)/d*p%(m[i]/d);
            r += M*tmp;
            M *= m[i]/d;
        }
        return make_pair(mod(r,M), M);
    }

};

template<class Type>
Type solve(Type res = Type()){
    res = numeric_limits<ll>::max();
    ll N; cin >> N;
    FindSmallestNumber_Sum_is_divisible_by_N Searcher(N);
    res = Searcher.getSmallestNumber();
    return res;
}
int main(void) {
    cin.tie(0); ios_base::sync_with_stdio(false);
    // solve(0);
    cout << fixed << setprecision(15) << solve<ll>() << endl;
    return 0;
}


Measured memory_bytes: 3784