# Rev 102
## Task
Flag format is: JISCTF{data}
File: be_true
## Solution
```bash$ file be_truebe_true: python 2.7 byte-compiled```
We use `uncompyle` for this. We need to add the file extension `pyc`.
```python$ python2 ~/.local/bin/uncompyle6 be_true.pyc# uncompyle6 version 3.7.4# Python bytecode 2.7 (62211)# Decompiled from: Python 2.7 (default, [REDACTED])# Embedded file name: be_true.py# Compiled at: 2019-12-06 14:36:32import operatorflag = 0power = (12 * flag + 44) / 4 - 1234 / 617 * flag - sum([1, 4, 7])flag *= powerppc = filter(lambda cc22: not any(cc22 % uu22 == 0 for uu22 in range(2, cc22)), range(2, 10000))dat = reduce(operator.mul, (ppc[i] ** int(str(flag)[i]) for i in range(len(str(flag)))))print dat == 3560267726635400465627540581996487760054035685444946475657505105403063442856963534755133504166293811169018648637812735995934052617540980495952470560844800443626277335201401028364068797946796579956457852457279957300619892623751175557650873016730889125068146398488627192356718363004881175012104986391177956396290571688585499385019181192105543180552708742672275440530116680223358366613050183523086165910780504269235376773473500L# okay decompiling be_true.pyc```
Let's do this step by step:
```pythonpower = (12 * flag + 44) / 4 - 1234 / 617 * flag - sum([1, 4, 7])power = 3 * flag + 11 - 2 * flag - 12power = flag - 1```
This is just simplifying the expression.
```pythonflag  = 0flag *= powerflag *= flag - 1flag = flag * (flag - 1)flag = flag**2 - flag```
This is just inserting the simplification an moving things around..
So what is `ppc`? It's the `range(2, 10000)` filtered by `not any(c % u == 0 for u in range(2, c))`. This is just creating a list of primes.
So what is `dat`? It's each prime from `ppc` exponented with the corresponding char from `flag` at that index and all of the result multiplied together.
This means we can resote `flag` from the required `dat` with prime factorization.
If `flag` was `201`, dat would be `20 == 2**2 * 3**0 * 5**1`.
Keep in mind there is `print dat` not `print(dat)` so this is python2. We write this script:
```pythondef primes(n):    primfac = []    d = 2    while d*d <= n:        while (n % d) == 0:            primfac.append(d)            n //= d        d += 1    if n > 1:       primfac.append(n)    return primfac
flag = 0cnt = Counter()# reduced to 269 here since it's zero after thatppc = filter(lambda cc22: not any(cc22 % uu22 == 0 for uu22 in range(2, cc22//2+1)), range(2, 269))
for prime in ppc:    cnt[prime] = 0
for prime in primes(result):    cnt[prime] += 1
print(cnt)
out = ""
for prime in ppc:    out += str(cnt[prime])
print(out)```
And get this:
```bash$ python2 be_true.pyCounter({7: 9, 37: 9, 73: 9, 83: 9, 17: 8, 41: 8, 131: 8, 3: 7, 197: 7, 241: 7, 139: 7, 227: 7, 191: 7, 137: 6, 29: 6, 263: 6, 101: 6, 157: 6, 257: 5, 19: 5, 151: 5, 67: 5, 89: 5, 109: 5, 113: 5, 31: 4, 229: 4, 59: 4, 199: 4, 239: 4, 5: 3, 23: 3, 193: 3, 223: 3, 97: 3, 211: 3, 2: 2, 163: 2, 53: 2, 181: 2, 71: 2, 79: 2, 107: 2, 13: 1, 149: 1, 167: 1, 173: 1, 47: 1, 179: 1, 61: 1, 233: 1, 11: 0, 269: 0, 43: 0, 103: 0, 251: 0, 127: 0})273901853649801241529295360255086715621112737433741470560```
`out` is now `flag**2 - flag`. Since it's such a large number the trouble-free way is to calculate the (positive) solution with WolframAlpha.
`flag` is now `5233563352533350594343304433`.
Unhexlify that...
```python>>> binascii.unhexlify(b'5233563352533350594343304433')b'R3V3RS3PYCC0D3'```