```go
package main
import (
"fmt"
"sort"
)
func main() {
var s, t string
fmt.Scan(&s)
fmt.Scan(&t)
n := len(s)
// Sort Oleg's letters ascending (he wants lex smallest, so he'll place small letters at front, large letters at back)
// Sort Igor's letters descending (he wants lex largest, so he'll place large letters at front, small letters at back)
oleg := []byte(s)
igor := []byte(t)
sort.Slice(oleg, func(i, j int) bool { return oleg[i] < oleg[j] })
sort.Slice(igor, func(i, j int) bool { return igor[i] > igor[j] })
result := make([]byte, n)
// We use two pointers: left (for placing at the front) and right (for placing at the back)
left := 0
right := n - 1
olegLeft := 0
olegRight := len(oleg) - 1
igorLeft := 0
igorRight := len(igor) - 1
// Total moves: n moves, Oleg goes first
// Oleg makes ceil(n/2) moves, Igor makes floor(n/2) moves
// They alternate: Oleg, Igor, Oleg, Igor, ...
for i := 0; i < n; i++ {
if i%2 == 0 {
// Oleg's turn - wants lex smallest
// Strategy: if his best letter (smallest) is smaller than Igor's best letter (largest),
// place it at the front (leftmost position)
// Otherwise, place his largest letter at the back (rightmost position)
// to minimize damage
if oleg[olegLeft] < igor[igorLeft] {
// Place smallest oleg letter at front
result[left] = oleg[olegLeft]
olegLeft++
left++
} else {
// Place largest oleg letter at back
result[right] = oleg[olegRight]
olegRight--
right--
}
} else {
// Igor's turn - wants lex largest
// Strategy: if his best letter (largest) is larger than Oleg's best letter (smallest),
// place it at the front (leftmost position)
// Otherwise, place his smallest letter at the back (rightmost position)
if igor[igorLeft] > oleg[olegLeft] {
// Place largest igor letter at front
result[left] = igor[igorLeft]
igorLeft++
left++
} else {
// Place smallest igor letter at back
result[right] = igor[igorRight]
igorRight--
right--
}
}
}
fmt.Println(string(result))
}
```