Lukujono

# DAD TEST

INCREASE F # F = 1 to print 1 once at the end

INCREASE I # Number of iterations to fake recursion
INCREASE I
INCREASE I
INCREASE J
INCREASE J

REPEAT I TIMES (
  REPEAT J TIMES (
    REPEAT I TIMES (
      INCREASE I
    )
  )
)
# I = 192 (~>180 max length)

REPEAT I TIMES (
  # Repeat enough times for X to reach 1, but not too many

  # Goal: Do if X does not equal 1
  # via E = 1
  CLEAR B
  CLEAR C
  CLEAR D
  CLEAR E
  INCREASE D
  INCREASE B
  # E = 0, will set to 1 if X > 1
  # D = 1, will set to 0 if X > 1, remains 1 if X = 1
  REPEAT X TIMES (
    REPEAT C TIMES (
      CLEAR C # Avoid repeating this loop again
      CLEAR D # X != 1 and we set D = 0
      INCREASE E
    )
    REPEAT B TIMES (
      INCREASE C
      CLEAR B # Avoid repeating this loop again
    )
  )
  # Now: E = 1 if X > 1
  #      D = 1 if X = 1

  # Goal: print 1 if X == 1 but only once
  REPEAT F TIMES (
    PRINT X # Print current X
    REPEAT D TIMES (
      CLEAR F # Clear F to avoid printing X = 1 again
    )
  )

  # Goal: Execute the following part only when X > 1
  REPEAT E TIMES (

    # Goal: implement "IF X IS ODD"
    CLEAR B # B = 0 # Redundant, might remove
    CLEAR C # C = 0
    CLEAR T
    INCREASE B # B = 1
    REPEAT X TIMES (
      REPEAT C TIMES (
        INCREASE T # Increasing T instead of B to skip next block
        CLEAR C
      )
      REPEAT B TIMES (
        INCREASE C
        CLEAR B
      )
      REPEAT T TIMES (
        INCREASE B # Now we increase B we postponed earlier
        CLEAR T
      )
    )
    # Now: B = 1 if X is even, else B = 0
    #      C = 1 if X is odd, else C = 0

    CLEAR A # Pre-clear A

    # goal: A = X / 2
    REPEAT B TIMES (
      # Optimized values by now:
      # B = 1 and C = 0
#      CLEAR B
#      CLEAR C
      CLEAR T
#      INCREASE B
      REPEAT X TIMES (
        REPEAT C TIMES (
          INCREASE A # A + 1 for odd X
          INCREASE T # Increasing T instead of B to skip next block
          CLEAR C
        )
        REPEAT B TIMES (
          INCREASE C
          CLEAR B
        )
        REPEAT T TIMES (
          INCREASE B # Now we increase B we postponed earlier
          CLEAR T
        )
      )
      # Optimized values by now:
      # B = 1, C = 0
    )
    # now A is X / 2 if X was even

    # goal: A = X * 3 + 1
    REPEAT C TIMES (
      # Optimized values by now:
      # B = 0 and C = 1
#      CLEAR B
      INCREASE B
      INCREASE B
      INCREASE B
      REPEAT B TIMES (
        REPEAT X TIMES (
          INCREASE A
        )
      )
      INCREASE A
    )
    # now A is X * 3 + 1 if X was odd

    # Update X
    CLEAR X
    REPEAT A TIMES (
      INCREASE X
    )
    # now X = A
  )
)

Test 1 (public)

Verdict: ACCEPTED