Can the same One-Time-Pad be re-used with some tricks Let’s say I have a message $m$ of $n$ bits. And a predetermined pad of $k*n$ bits. And for every bit $b$ of this message $m$, I’m creating random sequence $s$ of $k$ bits.

I also have a predetermined boolean random function $f$ (imagine something like this: $f(s) = hash(s)\ mod\ 2$).

For each bit $b_i$, I choose a random value for $s_i$, so that $f(s_i)=b_i$.

So, I can construct a padded version of $m$ like this: $m_p= s_0 || s_1 || ... || s_n$, removing the padding is trivial.

The encryption is also straightforward XOR of the $m_p$ value with the predetermined pad of the same length ($k * n$)

Can this protocol justify/enable reusing of the same pad over and over again providing OTP-Like security?



Equivalent text-based formulation of the scheme:
One comes up with a fresh, random hash pre-image for each message bit that when hashed yields the message bit as the LSB. You then transmit the pre-images and encrypt them with the re-used OTP.
Based on comments it seems the question asks if this is as secure as OTP as opposed to finding a practical attack. 

It is clearly not as secure as OTP. It is not information thetorical secure. With sufficient messages totalling more than key size we can brute force the key, just iterate over possible keys until you find one which works with all messages. 

With a OTP when the total message size never exceeds the key size, no compute power will allow you to brute force the key, all messages are equally likely and knowing part of the message doesn't help as the key is never reused.

Edit: Even an attack with $O(2^{kn})$ is sufficient to make it not information theoretical secure. but we can do at least somewhat better.

With $O(k)$ message pairs we can break the key with O(n*2^k) work. work one segment at a time. Iterate over all $2^k$ possible key segments, and check the messages, each message will exclude a bad key with probability 0.5 so we only need a few message pairs to rule out all false keys.

I reserve judgment regarding security of this with large k, and secure hash.