"macedonia":                            "\U0001f1f2\U0001f1f0",
	"madagascar":                           "\U0001f1f2\U0001f1ec",
	"mag":                                  "\U0001f50d",
	"mag_right":                            "\U0001f50e",
	"mage":                                 "\U0001f9d9",
	"mage_man":                             "\U0001f9d9\u200d\u2642\ufe0f",

    t.mapLeft { it + 1 }.right == "a"
    t.mapRight { it * 2 }.left == 1
    t.mapRight { it * 2 }.right == "aa"

    t.nestLeft(2).mapLeft(unpackLeft()).left == 2
    t.nestLeft(2).mapLeft(unpackRight()).left == 1
    t.nestLeft(2).mapLeft(unpackLeft()).right == "a"
    t.nestLeft(2).mapLeft(unpackRight()).right == "a"
    t.nestRight(2).mapRight(unpackLeft()).right == 2
    t.nestRight(2).mapRight(unpackRight()).right == "a"

    /**
     * Map the left side.
     *
     * @see #mapRight
     * @see #fold
     */
    public abstract <U, V> Either<U, V> mapLeft(Function<? super L, ? extends U> f);

    /**
     * Map the right side.
     *
     * @see #mapLeft
     * @see #fold
     */
    public abstract <U, V> Either<U, V> mapRight(Function<? super R, ? extends V> f);

    /**

    const int remaining_right = pool.w_in - ((pool.w_out - 1) * pool.sw);
    const int ceil_pad_right = pool.kw - remaining_right;
    pad_right = ceil_pad_right - pool.pw;
  }

  return {pool.ph, pad_bottom, pool.pw, pad_right};
}

DenseIntElementsAttr GetPadOpAttr(Builder& builder, CompositeOp op) {
  const TorchAvgPoolData pool = GetTorchAvgPoolData(op);

  const auto values = GetPadOpPaddingValues(pool);

        right.right.get() == RIGHT
    }

    def "map() works"() {
        expect:
        left.mapLeft({ assert it == LEFT; LEFT2 }).left.get() == LEFT2
        left.mapRight({ assert false }).left.get() == LEFT

        right.mapRight({ assert it == RIGHT; RIGHT2 }).right.get() == RIGHT2
        right.mapLeft({ assert false }).right.get() == RIGHT
    }

    def "fold() subsumes flatMap()"() {
        expect:

    }

    public <T> Pair<T, R> mapLeft(Function<? super L, ? extends T> function) throws Exception {
        return of(function.apply(left), right);
    }

    public <T> Pair<L, T> mapRight(Function<? super R, ? extends T> function) throws Exception {
        return of(left, function.apply(right));
    }

    @Nullable
    public <T> T map(Function<? super Pair<L, R>, ? extends T> function) throws Exception {

#endif
#ifndef REG_NOTBOL
#define REG_NOTBOL	NOTEST
#endif
#ifndef REG_NOTEOL
#define REG_NOTEOL	NOTEST
#endif
#ifndef REG_NULL
#define REG_NULL	NOTEST
#endif
#ifndef REG_RIGHT
#define REG_RIGHT	NOTEST
#endif
#ifndef REG_SHELL_DOT
#define REG_SHELL_DOT	NOTEST
#endif
#ifndef REG_SHELL_ESCAPED
#define REG_SHELL_ESCAPED	NOTEST
#endif
#ifndef REG_SHELL_GROUP

		//     A	REG_AUGMENTED		ARE	(egrep with negation)
		//     S	REG_SHELL		SRE	(sh glob)
		//     K	REG_SHELL|REG_AUGMENTED	KRE	(ksh glob)
		//     L	REG_LITERAL		LRE	(fgrep)
		//
		//     a	REG_LEFT|REG_RIGHT	implicit ^...$
		//     b	REG_NOTBOL		lhs does not match ^
		//     c	REG_COMMENT		ignore space and #...\n
		//     d	REG_SHELL_DOT		explicit leading . match
		//     e	REG_NOTEOL		rhs does not match $

	MB_HELP                 = 0x00004000
	MB_NOFOCUS              = 0x00008000
	MB_SETFOREGROUND        = 0x00010000
	MB_DEFAULT_DESKTOP_ONLY = 0x00020000
	MB_TOPMOST              = 0x00040000
	MB_RIGHT                = 0x00080000
	MB_RTLREADING           = 0x00100000
	MB_SERVICE_NOTIFICATION = 0x00200000
)

const (
	MOVEFILE_REPLACE_EXISTING      = 0x1
	MOVEFILE_COPY_ALLOWED          = 0x2

      paddings = [[pad_top, pad_bottom], [pad_left, pad_right]]

  The effective spatial dimensions of the zero-padded input tensor will be:

      height_pad = pad_top + height + pad_bottom
      width_pad = pad_left + width + pad_right}]>:$paddings,

    ConfinedAttr<I64Attr, [IntMinValue<2>]>:$block_size
  );

  let results = (outs