dc, 110 108 104 bytes

[[*]n]sd[dsi[li0!=dli1-dsi0!=L]dsLx]sl[10si[li0!=dli1-dsi0!=L]dsLx]sg[1+]sa10k/70*0k1~0!=ad10>ld10!>g[]p

echo 'v a (above)'|dc
# Wholly:
>> echo '163 2 [[*]n]sd[dsi[li0!=dli1-dsi0!=L]dsLx]sl[10si[li0!=dli1-dsi0!=L]dsLx]sg[1+]sa10k/70*0k1~0!=ad10>ld10!>g[]p'|dc
# outputs:
**
>> 

[[*]n]sd   # Here we store a macro in register d to print 1 * without a newline

[dsi[li0!=dli1-dsi0!=L]dsLx]sl # Store the "less than" case, a for loop which
                        # uses the top-of the stack as it's number of iterations.
[10si[li0!=dli1-dsi0!=L]dsLx]sg # Store the "greater than" case. It's the above,
                        # but it puts 10 on the stack to use instead.

[1+]sa # Store a macro to add 1 to whatever is the top-of-stack.


10k # Set precision at non-zero to allow decimal division

/70* # Divide the top two of the stack, v/a; multiply by 70 (`/700*10` == `/70`)
             # dc is postfix and stack-based, so operators come after operands.

0k1~0!=a     # This is a ceiling function.
|> 0k  # set precision to 0 to perform integer division
|> 1~  # push the quotient of integer division by 1, and then the remainder. (r is top)
|> 0!=a # If the top-of-stack (decimal part) is not 0, add 1 to the quotient

d10>ld10!>g # Conditional statement
|> d10>l  # (d)uplicate the top, push 10 on. If 10 > the old top, execute the `l`ess-than
          # case, which loops top-of-stack times.
|> d10!>g # Complement of the above, using the `g`reater-than to loop 10 times.

[]p # print a newline

• 2 bytes saved by duplicating-saving instead of saving-loading
• 4 bytes saved dividing by 70

dc, 110 108 104 98 bytes

[42P]sd[dsi[li0!=dli1-dsi0!=L]dsLx]sl[Isi[li0!=dli1-dsi0!=L]dsLx]sg[1+]saIk/70*0k1~0!=adI>ldI!>gIP

echo 'v a (above)'|dc
# Wholly:
>> echo '163 2 [42P]sd[dsi[li0!=dli1-dsi0!=L]dsLx]sl[Isi[li0!=dli1-dsi0!=L]dsLx]sg[1+]saIk/70*0k1~0!=adI>ldI!>gIP'|dc
# outputs:
**
>> 

[42P]sd   # Here we store a macro in register d to print 1 * without a newline

[dsi[li0!=dli1-dsi0!=L]dsLx]sl # Store the "less than" case, a for loop which
                        # uses the top-of the stack as it's number of iterations.
[Isi[li0!=dli1-dsi0!=L]dsLx]sg # Store the "greater than" case. It's the above,
                        # but it puts 10 on the stack to use instead.

[1+]sa # Store a macro to add 1 to whatever is the top-of-stack.


Ik # Set precision at non-zero to allow decimal division

/70* # Divide the top two of the stack, v/a; multiply by 70 (`/700*10` == `/70`)
             # dc is postfix and stack-based, so operators come after operands.

0k1~0!=a     # This is a ceiling function.
|> 0k  # set precision to 0 to perform integer division
|> 1~  # push the quotient of integer division by 1, and then the remainder. (r is top)
|> 0!=a # If the top-of-stack (decimal part) is not 0, add 1 to the quotient

dI>ldI!>g # Conditional statement
|> dI>l  # (d)uplicate the top, push 10 on. If 10 > the old top, execute the `l`ess-than
          # case, which loops top-of-stack times.
|> dI!>g # Complement of the above, using the `g`reater-than to loop 10 times.

IP # print a newline

• 2 bytes saved by duplicating-saving instead of saving-loading
• 4 bytes saved dividing by 70
• 6 bytes from daniero's suggestions (non-strings, ASCII nums instead; 10 => I)

dc, 110 108 bytes

[[*]n]sd[dsi[li0!=dli1-dsi0!=L]dsLx]sl[10si[li0!=dli1-dsi0!=L]dsLx]sg[1+]sa10k/700/10*0k1~0!=ad10>ld10!>g[]p

echo 'v a (above)'|dc
# Wholly:
>> echo '163 2 [[*]n]sd[dsi[li0!=dli1-dsi0!=L]dsLx]sl[10si[li0!=dli1-dsi0!=L]dsLx]sg[1+]sa10k/700/10*0k1~0!=ad10>ld10!>g[]p'|dc
# outputs:
**
>> 

[[*]n]sd   # Here we store a macro in register d to print 1 * without a newline

[dsi[li0!=dli1-dsi0!=L]dsLx]sl # Store the "less than" case, a for loop which
                        # uses the top-of the stack as it's number of iterations.
[10si[li0!=dli1-dsi0!=L]dsLx]sg # Store the "greater than" case. It's the above,
                        # but it puts 10 on the stack to use instead.

[1+]sa # Store a macro to add 1 to whatever is the top-of-stack.


10k # Set precision at non-zero to allow decimal division

/ 700 / 10 * # Divide the top two of the stack, v/a; then divide by 700, and multiply by 10
             # dc is postfix and stack-based, so operators come after operands.

0k1~0!=a     # This is a ceiling function.
|> 0k  # set precision to 0 to perform integer division
|> 1~  # push the quotient of integer division by 1, and then the remainder. (r is top)
|> 0!=a # If the top-of-stack (decimal part) is not 0, add 1 to the quotient

d10>ld10!>g # Conditional statement
|> d10>l  # (d)uplicate the top, push 10 on. If 10 > the old top, execute the `l`ess-than
          # case, which loops top-of-stack times.
|> d10!>g # Complement of the above, using the `g`reater-than to loop 10 times.

[]p # print a newline

• 2 bytes saved by duplicating-saving instead of saving-loading

dc, 110 108 104 bytes

[[*]n]sd[dsi[li0!=dli1-dsi0!=L]dsLx]sl[10si[li0!=dli1-dsi0!=L]dsLx]sg[1+]sa10k/70*0k1~0!=ad10>ld10!>g[]p

echo 'v a (above)'|dc
# Wholly:
>> echo '163 2 [[*]n]sd[dsi[li0!=dli1-dsi0!=L]dsLx]sl[10si[li0!=dli1-dsi0!=L]dsLx]sg[1+]sa10k/70*0k1~0!=ad10>ld10!>g[]p'|dc
# outputs:
**
>> 

[[*]n]sd   # Here we store a macro in register d to print 1 * without a newline

[dsi[li0!=dli1-dsi0!=L]dsLx]sl # Store the "less than" case, a for loop which
                        # uses the top-of the stack as it's number of iterations.
[10si[li0!=dli1-dsi0!=L]dsLx]sg # Store the "greater than" case. It's the above,
                        # but it puts 10 on the stack to use instead.

[1+]sa # Store a macro to add 1 to whatever is the top-of-stack.


10k # Set precision at non-zero to allow decimal division

/70* # Divide the top two of the stack, v/a; multiply by 70 (`/700*10` == `/70`)
             # dc is postfix and stack-based, so operators come after operands.

0k1~0!=a     # This is a ceiling function.
|> 0k  # set precision to 0 to perform integer division
|> 1~  # push the quotient of integer division by 1, and then the remainder. (r is top)
|> 0!=a # If the top-of-stack (decimal part) is not 0, add 1 to the quotient

d10>ld10!>g # Conditional statement
|> d10>l  # (d)uplicate the top, push 10 on. If 10 > the old top, execute the `l`ess-than
          # case, which loops top-of-stack times.
|> d10!>g # Complement of the above, using the `g`reater-than to loop 10 times.

[]p # print a newline

• 2 bytes saved by duplicating-saving instead of saving-loading
• 4 bytes saved dividing by 70

dc, 110 bytes

[[*]n]sd[dsi[li0!=dli1-dsi0!=L]sLlLx]sl[10si[li0!=dli1-dsi0!=L]sLlLx]sg[1+]sa10k/700/10*0k1~0!=ad10>ld10!>g[]p

echo 'v a (above)'|dc
# Wholly:
>> echo '163 2 [[*]n]sd[dsi[li0!=dli1-dsi0!=L]sLlLx]sl[10si[li0!=dli1-dsi0!=L]sLlLx]sg[1+]sa10k/700/10*0k1~0!=ad10>ld10!>g[]p'|dc
# outputs:
**
>> 

[[*]n]sd   # Here we store a macro in register d to print 1 * without a newline

[dsi[li0!=dli1-dsi0!=L]sLlLx]sl # Store the "less than" case, a for loop which
                        # uses the top-of the stack as it's number of iterations.
[10si[li0!=dli1-dsi0!=L]sLlLx]sg # Store the "greater than" case. It's the above,
                        # but it puts 10 on the stack to use instead.

[1+]sa # Store a macro to add 1 to whatever is the top-of-stack.


10k # Set precision at non-zero to allow decimal division

/ 700 / 10 * # Divide the top two of the stack, v/a; then divide by 700, and multiply by 10
             # dc is postfix and stack-based, so operators come after operands.

0k1~0!=a     # This is a ceiling function.
|> 0k  # set precision to 0 to perform integer division
|> 1~  # push the quotient of integer division by 1, and then the remainder. (r is top)
|> 0!=a # If the top-of-stack (decimal part) is not 0, add 1 to the quotient

d10>ld10!>g # Conditional statement
|> d10>l  # (d)uplicate the top, push 10 on. If 10 > the old top, execute the `l`ess-than
          # case, which loops top-of-stack times.
|> d10!>g # Complement of the above, using the `g`reater-than to loop 10 times.

[]p # print a newline

dc, 110 108 bytes

[[*]n]sd[dsi[li0!=dli1-dsi0!=L]dsLx]sl[10si[li0!=dli1-dsi0!=L]dsLx]sg[1+]sa10k/700/10*0k1~0!=ad10>ld10!>g[]p

echo 'v a (above)'|dc
# Wholly:
>> echo '163 2 [[*]n]sd[dsi[li0!=dli1-dsi0!=L]dsLx]sl[10si[li0!=dli1-dsi0!=L]dsLx]sg[1+]sa10k/700/10*0k1~0!=ad10>ld10!>g[]p'|dc
# outputs:
**
>> 

[[*]n]sd   # Here we store a macro in register d to print 1 * without a newline

[dsi[li0!=dli1-dsi0!=L]dsLx]sl # Store the "less than" case, a for loop which
                        # uses the top-of the stack as it's number of iterations.
[10si[li0!=dli1-dsi0!=L]dsLx]sg # Store the "greater than" case. It's the above,
                        # but it puts 10 on the stack to use instead.

[1+]sa # Store a macro to add 1 to whatever is the top-of-stack.


10k # Set precision at non-zero to allow decimal division

/ 700 / 10 * # Divide the top two of the stack, v/a; then divide by 700, and multiply by 10
             # dc is postfix and stack-based, so operators come after operands.

0k1~0!=a     # This is a ceiling function.
|> 0k  # set precision to 0 to perform integer division
|> 1~  # push the quotient of integer division by 1, and then the remainder. (r is top)
|> 0!=a # If the top-of-stack (decimal part) is not 0, add 1 to the quotient

d10>ld10!>g # Conditional statement
|> d10>l  # (d)uplicate the top, push 10 on. If 10 > the old top, execute the `l`ess-than
          # case, which loops top-of-stack times.
|> d10!>g # Complement of the above, using the `g`reater-than to loop 10 times.

[]p # print a newline

• 2 bytes saved by duplicating-saving instead of saving-loading