Passed Pawn Move Generation

[Edsel Apostol]

Generating a certain kind of move is much faster in my engine than when I just generate all moves and then filter them through the move loop according to its certain criteria. I have move generators for tactical moves, non tactical moves, non tactical checks, and legal evasion. I'm planning to add a passed move move generation.

What would be the best way to generate passed pawn moves? Take note that it must not be a tactical move, that means it shouldn't include captures, promotions and checks. Here is my first try, though I have not tested it yet.

Code: Select all

/* returns a bitboard with all bits above b filled up (including b) */
uint64 fillUp2(uint64 b) {
    b |= b << 8;
    b |= b << 16;
    return (b | (b << 32));
}

/* returns a bitboard with all bits below b filled down (including b) */
uint64 fillDown2(uint64 b) {
    b |= b >> 8;
    b |= b >> 16;
    return (b | (b >> 32));
}

// shift the parameter b with i places to the left
uint64 shiftLeft(uint64 b, uint32 i) {return (b << i);}

// shift the parameter b with i places to the right
uint64 shiftRight(uint64 b, uint32 i) {return (b >> i);}

static uint64 (*FillPtr2[])(uint64) = {&fillUp2, &fillDown2};
static uint64 (*ShiftPtr[])(uint64, uint32) = {&shiftLeft, &shiftRight};

/* this generates non tactical non checking passed pawn moves only */
void genPassedPawnMoves(const position_t *pos, sort_t *sort) {
    static const int Shift[] = {9, 7};
    uint64 pc_bits, mv_bits, pawns, xpawns, mask, dcc;
    int from, to;

    ASSERT(pos != NULL);
    ASSERT(sort != NULL);

    sort->size = 0;
    pawns = pos->pawns & pos->color[pos->side];
    xpawns = pos->pawns & pos->color[pos->side^1];
    dcc = discoveredCheckCandidates(pos, pos->side);
    mask = (~Rank8ByColorBB[pos->side] & ~((*FillPtr2[pos->side^1])((*ShiftPtr[pos->side^1])(pos->pawns, 8))))
        & ~(((*ShiftPtr[pos->side^1])(xpawns, Shift[pos->side^1]) & ~FileABB)
        | ((*ShiftPtr[pos->side^1])(xpawns, Shift[pos->side]) & ~FileHBB))
        & ~PawnCaps[pos->kpos[pos->side^1]][pos->side^1];

    mv_bits = (*ShiftPtr[pos->side])(pawns, 8) & mask;
    while (mv_bits) {
        to = popFirstBit(&mv_bits);
        pc_bits = (PawnMoves[to][pos->side^1] & pawns) & ~dcc;
        while (pc_bits) {
            from = popFirstBit(&pc_bits);
            sort->list[sort->size++].m = GenOneForward(from, to);
        }
    }
    mv_bits = (*ShiftPtr[pos->side])(pawns, 16) & Rank4ByColorBB[pos->side] & mask
    & ((*ShiftPtr[pos->side])(~pos->occupied, 8) & (*ShiftPtr[pos->side])(~pos->occupied, 16));
    while (mv_bits) {
        to = popFirstBit(&mv_bits);
        pc_bits = pawns & Rank2ByColorBB[pos->side] & ~dcc;
        while (pc_bits) {
            from = popFirstBit(&pc_bits);
            sort->list[sort->size++].m = GenTwoForward(from, to);
        }
    }
}

Any tips on how to optimize this? How would you do it if you we're to do such a move generator?

P.S. A1 = 0, H8 = 63, WHITE = 0, BLACK = 1
P.S.2 I'm using the sides color as index to Shift pointer as LEFT = 0 and RIGHT = 1 as they directly corresponds to WHITE and BLACK

[Edsel Apostol]

Correction:

Code: Select all

pc_bits = pawns & Rank2ByColorBB[pos->side] & ~dcc;

should be this:

Code: Select all

pc_bits = pawns & Rank2ByColorBB[pos->side] & FileMask[to] & ~dcc;

[Gerd Isenberg]

Generating a certain kind of move is much faster in my engine than when I just generate all moves and then filter them through the move loop according to its certain criteria. I have move generators for tactical moves, non tactical moves, non tactical checks, and legal evasion. I'm planning to add a passed move move generation.

What would be the best way to generate passed pawn moves? Take note that it must not be a tactical move, that means it shouldn't include captures, promotions and checks. Here is my first try, though I have not tested it yet.

Code: Select all

/* returns a bitboard with all bits above b filled up (including b) */
uint64 fillUp2(uint64 b) {
    b |= b << 8;
    b |= b << 16;
    return (b | (b << 32));
}

/* returns a bitboard with all bits below b filled down (including b) */
uint64 fillDown2(uint64 b) {
    b |= b >> 8;
    b |= b >> 16;
    return (b | (b >> 32));
}

// shift the parameter b with i places to the left
uint64 shiftLeft(uint64 b, uint32 i) {return (b << i);}

// shift the parameter b with i places to the right
uint64 shiftRight(uint64 b, uint32 i) {return (b >> i);}

static uint64 (*FillPtr2[])(uint64) = {&fillUp2, &fillDown2};
static uint64 (*ShiftPtr[])(uint64, uint32) = {&shiftLeft, &shiftRight};

/* this generates non tactical non checking passed pawn moves only */
void genPassedPawnMoves(const position_t *pos, sort_t *sort) {
    static const int Shift[] = {9, 7};
    uint64 pc_bits, mv_bits, pawns, xpawns, mask, dcc;
    int from, to;

    ASSERT(pos != NULL);
    ASSERT(sort != NULL);

    sort->size = 0;
    pawns = pos->pawns & pos->color[pos->side];
    xpawns = pos->pawns & pos->color[pos->side^1];
    dcc = discoveredCheckCandidates(pos, pos->side);
    mask = (~Rank8ByColorBB[pos->side] & ~((*FillPtr2[pos->side^1])((*ShiftPtr[pos->side^1])(pos->pawns, 8))))
        & ~(((*ShiftPtr[pos->side^1])(xpawns, Shift[pos->side^1]) & ~FileABB)
        | ((*ShiftPtr[pos->side^1])(xpawns, Shift[pos->side]) & ~FileHBB))
        & ~PawnCaps[pos->kpos[pos->side^1]][pos->side^1];

    mv_bits = (*ShiftPtr[pos->side])(pawns, 8) & mask;
    while (mv_bits) {
        to = popFirstBit(&mv_bits);
        pc_bits = (PawnMoves[to][pos->side^1] & pawns) & ~dcc;
        while (pc_bits) {
            from = popFirstBit(&pc_bits);
            sort->list[sort->size++].m = GenOneForward(from, to);
        }
    }
    mv_bits = (*ShiftPtr[pos->side])(pawns, 16) & Rank4ByColorBB[pos->side] & mask
    & ((*ShiftPtr[pos->side])(~pos->occupied, 8) & (*ShiftPtr[pos->side])(~pos->occupied, 16));
    while (mv_bits) {
        to = popFirstBit(&mv_bits);
        pc_bits = pawns & Rank2ByColorBB[pos->side] & ~dcc;
        while (pc_bits) {
            from = popFirstBit(&pc_bits);
            sort->list[sort->size++].m = GenTwoForward(from, to);
        }
    }
}

Any tips on how to optimize this? How would you do it if you we're to do such a move generator?

P.S. A1 = 0, H8 = 63, WHITE = 0, BLACK = 1
P.S.2 I'm using the sides color as index to Shift pointer as LEFT = 0 and RIGHT = 1 as they directly corresponds to WHITE and BLACK

In a staged MG I would probably do it target rankwise (only rank 7, 6, 5). Then you may even unroll the serialization loops of those rank-sets (usually empty or very low populated), by using a target rank (byte) as index to address a pre-calculated move-list.

[mcostalba]

Below is the case for a single color only (side to move == WHITE), I am not a fan of function pointers to handle color asymmetry.

Not tested.

It is not clear if with "passed pawn moves" you mean moves of pawns that are already passed, move of a non passed pawn that make the pawn become passed, or a union of the boths.

In my example I will consider the last case that is the most correct IMHO.

Code: Select all

/* returns a bitboard with all bits above b filled up (EXCLUDING b) */
uint64 fillDown2(uint64 b) {
    b >>= 8;
    b |= b >> 8;
    b |= b >> 16;
    return (b | (b >> 32));
} 


pawns = pos->pawns & pos->color[pos->side];
xpawns = pos->pawns & pos->color[pos->side^1];
dcc = discoveredCheckCandidates(pos, pos->side);

// After the move a passed pawn must not be in the mask area
mask = fillDown2(xpawns);
mask |= ((mask >> 1) & ~FileABB) | ((mask << 1) & ~FileHBB);

// Pawn pushes
pawns &= ~dcc;
single_push_pawns = (pawns >> 8) & ~pos->occupied;
double_push_pawns = (single_push_pawns >> 8) & ~pos->occupied & ~mask & Rank4ByColorBB[pos->side];
single_push_pawns &= ~mask;

// Pawn that are passed or became passed with a single push
mv_single_bits = single_push_pawns << 8;

// The same but for double push
mv_double_bits = double_push_pawns << 16;


...then serialize mv_bits as usual

BTW are you sure your code checks the single push in non occupied squares only ?

[Edsel Apostol]

Below is the case for a single color only (side to move == WHITE), I am not a fan of function pointers to handle color asymmetry.

Not tested.

It is not clear if with "passed pawn moves" you mean moves of pawns that are already passed, move of a non passed pawn that make the pawn become passed, or a union of the boths.

In my example I will consider the last case that is the most correct IMHO.

Code: Select all

/* returns a bitboard with all bits above b filled up (EXCLUDING b) */
uint64 fillDown2(uint64 b) {
    b >>= 8;
    b |= b >> 8;
    b |= b >> 16;
    return (b | (b >> 32));
} 


pawns = pos->pawns & pos->color[pos->side];
xpawns = pos->pawns & pos->color[pos->side^1];
dcc = discoveredCheckCandidates(pos, pos->side);

// After the move a passed pawn must not be in the mask area
mask = fillDown2(xpawns);
mask |= ((mask >> 1) & ~FileABB) | ((mask << 1) & ~FileHBB);

// Pawn pushes
pawns &= ~dcc;
single_push_pawns = (pawns >> 8) & ~pos->occupied;
double_push_pawns = (single_push_pawns >> 8) & ~pos->occupied & ~mask & Rank4ByColorBB[pos->side];
single_push_pawns &= ~mask;

// Pawn that are passed or became passed with a single push
mv_single_bits = single_push_pawns << 8;

// The same but for double push
mv_double_bits = double_push_pawns << 16;


...then serialize mv_bits as usual

BTW are you sure your code checks the single push in non occupied squares only ?

Hi Marco,

Yes, I mean the last case, where the to square must be considered as passed, so it doesn't matter if it already is a passed pawn before moving or not.

And yes, my single push is not correct as it might push into non pawns. I assumed that my mask is already not occupied by pieces.

By the way, you're code I think is for black as my A1 is 0 and H8 is 63. I am also not sure but I think that your code will fail if there is a doubled pawn in a file, in that case only the pawn ahead is a passed pawn and the one behind it is not. It also doesn't take into consideration if the move will give direct check.

I'm planning to use this move generation in conjunction with tactical and checking moves and I don't want it to generate moves identical to what is generated by those mentioned.

Your code give me ideas, I will improve on that. I will post it here later.

[Edsel Apostol]

Generating a certain kind of move is much faster in my engine than when I just generate all moves and then filter them through the move loop according to its certain criteria. I have move generators for tactical moves, non tactical moves, non tactical checks, and legal evasion. I'm planning to add a passed move move generation.

What would be the best way to generate passed pawn moves? Take note that it must not be a tactical move, that means it shouldn't include captures, promotions and checks. Here is my first try, though I have not tested it yet.

Code: Select all

/* returns a bitboard with all bits above b filled up (including b) */
uint64 fillUp2(uint64 b) {
    b |= b << 8;
    b |= b << 16;
    return (b | (b << 32));
}

/* returns a bitboard with all bits below b filled down (including b) */
uint64 fillDown2(uint64 b) {
    b |= b >> 8;
    b |= b >> 16;
    return (b | (b >> 32));
}

// shift the parameter b with i places to the left
uint64 shiftLeft(uint64 b, uint32 i) {return (b << i);}

// shift the parameter b with i places to the right
uint64 shiftRight(uint64 b, uint32 i) {return (b >> i);}

static uint64 (*FillPtr2[])(uint64) = {&fillUp2, &fillDown2};
static uint64 (*ShiftPtr[])(uint64, uint32) = {&shiftLeft, &shiftRight};

/* this generates non tactical non checking passed pawn moves only */
void genPassedPawnMoves(const position_t *pos, sort_t *sort) {
    static const int Shift[] = {9, 7};
    uint64 pc_bits, mv_bits, pawns, xpawns, mask, dcc;
    int from, to;

    ASSERT(pos != NULL);
    ASSERT(sort != NULL);

    sort->size = 0;
    pawns = pos->pawns & pos->color[pos->side];
    xpawns = pos->pawns & pos->color[pos->side^1];
    dcc = discoveredCheckCandidates(pos, pos->side);
    mask = (~Rank8ByColorBB[pos->side] & ~((*FillPtr2[pos->side^1])((*ShiftPtr[pos->side^1])(pos->pawns, 8))))
        & ~(((*ShiftPtr[pos->side^1])(xpawns, Shift[pos->side^1]) & ~FileABB)
        | ((*ShiftPtr[pos->side^1])(xpawns, Shift[pos->side]) & ~FileHBB))
        & ~PawnCaps[pos->kpos[pos->side^1]][pos->side^1];

    mv_bits = (*ShiftPtr[pos->side])(pawns, 8) & mask;
    while (mv_bits) {
        to = popFirstBit(&mv_bits);
        pc_bits = (PawnMoves[to][pos->side^1] & pawns) & ~dcc;
        while (pc_bits) {
            from = popFirstBit(&pc_bits);
            sort->list[sort->size++].m = GenOneForward(from, to);
        }
    }
    mv_bits = (*ShiftPtr[pos->side])(pawns, 16) & Rank4ByColorBB[pos->side] & mask
    & ((*ShiftPtr[pos->side])(~pos->occupied, 8) & (*ShiftPtr[pos->side])(~pos->occupied, 16));
    while (mv_bits) {
        to = popFirstBit(&mv_bits);
        pc_bits = pawns & Rank2ByColorBB[pos->side] & ~dcc;
        while (pc_bits) {
            from = popFirstBit(&pc_bits);
            sort->list[sort->size++].m = GenTwoForward(from, to);
        }
    }
}

Any tips on how to optimize this? How would you do it if you we're to do such a move generator?

P.S. A1 = 0, H8 = 63, WHITE = 0, BLACK = 1
P.S.2 I'm using the sides color as index to Shift pointer as LEFT = 0 and RIGHT = 1 as they directly corresponds to WHITE and BLACK

In a staged MG I would probably do it target rankwise (only rank 7, 6, 5). Then you may even unroll the serialization loops of those rank-sets (usually empty or very low populated), by using a target rank (byte) as index to address a pre-calculated move-list.

Hi Gerd,

Can you give a pseudo code for this. I can't seem to grasp the idea from your description.

[Gerd Isenberg]

Hi Gerd,

Can you give a pseudo code for this. I can't seem to grasp the idea from your description.

Hi Edsel,
for instance white pawns to the seventh rank, where you even don't need to consider sentries:

Code: Select all

pawnPushTargets7thRank = (whitePawns << 8) & emptySquares & 0x00ff000000000000;
unsigned index = pawnPushTargets7thRank >> 48;
movecpy (movelist, precalcpawnPushes[rank7][index ].moves, precalcpawnPushes[rank7][index ].nmoves);

[mcostalba]

By the way, you're code I think is for black as my A1 is 0 and H8 is 63. I am also not sure but I think that your code will fail if there is a doubled pawn in a file, in that case only the pawn ahead is a passed pawn and the one behind it is not. It also doesn't take into consideration if the move will give direct check.

Yes you are correct, this should be ok.

Code: Select all

/* returns a bitboard with all bits above b filled up (EXCLUDING b) */
uint64 fillDown2(uint64 b) {
    b >>= 8;
    b |= b >> 8;
    b |= b >> 16;
    return (b | (b >> 32));
}


pawns = pos->pawns & pos->color[pos->side];
xpawns = pos->pawns & pos->color[pos->side^1];
dcc = discoveredCheckCandidates(pos, pos->side);

// In case of two pawns in the same file consider only
// the more advanced as passed.
pawns &= ~fillDown2(pawns);

// After the move a passed pawn must not be in the mask area.
// We don't want direct check moves.
mask = fillDown2(xpawns) | (kposBB >> 8);
mask |= ((mask >> 1) & ~FileABB) | ((mask << 1) & ~FileHBB);
mask &= ~(kposBB >> 8);

// Pawn pushes
pawns &= ~dcc;
single_push_pawns = (pawns >> 8) & ~pos->occupied;
double_push_pawns = (single_push_pawns >> 8) & ~pos->occupied & ~mask & Rank4ByColorBB[pos->side];
single_push_pawns &= ~mask;

// Pawn that are passed or became passed with a single push
mv_single_bits = single_push_pawns << 8;

// The same but for double push
mv_double_bits = double_push_pawns << 16;


...then serialize mv_bits as usual 

[mcostalba]

Well, my previous version was almost correct it had a very very small bug !

Hope this is teh final one:

Code: Select all

/* returns a bitboard with all bits below b filled up (EXCLUDING b) */
uint64 fillDown2(uint64 b) {
    b >>= 8;
    b |= b >> 8;
    b |= b >> 16;
    return (b | (b >> 32));
}


pawns = pos->pawns & pos->color[pos->side];
xpawns = pos->pawns & pos->color[pos->side^1];
dcc = discoveredCheckCandidates(pos, pos->side);

// In case of two pawns in the same file consider only the ahead one
pawns &= ~fillDown2(pawns);

// Build up the after-move mask area. We don't want direct check moves.
kchecks = kposBB >> 8;
mask = fillDown2(xpawns);
mask |= ((mask >> 1) & ~FileABB) | ((mask << 1) & ~FileHBB);
mask |= ((kchecks >> 1) & ~FileABB) | ((kchecks << 1) & ~FileHBB);

// Pawn pushes
pawns &= ~dcc;
single_push_pawns = (pawns >> 8) & ~pos->occupied;
double_push_pawns = (single_push_pawns >> 8) & ~pos->occupied & ~mask & Rank4ByColorBB[pos->side];
single_push_pawns &= ~mask;

// Pawn that are passed or became passed with a single push
mv_single_bits = single_push_pawns << 8;

// The same but for double push
mv_double_bits = double_push_pawns << 16;


...then serialize mv_bits as usual 

[Edsel Apostol]

Thanks Marco. I almost didn't notice it. That last code wouldn't generate a passed pawn if there is an enemy king in front of it. This last one seems correct.

Well, my previous version was almost correct it had a very very small bug !

Hope this is teh final one:

Code: Select all

/* returns a bitboard with all bits below b filled up (EXCLUDING b) */
uint64 fillDown2(uint64 b) {
    b >>= 8;
    b |= b >> 8;
    b |= b >> 16;
    return (b | (b >> 32));
}


pawns = pos->pawns & pos->color[pos->side];
xpawns = pos->pawns & pos->color[pos->side^1];
dcc = discoveredCheckCandidates(pos, pos->side);

// In case of two pawns in the same file consider only the ahead one
pawns &= ~fillDown2(pawns);

// Build up the after-move mask area. We don't want direct check moves.
kchecks = kposBB >> 8;
mask = fillDown2(xpawns);
mask |= ((mask >> 1) & ~FileABB) | ((mask << 1) & ~FileHBB);
mask |= ((kchecks >> 1) & ~FileABB) | ((kchecks << 1) & ~FileHBB);

// Pawn pushes
pawns &= ~dcc;
single_push_pawns = (pawns >> 8) & ~pos->occupied;
double_push_pawns = (single_push_pawns >> 8) & ~pos->occupied & ~mask & Rank4ByColorBB[pos->side];
single_push_pawns &= ~mask;

// Pawn that are passed or became passed with a single push
mv_single_bits = single_push_pawns << 8;

// The same but for double push
mv_double_bits = double_push_pawns << 16;


...then serialize mv_bits as usual 

By the way, here's my corrected version:

Code: Select all

/* this generates non tactical non checking passed pawn moves only */
void genPassedPawnMoves(const position_t *pos, sort_t *sort) {
    static const int Shift[] = {9, 7};
    uint64 pc_bits, mv_bits, pawns, xpawns, mask, dcc;
    int from, to;

    ASSERT(pos != NULL);
    ASSERT(sort != NULL);

    sort->size = 0;
    pawns = pos->pawns & pos->color[pos->side];
    xpawns = pos->pawns & pos->color[pos->side^1];
    dcc = discoveredCheckCandidates(pos, pos->side);
    mask = Rank8ByColorBB[pos->side] & ((*FillPtr2[pos->side^1])((*ShiftPtr[pos->side^1])(pos->pawns, 8)))
        & (*FillPtr[pos->side^1])(((*ShiftPtr[pos->side^1])(xpawns, Shift[pos->side^1]) & ~FileABB)
        | ((*ShiftPtr[pos->side^1])(xpawns, Shift[pos->side]) & ~FileHBB))
        & PawnCaps[pos->kpos[pos->side^1]][pos->side^1];

    mv_bits = (*ShiftPtr[pos->side])(pawns, 8) & ~mask & (*ShiftPtr[pos->side])(~pos->occupied, 8);
    while (mv_bits) {
        to = popFirstBit(&mv_bits);
        pc_bits = (PawnMoves[to][pos->side^1] & pawns) & ~dcc;
        while (pc_bits) {
            from = popFirstBit(&pc_bits);
            sort->list[sort->size++].m = GenOneForward(from, to);
        }
    }
    mv_bits = (*ShiftPtr[pos->side])(pawns, 16) & Rank4ByColorBB[pos->side] & ~mask
    & ((*ShiftPtr[pos->side])(~pos->occupied, 8) & (*ShiftPtr[pos->side])(~pos->occupied, 16));
    while (mv_bits) {
        to = popFirstBit(&mv_bits);
        pc_bits = pawns & Rank2ByColorBB[pos->side] & FileMask[to] & ~dcc;
        while (pc_bits) {
            from = popFirstBit(&pc_bits);
            sort->list[sort->size++].m = GenTwoForward(from, to);
        }
    }
}

And here's an equivalent code if for WHITE only:

Code: Select all

    sort->size = 0;
    pawns = pos->pawns & pos->color[pos->side];
    xpawns = pos->pawns & pos->color[pos->side^1];
    dcc = discoveredCheckCandidates(pos, pos->side);
    mask =
        Rank8ByColorBB[pos->side] // do not include promotions
        & fillDown2(pos->pawns >> 8) // it must be on open file
        & fillDown(((xpawns >> 7) & ~FileABB) | ((xpawns >> 9) & ~FileHBB)) // no enemy pawns to attack its way
        & PawnCaps[pos->kpos[pos->side^1]][pos->side^1]; // it must not give check

    mv_bits = (pawns << 8) & ~mask & ~(pos->occupied << 8);
    while (mv_bits) {
        to = popFirstBit(&mv_bits);
        pc_bits = ((BitMask[to] >> 8) & pawns) & ~dcc;
        while (pc_bits) {
            from = popFirstBit(&pc_bits);
            sort->list[sort->size++].m = GenOneForward(from, to);
        }
    }
    mv_bits = (pawns << 16) & Rank4ByColorBB[pos->side] & ~mask & ~(pos->occupied << 8) & ~(pos->occupied << 16);
    while (mv_bits) {
        to = popFirstBit(&mv_bits);
        pc_bits = pawns & Rank2ByColorBB[pos->side] & FileMask[to] & ~dcc;
        while (pc_bits) {
            from = popFirstBit(&pc_bits);
            sort->list[sort->size++].m = GenTwoForward(from, to);
        }
    }

Here's the complete bit utility used:

Code: Select all

/* returns a bitboard with all bits above b filled up (excluding b) */
uint64 fillUp(uint64 b) {
    b |= b << 8;
    b |= b << 16;
    return (b | (b << 32)) << 8;
}

/* returns a bitboard with all bits below b filled down (excluding b) */
uint64 fillDown(uint64 b) {
    b |= b >> 8;
    b |= b >> 16;
    return (b | (b >> 32)) >> 8;
}

/* returns a bitboard with all bits above b filled up (including b) */
uint64 fillUp2(uint64 b) {
    b |= b << 8;
    b |= b << 16;
    return (b | (b << 32));
}

/* returns a bitboard with all bits below b filled down (including b) */
uint64 fillDown2(uint64 b) {
    b |= b >> 8;
    b |= b >> 16;
    return (b | (b >> 32));
}

// shift the parameter b with i places to the left
uint64 shiftLeft(uint64 b, uint32 i) {return (b << i);}

// shift the parameter b with i places to the right
uint64 shiftRight(uint64 b, uint32 i) {return (b >> i);}

static uint64 (*FillPtr[])(uint64) = {&fillUp, &fillDown};
static uint64 (*FillPtr2[])(uint64) = {&fillUp2, &fillDown2};
static uint64 (*ShiftPtr[])(uint64, uint32) = {&shiftLeft, &shiftRight};