// The algorithm needs O((M+N)*log(M)) calls to data.Swap.
//
// The paper gives O((M+N)*log(M)) as the number of assignments assuming a
// rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
// in the paper carries through for Swap operations, especially as the block
// swapping rotate uses only O(M+N) Swaps.
//
// symMerge assumes non-degenerate arguments: a < m && m < b.

// The algorithm needs O((M+N)*log(M)) calls to data.Swap.
//
// The paper gives O((M+N)*log(M)) as the number of assignments assuming a
// rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
// in the paper carries through for Swap operations, especially as the block
// swapping rotate uses only O(M+N) Swaps.
//
// symMerge assumes non-degenerate arguments: a < m && m < b.

// The algorithm needs O((M+N)*log(M)) calls to data.Swap.
//
// The paper gives O((M+N)*log(M)) as the number of assignments assuming a
// rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
// in the paper carries through for Swap operations, especially as the block
// swapping rotate uses only O(M+N) Swaps.
//
// symMerge assumes non-degenerate arguments: a < m && m < b.

          align_corners ? output_spatial - 1 : output_spatial;

      int64_t gcd =
          tensorflow::MathUtil::GCD(static_cast<uint64_t>(input_spatial_size),
                                    static_cast<uint64_t>(output_spatial_size));
      if ((input_spatial_size % gcd != 0) ||
          (input_spatial_size / gcd != stride) || (dilation - 1 != padding)) {
        return false;
      }

      return true;

				delete(m, i)
			}
			growflag = false
		} else {
			if k&1 == 1 {
				t.Error("odd value returned")
			}
		}
	}
}

// make sure old bucket arrays don't get GCd while
// an iterator is still using them.
func TestIterGrowWithGC(t *testing.T) {
	m := make(map[int]int, 4)
	for i := 0; i < 8; i++ {
		m[i] = i
	}
	for i := 8; i < 16; i++ {
		m[i] += i
	}

	count uint32
	pos   uint32
	inc   uint32
}

func (ord *randomOrder) reset(count uint32) {
	ord.count = count
	ord.coprimes = ord.coprimes[:0]
	for i := uint32(1); i <= count; i++ {
		if gcd(i, count) == 1 {
			ord.coprimes = append(ord.coprimes, i)
		}
	}
}

func (ord *randomOrder) start(i uint32) randomEnum {
	return randomEnum{
		count: ord.count,
		pos:   i % ord.count,

		{"(*Int).Div", Method, 0},
		{"(*Int).DivMod", Method, 0},
		{"(*Int).Exp", Method, 0},
		{"(*Int).FillBytes", Method, 15},
		{"(*Int).Float64", Method, 21},
		{"(*Int).Format", Method, 0},
		{"(*Int).GCD", Method, 0},
		{"(*Int).GobDecode", Method, 0},
		{"(*Int).GobEncode", Method, 0},
		{"(*Int).Int64", Method, 0},
		{"(*Int).IsInt64", Method, 9},
		{"(*Int).IsUint64", Method, 9},
		{"(*Int).Lsh", Method, 0},

pkg math/big, method (*Int) DivMod(*Int, *Int, *Int) (*Int, *Int)
pkg math/big, method (*Int) Exp(*Int, *Int, *Int) *Int
pkg math/big, method (*Int) Format(fmt.State, int32)
pkg math/big, method (*Int) GCD(*Int, *Int, *Int, *Int) *Int
pkg math/big, method (*Int) GobDecode([]uint8) error
pkg math/big, method (*Int) GobEncode() ([]uint8, error)
pkg math/big, method (*Int) Int64() int64