Move spaces from before comments to within comments

tests/corelib_strong/int_modulo_arith_test.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
 
 import "dart:math" show pow;
 
-var smallNumber = 1234567890;   // is 31-bit integer.
+var smallNumber = 1234567890; //   is 31-bit integer.
 var mediumNumber = 1234567890123456;  // is 53-bit integer
 var bigNumber = 590295810358705600000;  // is > 64-bit integer, exact as double.
 
 testModPow() {
   test(x, e, m, expectedResult) {
     // Check that expected result is correct, using an unoptimized version.
     assert(() {
       if (1 is double) return true;  // Don't have bignums.
       slowModPow(x, e, m) {
         var r = 1;
@@ skipping 91 matching lines @@
   test(19, 1234567890, 519818059);
   test(1000000001, 1234567890, 1001100101);
 
   test(12345, 12346, 12345);
   test(12345, 12346, 12345);
 
   test(smallNumber, 137, 42);
   test(137, smallNumber, 856087223);
   test(mediumNumber, 137, 77);
   test(137, mediumNumber, 540686667207353);
-  test(bigNumber, 137, 128);                  /// bignum: ok
+  test(bigNumber, 137, 128); //               /// bignum: ok
   // Bigger numbers as modulo is tested in big_integer_arith_vm_test.dart.
   // Big doubles are not co-prime, so there is nothing to test for dart2js.
 }
 
 testGcd() {
   // Call testFunc with all combinations and orders of plus/minus
   // value and other.
   callCombos(value, other, testFunc) {
     testFunc(value, other);
     testFunc(value, -other);
@@ skipping 30 matching lines @@
     callCombos(value, other, (a, b) {
       Expect.throws(() => a.gcd(b), null, "$a.gcd($b)");
     });
   }
 
   testThrows(2.5, 5);  // Not a method on double.
   testThrows(5, 2.5);  // Not accepting non-int arguments.
 
   // Format:
   //  test(value1, value2, expectedResult);
-  test(1, 1, 1);     // both are 1
-  test(1, 2, 1);     // one is 1
-  test(3, 5, 1);     // coprime.
+  test(1, 1, 1); //     both are 1
+  test(1, 2, 1); //     one is 1
+  test(3, 5, 1); //     coprime.
   test(37, 37, 37);  // Same larger prime.
 
   test(9999, 7272, 909);  // Larger numbers
 
   test(0, 1000, 1000);  // One operand is zero.
-  test(0, 0, 0);        // Both operands are zero.
+  test(0, 0, 0); //        Both operands are zero.
 
   // Multiplying both operands by a number multiplies result by same number.
   test(693, 609, 21);
   test(693 << 5, 609 << 5, 21 << 5);
   test(693 * 937, 609 * 937, 21 * 937);
   test(693 * pow(2, 32), 609 * pow(2, 32), 21 * pow(2, 32));
   test(693 * pow(2, 52), 609 * pow(2, 52), 21 * pow(2, 52));
   test(693 * pow(2, 53), 609 * pow(2, 53), 21 * pow(2, 53));  // Regression.
   test(693 * pow(2, 99), 609 * pow(2, 99), 21 * pow(2, 99));
 
@@ skipping 10 matching lines @@
        (pow(2, 26) - 1) * pow(2, 22),
        (pow(2, 26) - 1) * pow(2, 14));
 }
 
 main() {
   testModPow();  /// modPow: ok
   testModInverse();
   testGcd();
 }