Is "reused one time pad" safe to encrypt a message like "random number + mod"? I want to encrypt a message that contains a fixed length random number and a long mod. 
i.e. 1234564284 (created like this 123456 + (123456 mod 9931))

I assume that reusing the same key is not a problem if the message is purely random but is the fact that the message is always given with a mod is opening a hole to find the key?
Here's my understanding of the encryption process you're talking about:


You take a random number $r$, and compute $t = r \bmod n$
You concatinate the two numbers $r$ and $t$, and express the concatination as a bitstring $u$
You then xor that bitstring $u$ with a secret bitstring $s$


You do the same for two different random numbers $r$ and $r'$, using the same values for $n$ and $s$.

If that is correct, then here is one way that someone with the two encrypted strings can recover a short list of possible $r, r'$ values:


Consider all possible $r$ values (in your example, $r$ was a 6 digit number, so that would be trivial; I don't know how long you would make $r$ in the real case)
For each such $r$, compute the corresponding $t = r \bmod n$, and combine them to form the bitstring $u$.
Exclusive-or $u$ with the first ciphertext to create the corresponding bitstring $s$.
Validate that guess on $s$ by attempting to decrypt the second ciphertext with it; recovering the corresponding $r'$, $t'$ values.  If $t' = r' \bmod n$, then add $r, r'$ to the list of plausible values.


In the simple example you gave (and depending somewhat on how you encode the numbers as bitstrings), that would give you a list of approximately 100 $r, r'$ values, one of which are the correct one.  It would be possible to list this to only the correct value given 1 or 2 more ciphertexts.

One time pad (where you use the secret bitstring $s$ only once) is safe because, while can reconstruct the possible values of $s$ (based on what the original message might be), you have no way to verify any possible $s$ value.  By reusing $s$, you provide such a way, and thus lose the security guarantees that you have when you use $s$ only once.

It is likely possible to design a more efficient attack method; however that method would likely depend on the details of how you encode an integer as a bitstring