jiahuimbzuai/CoQuIR huggingface dataset:
//  [javascript]
var read = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});
var obj;
var inLine = [];
read.on('line', function(input){inLine.push(input);});
read.on('close', function(){
  obj = init(inLine);
  myerr("-----start-----");
  var start = new Date();
  Main();
  var end = new Date() - start;
  myerr("----- end -----");
  myerr("time : " + (end) + "ms");
});
function nextInt(){return myconv(next(),1);} function nextStrArray(){return myconv(next(),2);}
function nextIntArray(){return myconv(next(),4);} function nextCharArray(){return myconv(next(),6);}
function next(){return obj.next();} function hasNext(){return obj.hasNext();}
function init(input){  
  var returnObj = {
    list : input, index : 0, max : input.length,
    hasNext : function(){return (this.index < this.max);},
    next : function(){if(!this.hasNext()){throw "ArrayIndexOutOfBoundsException これ以上ないよ";}else{var returnInput = this.list[this.index];this.index++;return returnInput;}}
  };
  return returnObj;
}
function myout(s){console.log(s);}
function myerr(s){console.error("debug:" + require("util").inspect(s,false,null));}
//[no]要素の扱い。数値型
//不明値、異常時:引数そのまま返す 1:数値へ変換
//2:半角SPで分割 4:半角SPで分割し、数値配列へ
//6:1文字で分割  7:1文字で分割し、数値配列へ
//8:半角SPで結合 9:改行で結合 0:文字なしで結合
function myconv(i,no){try{switch(no){case 1:return parseInt(i);case 2:return i.split(" ");case 4:return i.split(" ").map(Number);case 6:return i.split("");case 7:return i.split("").map(Number);case 8:return i.join(" ");case 9:return i.join("\n");case 0:return i.join("");default:return i;}}catch(e){return i;}}
function Main(){
  var N = nextInt();
  var list = new Array(N);
  var mins = [0];
  for(var i = 0; i < N; i++){
    list[i] = nextInt();
  }
  for(var i = 0; i < N; i++){
    var isOK = false;
    for(var j = 0; j < mins.length; j++){
      if(list[i] > mins[j]){
        mins[j] = list[i];
        isOK = true;
        break;
      }
    }
    if(!isOK){
      mins.push(list[i]);
    }
  }
  myout(mins.length);
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Scan()
	n, _ := strconv.Atoi(sc.Text())

	arr := make([]int, n)
	for i := 0; i < n; i++ {
		sc.Scan()
		arr[i], _ = strconv.Atoi(sc.Text())
	}

	result := make([]int, 0)
	for _, el := range arr {
		if len(result) == 0 || result[len(result)-1] >= el {
			result = append(result, el)
		} else {
			left := 0
			right := len(result)
			for left < right {
				current := (left + right) / 2
				if result[current] < el {
					right = current
				} else {
					left = current + 1
				}
			}

			result[left] = el
		}
	}

	fmt.Println(len(result))
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

const (
	maxBufferSize     = 2000000 // check
	initialBufferSize = 20000
)

func Reverse(a []int) {
	n := len(a)
	for i := 0; i < n/2; i++ {
		a[i], a[n-i-1] = a[n-i-1], a[i]
	}
}

func BinarySearch(a []int, begin, end, target int) (int, int) {
	lb, ub := begin-1, end
	for ub-lb > 1 {
		mid := (lb + ub) / 2
		if a[mid] <= target {
			lb = mid
		} else {
			ub = mid
		}
	}
	return lb, ub
}

func Fill(a []int, value int) {
	for i := 0; i < len(a); i++ {
		a[i] = value
	}
}

func solve() {
	sc := bufio.NewScanner(os.Stdin)
	buffer := make([]byte, initialBufferSize)
	sc.Buffer(buffer, maxBufferSize)

	sc.Scan()
	n, _ := strconv.Atoi(sc.Text())
	a := make([]int, n)
	for i := 0; i < n; i++ {
		sc.Scan()
		a[i], _ = strconv.Atoi(sc.Text())
	}

	Reverse(a)

	b := make([]int, n)
	Fill(b, 1010101010)
	b[0] = a[0]
	for i := 1; i < n; i++ {
		_, ub := BinarySearch(b, 0, n, a[i])
		b[ub] = a[i]
	}

	var ans int
	for i := 0; i < n; i++ {
		if b[i] != 1010101010 {
			ans = i + 1
		}
	}

	fmt.Println(ans)
}

func main() {
	solve()
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

const (
	maxBufferSize     = 2000000 // check
	initialBufferSize = 20000
)

func Reverse(a []int) {
	n := len(a)
	for i := 0; i < n/2; i++ {
		a[i], a[n-i-1] = a[n-i-1], a[i]
	}
}

func BinarySearch(a []int, begin, end, target int) (int, int) {
	lb, ub := begin-1, end-1
	for ub-lb > 1 {
		mid := (lb + ub) / 2
		if a[mid] <= target {
			lb = mid
		} else {
			ub = mid
		}
	}
	return lb, ub
}

func Fill(a []int, value int) {
	for i := 0; i < len(a); i++ {
		a[i] = value
	}
}

func solve() {
	sc := bufio.NewScanner(os.Stdin)
	buffer := make([]byte, initialBufferSize)
	sc.Buffer(buffer, maxBufferSize)

	sc.Scan()
	n, _ := strconv.Atoi(sc.Text())
	a := make([]int, n)
	for i := 0; i < n; i++ {
		sc.Scan()
		a[i], _ = strconv.Atoi(sc.Text())
	}

	Reverse(a)

	b := make([]int, n)
	Fill(b, 1010101010)
	b[0] = a[0]
	for i := 1; i < n; i++ {
		_, ub := BinarySearch(b, 0, n, a[i])
		b[ub] = a[i]
	}

	var ans int
	for i := 0; i < n; i++ {
		if b[i] != 1010101010 {
			ans = i + 1
		}
	}

	fmt.Println(ans)
}

func main() {
	solve()
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func scanInt() int {
	sc.Scan()
	i, err := strconv.Atoi(sc.Text())
	if err != nil {
		panic(err)
	}
	return i
}

func main() {
	sc.Split(bufio.ScanWords)

	N := scanInt()
	A := make([]int, N)
	for i := 0; i < N; i++ {
		A[i] = scanInt()
	}

	minList := make([]int, 1)
	minList[0] = A[0]
	for i := 1; i < N; i++ {
		useNewColor := true
		for j := len(minList) - 1; j >= 0; j-- {
			if A[i] > minList[j] {
				minList[j] = A[i]
				sort.Ints(minList)
				useNewColor = false
				break
			}
		}

		if useNewColor {
			minList = append([]int{A[i]}, minList...)
		}
	}
	fmt.Println(len(minList))
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func scanInt() int {
	sc.Scan()
	i, err := strconv.Atoi(sc.Text())
	if err != nil {
		panic(err)
	}
	return i
}

func main() {
	sc.Split(bufio.ScanWords)

	N := scanInt()
	A := make([]int, N)
	for i := 0; i < N; i++ {
		A[i] = scanInt()
	}

	minList := make([]int, 1)
	minList[0] = A[0]
	for i := 1; i < N; i++ {
		useNewColor := true
		for j := len(minList) - 1; j >= 0; j-- {
			if A[i] > minList[j] {
				minList[j] = A[i]
				sort.Ints(minList)
				useNewColor = false
				break
			}
		}

		if useNewColor {
			minList = append(minList, A[i])
			sort.Ints(minList)
		}
	}
	fmt.Println(len(minList))
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func Scanner() string {
	sc.Scan()
	return sc.Text()
}

func intScanner() int {
	n, _ := strconv.Atoi(Scanner())
	return n
}

func floatScanner() float64 {
	n, _ := strconv.ParseFloat(Scanner(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}

var mod int

func main() {
	mod = 1000000007
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	n := intScanner()
	as := make([]int, n)
	for i := 0; i < n; i++ {
		as[i] = intScanner()
	}
	xs := []int{as[0]}
	for i := 1; i < n; i++ {
		idx := sort.SearchInts(xs, as[i])
		if idx == 0 {
			xs = append([]int{as[i]}, xs...)
		} else {
			xs = append(xs[:idx-1], xs[idx:]...)
			x := sort.SearchInts(xs, as[i])
			xs = append(append(xs[:x], as[i]), xs[x:]...)
		}
	}
	fmt.Println(len(xs))
}
//  [ruby]
n = gets.to_s.to_i

a = []
$<.each do |x|
  x = x.to_i
  a[ a.bsearch_index{|k|k<x} || a.size ] = x
end

puts a.size
//  [ruby]
gets

a = []
$<.each do |x|
  x = x.to_i
  a[ a.bsearch_index{|k|k<x} || a.size ] = x
end

puts a.size
//  [ruby]
_,*a=gets
$<.map{|x|x=x.to_i
a[a.bsearch_index{|y|y<x}||a.size]=x}
p a.size
//  [ruby]
b = []
gets.to_i.times.map{ gets.to_i }.each do |a|
  i = b.bsearch_index {|e| e < a }
  if i; b[i] = a; else; b.push a; end
  p b
end
puts b.size
//  [ruby]
b = []
gets.to_i.times.map{ gets.to_i }.each do |a|
  i = b.bsearch_index {|e| e < a }
  if i; b[i] = a; else; b.unshift a; end
end
puts b.size
//  [ruby]
line = readlines.map(&:to_i)

N = line[0]

ans = []
for i in 1..N do
  if ans == [] then
    ans.push(line[i])
  else
    found = false
    j = (ans.length - 1) / 2
    min = 0
    max = ans.length
    while found == false do
      if ans[j] >= line[i] then
        min = j + 1
        j = (ans.length + j) / 2
      elsif ans[j] < line[i] then  #can be colored j
        max = j
        j = j / 2
      end
      if min == max then
        found = true
      end
    end
    if min == -1 then
      ans.push(line[i])
    else
      ans[min] = line[i]
    end
  end
end
        
print ans.length
//  [rust]
fn read_stdin() -> String {
    use std::io::Read;
    let mut input = String::new();
    std::io::stdin().read_to_string(&mut input).unwrap();
    input
}

fn scan<'a, I: Iterator<Item = &'a str>, T: std::str::FromStr>(tokens: &mut I) -> T {
    tokens.next().unwrap().parse().ok().unwrap()
}

fn main() {
    let input = read_stdin();
    let tokens = &mut input.split_whitespace();
    let n: usize = scan(tokens);
    let mut x: Vec<usize> = Vec::new();
    for _ in 0..n {
        let a: usize = scan(tokens);
        if x.is_empty() || x[x.len() - 1] >= a {
            x.push(a);
        } else if x[0] < a {
            x[0] = a;
        } else {
            let mut i = 0;
            let mut j = x.len() - 1;
            while i + 1 < j {
                let c = (i + j) / 2;
                if x[c] >= a {
                    i = c;
                } else {
                    j = c;
                }
            }
            x[j] = a;
        }
    }
    println!("{}", x.len());
}
//  [rust]
use proconio::input;
use superslice::*;

fn main() {
    input! {
        n: usize,
        a: [usize; n],
    }

    let mut v = vec![];

    v.push(a[0]);

    for &na in a.iter().skip(1) {
        if na <= v[0] {
            v.push(na);
            continue;
        } else {
            let index = v.upper_bound(&(na - 1));
            v[index - 1] = na;
        }
    }

    println!("{}", v.len());
}
//  [rust]
use std::cmp;
use std::collections::BTreeSet;
use std::collections::VecDeque;
use std::fmt::Debug;
use std::str::FromStr;
#[allow(dead_code)]
fn read_as_vec<T>() -> Vec<T>
where
    T: FromStr,
    <T as FromStr>::Err: Debug,
{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim()
        .split_whitespace()
        .map(|c| T::from_str(c).unwrap())
        .collect()
}

#[allow(dead_code)]
fn read_as_string() -> String {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().to_string()
}

fn lower_bound<T: Ord + Debug>(a: &VecDeque<T>, t: T) -> Option<usize> {
    if a.len() == 0 || t <= a[0] {
        return None;
    }
    let (mut left, mut right) = (0, a.len());
    while left + 1 < right {
        let mid = (left + right) / 2;
        //println!("left={}, right={}, mid={}", left, right, mid);
        if t > a[mid] {
            left = mid;
        } else {
            right = mid;
        }
    }
    return Some(left);
}

fn main() {
    let n: usize = read_as_vec()[0];
    let mut a: VecDeque<usize> = VecDeque::new();

    for _ in 0..n {
        let t = read_as_vec::<usize>()[0];
        if let Some(pos) = lower_bound(&a, t) {
            a[pos] = t;
        } else {
            a.push_back(t);
        }
    }
    println!("{}", a.len());

    // let mut b: VecDeque<usize> = VecDeque::new();
    // b.push_back(3);
    // b.push_back(4);
    // b.push_back(4);
    // b.push_back(4);
    // b.push_back(5);
    // b.push_back(5);
    // b.push_back(6);
    // b.push_back(6);
    // dbg!(lower_bound(&b, 5));
}
//  [rust]
use std::cmp;
use std::collections::BTreeSet;
use std::collections::VecDeque;
use std::fmt::Debug;
use std::str::FromStr;
#[allow(dead_code)]
fn read_as_vec<T>() -> Vec<T>
where
    T: FromStr,
    <T as FromStr>::Err: Debug,
{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim()
        .split_whitespace()
        .map(|c| T::from_str(c).unwrap())
        .collect()
}

#[allow(dead_code)]
fn read_as_string() -> String {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().to_string()
}

fn lower_bound<T: Ord + Debug>(a: &VecDeque<T>, t: T) -> Option<usize> {
    if a.len() == 0 || t <= a[0] {
        return None;
    }
    let (mut left, mut right) = (0, a.len());
    while left + 1 < right {
        let mid = (left + right) / 2;
        if t > a[mid] {
            left = mid;
        } else {
            right = mid - 1;
        }
    }
    return Some(left);
}

fn main() {
    let n: usize = read_as_vec()[0];
    let mut a: VecDeque<usize> = VecDeque::new();

    for _ in 0..n {
        let t = read_as_vec::<usize>()[0];
        if let Some(pos) = lower_bound(&a, t) {
            a[pos] = t;
        } else {
            a.push_back(t);
        }
    }
    println!("{}", a.len());

    // let mut b: VecDeque<usize> = VecDeque::new();
    // b.push_back(3);
    // b.push_back(4);
    // b.push_back(4);
    // b.push_back(4);
    // b.push_back(5);
    // b.push_back(5);
    // b.push_back(6);
    // b.push_back(6);
    // dbg!(lower_bound(&b, 5));
}
//  [swift]
let n = Int(readLine()!)!
var a: [Int] = .init(repeating: 0, count: n)
for i in 0..<n {
  a[i] = Int(readLine()!)!
}
var ans: [Int] = []

func binarySearch(_ a: [Int], _ target: Int) -> Int {
  var left = 0
  var right = ans.count - 1
  var ans = a.count
  while left <= right {
    let mid = left + (right - left) / 2
    if target > a[mid] {
      ans = mid
      right = mid - 1
    } else {
      left = mid + 1
    }
  }
  return max(ans, 0)
}

for i in 0..<n {
  let ai = a[i]
  let index = binarySearch(ans, ai)
  if index >= ans.count {
    ans.append(ai)
  } else {
    ans[index] = ai
  }
}
print(ans.count)
//  [swift]
let n = Int(readLine()!)!
var a: [Int] = .init(repeating: 0, count: n)
for i in 0..<n {
  a[i] = Int(readLine()!)!
}
var ans: [Int] = []

func binarySearch(_ a: [Int], _ target: Int) -> Int {
  var left = 0
  var right = ans.count - 1
  var ans = a.count
  while left <= right {
    let mid = left + (right - left) / 2
    if target > a[mid] {
      ans = mid
      left = mid + 1
    } else {
      right = mid - 1
    }
  }
  return max(ans, 0)
}

for i in 0..<n {
  let ai = a[i]
  let index = binarySearch(ans, ai)
  if index >= ans.count {
    ans.append(ai)
  } else {
    ans[index] = ai
  }
}
print(ans.count)
//  [swift]
let n = Int(readLine()!)!
var a: [Int] = .init(repeating: 0, count: n)
for i in 0..<n {
  a[i] = Int(readLine()!)!
}
var ans: [Int] = []

func binarySearch(_ a: [Int], _ target: Int) -> Int {
  var left = 0
  var right = ans.count - 1
  var ans = a.count
  while left <= right {
    let mid = left + (right - left) / 2
    if target > a[mid] {
      ans = mid
      left = mid + 1
    } else {
      right = mid - 1
    }
  }
  return max(ans, 0)
}

for i in 0..<n {
  let ai = -a[i]
  let index = binarySearch(ans, ai)
  if index >= ans.count {
    ans.append(ai)
  } else {
    ans[index] = ai
  }
}
print(ans.count)
//  [swift]
let n = Int(readLine()!)!
var a: [Int] = .init(repeating: 0, count: n)
for i in 0..<n {
  a[i] = Int(readLine()!)!
}
var ans: [Int] = []

func binarySearch(_ a: [Int], _ target: Int) -> Int {
  var left = 0
  var right = ans.count - 1
  var ans = a.count
  while left <= right {
    let mid = left + (right - left) / 2
    if target > a[mid] {
      ans = mid
      left = mid + 1
    } else {
      right = mid - 1
    }
  }
  return max(ans, 0)
}

for i in 0..<n {
  let ai = -a[i]
  let index = binarySearch(ans, ai)
  if index >= ans.count {
    ans.append(ai)
  } else {
    ans[index] = ai
  }
}
print(ans)
print(ans.count)
//  [typescript]
import * as fs from 'fs';

export class Reader {
    lines: string[];
    currentLine: number;

    constructor() {
        this.lines = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
        this.currentLine = 0;
    }

    readLine(): string {
        return this.lines[this.currentLine++];
    }

    readInt(): number {
        return Number(this.readLine());
    }

    readInts(): number[] {
        return this.readLine().split(" ").map(Number);
    }
}

let reader = new Reader();

let N = reader.readInt();
let A: number[] = [];
for(let i=0; i<N; i++) {
    A.push(reader.readInt());
}

let B = new Array(2*N).fill(-1);
let start = N, end = N;

for(let a of A) {
    if (start == end && B[start] == -1) {
        B[start] = a;
        continue
    }
    if (a <= B[start]) {
        B[--start] = a;
        continue
    }
    if (a > B[end]) {
        B[end] = a;
        continue
    }
    let low = start-1, high = end+1;
    while (high-low > 1) {
        let mid = Math.floor((low+high)/2);
        if (a > B[mid]) {
            low = mid;
        } else {
            high = mid;
        }
    }
    if (B[low] == -1)
        B[--start] = a;
    else
        B[low] = a;
}

let count = B.reduce((prev, current) => prev+((current >= 0)?1:0), 0);
console.log(count);
//  [typescript]
function main(input) {
  input = input.trim().split("\n");
  const n = Number(input[0]);
  const as = input.slice(1).map(n => Number(n));
  const colors = [];
  for (let i = 0; i < n; i++) {
    const a = as[i];
    const target = (() => {
      if (!colors.length || a <= colors[colors.length-1]) return null;
      for (let j = 0; j < colors.length; j++) {
        const num = colors[j];
        if (num < a) return j;
      }
      return null;
    })();
    if (target === null) {
      colors.push(a);
    } else {
      colors[target] = a;
    }
  }
  const result = colors.length;
  console.log(result);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
function main(input) {
  input = input.trim().split("\n");
  const n = Number(input[0]);
  const as = input.slice(1).map(n => Number(n));
  const colors = [];
  for (let i = 0; i < n; i++) {
    const a = as[i];
    const target = (() => {
      if (!colors.length || a < colors[colors.length-1]) return null;
      for (let j = 0; j < colors.length; j++) {
        const num = colors[j];
        if (num < a) return j;
      }
      return null;
    })();
    if (target === null) {
      colors.push(a);
    } else {
      colors[target] = a;
    }
  }
  const result = colors.length;
  console.log(result);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [python]
x1, y1, x2, y2 = map(int, input().split())

ans = ''

dx = x2 - x1
dy = y2 - y1

ans += 'R'*dx + 'U'*dy + 'R' + 'D'*(dy+1) + 'L'*(dx+1) + 'U'*(dy+1) + 'R'*dx + 'U' + 'L'*(dx+1) + 'D'*(dy+1) + 'R'

print(ans)
//  [python]
# UU  R     DD  L
#LUUU RR DR DDD LLU

sx, sy, tx, ty = map(int, input().split())
print('U'*abs(ty-sy),
        'R'*abs(tx-sx),
        'D'*abs(ty-sy),
        'L'*abs(tx-sx),
        'L',
        'U'*(abs(ty-sy)+1),
        'R'*(abs(tx-sx)+1),
        'DR',
        'D'*(abs(ty-sy)+1),
        'L'*(abs(tx-sx)+1),
        'U',
        sep='')
//  [python]
sx,sy,tx,ty=map(int,input().split())
xd=tx-sx;yd=ty-sy
res='R'*xd+'U'*yd+'L'*xd+'D'*yd+'D'+'R'*(xd+1)+'U'*(yd+1)+'LU'+'L'*(xd+1)+'D'*(yd+1)+'R'
print(res)
//  [python]
def main():
    sx, sy, tx, ty = map(int, input().split())
    x = tx - sx
    y = ty - sy
    s = ""
    for i in range(2):
        tmp = ""
        if i:
            tmp += "D"
            tmp += "R"*(x+1)
            tmp += "U"*(y+1)
            tmp += "L"

        else:
            tmp += "R"*x
            s += "U"*y
        s += tmp + tmp.translate(str.maketrans({"U": "D",
                                                "D": "U", "L": "R", "R": "L"}))
    print(s)


if __name__ == "__main__":
    main()
//  [python]
def main():
    sx, sy, tx, ty = map(int, input().split())
    x = tx - sx
    y = ty - sy
    s = ""
    for i in range(2):
        if i:
            s += "D"
            s += "R"*(x+1)
            s += "U"*(y+1)
            s += "L"

        else:
            s += "R"*x
            s += "U"*y
        s += s.translate(str.maketrans({"U": "D",
                                        "D": "U", "L": "R", "R": "L"}))
    print(s)


if __name__ == "__main__":
    main()
//  [python]
def main():
    sx, sy, tx, ty = map(int, input().split())
    x = tx - sx
    y = ty - sy
    s = ""
    for i in range(2):
        if i:
            s += "D"
            s += "R"*x
            s += "U"*y
            s += "L"

        else:
            s += "R"*x
            s += "U"*y

        s += s.translate(str.maketrans({"U": "D",
                                        "D": "U", "L": "R", "R": "L"}))
    print(s)


if __name__ == "__main__":
    main()
//  [java]
import java.io.*;
import java.util.*;
import static java.lang.System.out;

public class Main{
    static MyReader in = new MyReader();

    public static void main(String[] args){
        int sx, sy, tx, ty; 
        {int[] a = in.ii(); sx = a[0]; sy = a[1]; tx = a[2]; ty = a[3];}
        StringBuilder sb = new StringBuilder();
        int x = sx;
        int y = sy;
        int dx = tx-sx;
        int dy = ty-sy;
        char[] ans = new char[4*(dx+dy)+8];
        int j = 0;
        for(int i = dx; i != 0; i--){
            ans[j++] = 'R';
        }
        for(int i = dy; i != 0; i--){
            ans[j++] = 'U';
        }
        for(int i = dx; i != 0; i--){
            ans[j++] = 'L';
        }
        for(int i = dy+1; i != 0; i--){
            ans[j++] = 'D';
        }
        for(int i = dx+1; i != 0; i--){
            ans[j++] = 'R';
        }
        for(int i = dy+1; i != 0; i--){
            ans[j++] = 'U';
        }
        ans[j++] = 'L';
        ans[j++] = 'U';
        for(int i = dx+1; i != 0; i--){
            ans[j++] = 'L';
        }
        for(int i = dy+1; i != 0; i--){
            ans[j++] = 'D';
        }
        ans[j++] = 'R';
        out.println(ans);
    }

    static class MyReader extends BufferedReader{
        MyReader(){
            super(new InputStreamReader(System.in));
        }

        String s(){
            try{return readLine();}catch(IOException e){return "";}
        }

        String[] ss(){
            return s().split(" ");
        }

        int i(){
            return Integer.parseInt(s());
        }

        int[] ii(){
            String[] ss = ss();
            int[] ii = new int[ss.length];
            for(int j = 0; j < ss.length; j++) ii[j] = Integer.parseInt(ss[j]);
            return ii;
        }

        ArrayList<Integer> li(){
            String[] ss = ss();
            ArrayList<Integer> li = new ArrayList<>();
            for(int j = 0; j < ss.length; j++) li.add(Integer.parseInt(ss[j]));
            return li;
        }

        long l(){
            return Long.parseLong(s());
        }

        long[] ll(){
            String[] ss = ss();
            long[] ll = new long[ss.length];
            for(int j = 0; j < ss.length; j++) ll[j] = Long.parseLong(ss[j]);
            return ll;
        }
    }
}
//  [java]
import java.lang.*;
import java.io.*;
import java.util.*;


public class Main {
	
	public static void main(String[] args) throws java.lang.Exception {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(in, out);
		out.close();
	}
}

class TaskA {

	public void solve(InputReader in, PrintWriter out) {
		int sx = in.nextInt(), sy = in.nextInt();
		int tx = in.nextInt(), ty = in.nextInt();
		StringBuilder sb = new StringBuilder();
		String sud = "UD";
		String srl = "RL";
	
		for (int j=0; j<2; ++j) {
			char ch1 = sud.charAt(j), ch2 = srl.charAt(j);
			for (int i=sy; i<ty; ++i) {
				sb.append(ch1);
			}
			for (int i=sx; i<tx; ++i) {
				sb.append(ch2);
			}
		}
		
		for (int j=0; j<2; ++j) {
			char ch1 = sud.charAt(j), ch2 = srl.charAt(j);
			sb.append(srl.charAt(j^1));
			for (int i=sy; i<=ty; ++i) {
				sb.append(ch1);
			}
			for (int i=sx; i<=tx; ++i) {
				sb.append(ch2);
			}
			sb.append(sud.charAt(j^1));
		}

		out.println(sb.toString());
	}
}

class InputReader {
	public BufferedReader reader;
	public StringTokenizer tokenizer;


	public InputReader(InputStream stream) {
		reader = new BufferedReader(new InputStreamReader(stream), 32768);
		tokenizer = null;
	}


	public String next() {
		while (tokenizer==null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(reader.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}

	public int nextInt() {
		return Integer.parseInt(next());
	}

	public long nextLong() {
		return Long.parseLong(next());
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}
}
//  [java]
import java.util.*;
import java.io.*;


public class HelloWorld{

     public static void main(String []args){
        Scanner scanner = new Scanner(System.in);
        int sx = scanner.nextInt();
        int sy =scanner.nextInt();
        int tx = scanner.nextInt();
        int ty =scanner.nextInt();
   
        
        int y = ty- sy;
        int x = tx - sx;
        
        for(int i=0;i<y;i++)
         System.out.print("U");
        
        for(int i=0;i<x;i++)
        System.out.print("R");
        
         for(int i=0;i<y;i++)
         System.out.print("D");
        
        for(int i=0;i<=x;i++)
        System.out.print("L");
        
        for(int i=0;i<=y;i++)
         System.out.print("U");
        
        for(int i=0;i<=x;i++)
        System.out.print("R");
        
         System.out.print("D");
        
        
         System.out.print("R");
         
           for(int i=0;i<=y;i++)
         System.out.print("D");
         
          for(int i=0;i<=x;i++)
        System.out.print("L");
        
        
        System.out.print("U");
        
        
        
     }
}
//  [java]


import java.util.*;

public class Main {
	public static void main(String args[])
	{
		Scanner sc=new Scanner(System.in);
		int sx=sc.nextInt();
		int sy=sc.nextInt();
		int tx=sc.nextInt();
		int ty=sc.nextInt();
		int i;
		for(i=0;i<ty;i++) System.out.print("U");
		for(i=0;i<tx;i++) System.out.print("R");
		for(i=0;i<ty;i++) System.out.print("D");
		for(i=0;i<tx;i++) System.out.print("L");
		
		System.out.print("L");
		for(i=0;i<=ty;i++) System.out.print("U");
		for(i=0;i<=tx;i++) System.out.print("R");
		System.out.print("D");
		
		System.out.print("R");
		for(i=0;i<=ty;i++) System.out.print("D");
		for(i=0;i<=tx;i++) System.out.print("L");
		System.out.print("U");


		
	}

}
//  [cpp]
#include<iostream>
#include<string>

using namespace std;
using ll = long long;

int sx, sy, tx, ty;

void input(){
  cin >> sx >> sy >> tx >> ty;
}


string first_time(){
  string s;
  int y = ty - sy;
  int x = tx - sx;
  for(int i = 0; i < y; ++i){
    s.append("U");
  }
  for(int i = 0; i < x; ++i){
    s.append("R");
  }
  for(int i = 0; i < y; ++i){
    s.append("D");
  }
  for(int i = 0; i < x; ++i){
    s.append("L");
  }
  return s;
}

string second_time(){
  string s;
  int y = ty - sy;
  int x = tx - sx;
  s.append("L");
  for(int i = 0; i <= y; ++i){
    s.append("U");
  }
  for(int i = 0; i <= x; ++i){
    s.append("R");
  }
  s.append("D");
  s.append("R");
  for(int i = 0; i <= y; ++i){
    s.append("D");
  }
  for(int i = 0; i <= x; ++i){
    s.append("L");
  }
  s.append("U");
  return s;
}

int main(){
  input();
  cout << first_time() << second_time() << endl;
}
//  [cpp]
#include <vector>
#include <math.h>
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <iomanip>
#include <deque>
#include <map>

typedef long long ll;
#define rep(i, a, n) for(int i = a; i<n; i++)
#define ALL(a) begin(a), end(a)
#define mii map<int, int>
#define msi map<string, int>
#define vi vector<int>
#define vl vector<ll>
#define MOD 1000000007
#define INF 1e9
#define showVector(v) rep(i,0,v.size()){p(v[i]);p(" ")} pl("")
#define p(s) std::cout << s ;
#define pl(s)  std::cout << s << endl;
using namespace std;

// 素数判定 O(√n)
bool is_prime(int n){
    for(int i = 2; i * i <= n; i++){
        if(n % i == 0) return false;
    }
    return true;
}

template<class T> inline bool chmin(T& a, T b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;

}
template<class T> inline bool chmax(T& a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}
int main() {
    int sx, sy, tx, ty;
    cin >> sx >> sy >> tx >> ty;
    int dx = tx - sx, dy = ty - sy;
    string res = "";
    rep(i, 0, dx) res += "R";
    rep(i, 0, dy) res += "U";
    rep(i, 0, dx) res += "L";
    rep(i, 0, dy) res += "D";

    res += "D";
    rep(i, 0, dx+1) res += "R";
    rep(i, 0, dy+1) res += "U";
    res += "L";
    res += "U";
    rep(i, 0, dx+1) res += "L";
    rep(i, 0, dy+1) res += "D";
    res += "R";
    cout << res << endl;
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#define INF 1e9
#define INFLL 1ull<<60u
using namespace std;

#define REPR(i,n) for(int i=(n); i >= 0; --i)
#define FOR(i, m, n) for(int i = (m); i < (n); ++i)
#define REP(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define ALL(a)  (a).begin(),(a).end()
#define endl "\n"

template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return true; } return false; }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
typedef long long ll;

const int MAX_SIZE = 2003;

void solve() {
    vector<vector<bool>> visited(MAX_SIZE,vector<bool>(MAX_SIZE,false));
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
    char dir[4] = {'U','D','R','L'};
    pair<int,int> s,t;
    int sx,sy,tx,ty; cin >> sx >> sy >> tx >> ty;
    sx += 1001; sy += 1001; tx += 1001; ty += 1001;
    s = make_pair(sx,sy);
    t = make_pair(tx,ty);
    visited[sy][sx] = true;
    visited[ty][tx] = true;

    auto bfs = [&](pair<int,int> from,pair<int,int> to)-> string {
        queue<pair<int,int>> qp;
        vector<vector<string>> cost_map(MAX_SIZE,vector<string>(MAX_SIZE,"."));
        auto [stx,sty] = from;
        auto [gx,gy] = to;
        cost_map[sty][stx] = "";
        qp.push(from);
        while(!qp.empty()) {
            auto [x,y] = qp.front(); qp.pop();
            if (x == gx && y == gy) break;
            REP(i,4) {
                string ds(1,dir[i]);
                if ( y+dy[i] >= MAX_SIZE || y+dy[i] < 0 || x+dx[i] >= MAX_SIZE || x+dx[i] < 0) continue;
                else if (!(y+dy[i] == gy && x+dx[i] == gx) && visited[y+dy[i]][x+dx[i]]) continue;
                else if (cost_map[y+dy[i]][x+dx[i]] != "." && cost_map[y+dy[i]][x+dx[i]].size() <= (cost_map[y][x].size() + 1)) continue;
                else {
                    cost_map[y+dy[i]][x+dx[i]] = cost_map[y][x] + ds;
                    qp.emplace(x+dx[i],y+dy[i]);
                }
            }
        }
        assert(cost_map[gy][gx] != ".");
        return cost_map[gy][gx];
    };
    auto update_visited_map = [&](pair<int,int> from, const string& route) {
        auto get_update_pair = [&](char c)-> pair<int,int> {
            REP(i,4) {
                if (c == dir[i]) return make_pair(dx[i],dy[i]);
            }
            return make_pair(-INF,-INF);
        };
        auto [x,y] = from;
        for(const auto &c: route) {
            auto [dx,dy] = get_update_pair(c);
            x += dx; y += dy;
            visited[y][x] = true;
        }
    };

    string save;
    auto route = bfs(s,t);
    save += route;
    update_visited_map(s,route);
    route = bfs(t,s);
    save += route;
    update_visited_map(t,route);
    route = bfs(s,t);
    save += route;
    update_visited_map(s,route);
    route = bfs(t,s);
    save += route;
    update_visited_map(t,route);
    cout << save << endl;
}

int main() {
    solve();
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#define INF 1e9
#define INFLL 1ull<<60u
using namespace std;

#define REPR(i,n) for(int i=(n); i >= 0; --i)
#define FOR(i, m, n) for(int i = (m); i < (n); ++i)
#define REP(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define ALL(a)  (a).begin(),(a).end()
#define endl "\n"

template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return true; } return false; }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
typedef long long ll;

const int MAX_SIZE = 3010;

void solve() {
    vector<vector<bool>> visited(MAX_SIZE,vector<bool>(MAX_SIZE,false));
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
    char dir[4] = {'U','D','R','L'};
    pair<int,int> s,t;
    int sx,sy,tx,ty; cin >> sx >> sy >> tx >> ty;
    sx += 1500; sy += 1500; tx += 1500; ty += 1500;
    s = make_pair(sx,sy);
    t = make_pair(tx,ty);
    visited[sy][sx] = true;
    visited[ty][tx] = true;

    auto bfs = [&](pair<int,int> from,pair<int,int> to)-> string {
        queue<pair<int,int>> qp;
        vector<vector<string>> cost_map(MAX_SIZE,vector<string>(MAX_SIZE,"."));
        auto [stx,sty] = from;
        auto [gx,gy] = to;
        cost_map[sty][stx] = "";
        qp.push(from);
        while(!qp.empty()) {
            auto [x,y] = qp.front(); qp.pop();
            if (x == gx && y == gy) break;
            REP(i,4) {
                string ds(1,dir[i]);
                if ( y+dy[i] >= 3010 || y+dy[i] < 0 || x+dx[i] >= 3010 || x+dx[i] < 0) continue;
                else if (!(y+dy[i] == gy && x+dx[i] == gx) && visited[y+dy[i]][x+dx[i]]) continue;
                else if (cost_map[y+dy[i]][x+dx[i]] != "." && cost_map[y+dy[i]][x+dx[i]].size() <= (cost_map[y][x].size() + 1)) continue;
                else {
                    cost_map[y+dy[i]][x+dx[i]] = cost_map[y][x] + ds;
                    qp.emplace(x+dx[i],y+dy[i]);
                }
            }
        }
        assert(cost_map[gy][gx] != ".");
        return cost_map[gy][gx];
    };
    auto update_visited_map = [&](pair<int,int> from, const string& route) {
        auto get_update_pair = [&](char c)-> pair<int,int> {
            REP(i,4) {
                if (c == dir[i]) return make_pair(dx[i],dy[i]);
            }
            return make_pair(-INF,-INF);
        };
        auto [x,y] = from;
        for(const auto &c: route) {
            auto [dx,dy] = get_update_pair(c);
            x += dx; y += dy;
            visited[y][x] = true;
        }
    };

    string save;
    auto route = bfs(s,t);
    save += route;
    update_visited_map(s,route);
    route = bfs(t,s);
    save += route;
    update_visited_map(t,route);
    route = bfs(s,t);
    save += route;
    update_visited_map(s,route);
    route = bfs(t,s);
    save += route;
    update_visited_map(t,route);
    cout << save << endl;
}

int main() {
    solve();
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
int main(void){
int sx,sy,tx,ty;
cin >> sx >> sy >> tx >> ty;

const int dx=tx-sx,dy=ty-sy;

 // Path 1
cout << string(dy,’U’) << string(dx,’R’);

// Path 2
cout << string(dy,’D’) << string(dx,’L’);

// Path 3
cout << ’L’ << string(dy+1,’U’) << string(dx+1,’R’) << ’D’;

// Path 4
cout << ’R’ << string(dy+1,’D’) << string(dx+1,’L’) << ’U’;

// EndLine
cout << endl;
return 0;
}
//  [c]
#include <stdio.h>

int main(){
  int sx,sy,tx,ty;
  int i,tmp;
  
  scanf("%d %d %d %d",&sx,&sy,&tx,&ty);
  
  //s-->t
  tmp=tx-sx;
  for(i=0;i<tmp;i++){
    printf("R");
  }
  tmp=ty-sy;
  for(i=0;i<tmp;i++){
    printf("U");
  }
  
  //t-->s
  tmp=tx-sx;
  for(i=0;i<tmp;i++){
    printf("L");
  }
  tmp=ty-sy;
  for(i=0;i<tmp;i++){
    printf("D");
  }
  
  //s-->t
  tmp=tx-sx+1;
  printf("D");
  for(i=0;i<tmp;i++){
    printf("R");
  }
  tmp=ty-sy+1;
  for(i=0;i<tmp;i++){
    printf("U");
  }
  printf("L");
  
  //t-->s
  tmp=tx-sx+1;
  printf("U");
  for(i=0;i<tmp;i++){
    printf("L");
  }
  tmp=ty-sy+1;
  for(i=0;i<tmp;i++){
    printf("D");
  }
  printf("R");
 
}
//  [c]
#include <stdio.h>

int main(void){
	int sx, sy, tx, ty;

	scanf("%d%d%d%d", &sx, &sy, &tx, &ty);
	tx -= sx;
	ty -= sy;
	for(int i=0; i < 4; i++) {
        if(i==2){
            tx++;   ty++;
        }
		if(i >= 2)
			printf((i%2) ? "U" : "D");
		for(int j=0; j < tx; j++) {
			printf((i%2) ? "L" : "R");
		}
		for(int j=0; j < ty; j++) {
			printf((i%2) ? "D" : "U");
		}
		if(i >= 2)
			printf((i%2) ? "R" : "L");
	}

	return 0;
}
//  [c]
#include <stdio.h>

int main(void){
	int sx, sy, tx, ty;

	scanf("%d%d%d%d", &sx, &sy, &tx, &ty);
	tx -= sx;
	ty -= sy;
	for(int i=0; i < 4; i++) {
		if(i == 2) {
			tx++;   ty++;
		}
		if(i >= 2)
			printf((i % 2) ? "U" : "D");
		for(int j=0; j < tx; j++) {
			printf((i % 2) ? "L" : "R");
		}
		for(int j=0; j < ty; j++) {
			printf((i % 2) ? "D" : "U");
		}
		if(i >= 2)
			printf((i % 2) ? "R" : "L");
	}

	return 0;
}
//  [c]
#include <stdio.h>

int main(void){
    int x0, y0, x1, y1;
    int xl, yl;
    scanf("%d %d %d %d", &x0, &y0, &x1, &y1);

    xl = x1 - x0;
    yl = y1 - y0;

    for(int i = 0; i < xl; i++) printf("%c", 'U');
    for(int i = 0; i < yl; i++) printf("%c", 'R');
    for(int i = 0; i < yl; i++) printf("%c", 'D');
    for(int i = 0; i < xl; i++) printf("%c", 'L');

    printf("%c", 'L');
    for(int i = 0; i < xl + 1; i++) printf("%c", 'U');
    for(int i = 0; i < yl + 1; i++) printf("%c", 'R');
    printf("%c", 'D');

    printf("%c", 'R');
    for(int i = 0; i < yl + 1; i++) printf("%c", 'D');
    for(int i = 0; i < xl + 1; i++) printf("%c", 'L');
    printf("%c\n", 'U');

    return 0;
}
//  [c]
#include<stdio.h>
#include<stdlib.h>

int max(int a, int b){
  if(a > b) return a;
  else return b;
}

int min(int a, int b){
  if(a < b) return a;
  else return b;
}


int main(){

  int sx,sy,tx,ty;
  scanf("%d %d %d %d",sx,sy,tx,ty);

  for(int i = 0; i < abs(tx-sx); ++i){
    printf("R");
  }

  for(int i = 0; i < abs(ty-sy); ++i){
    printf("U");
  }

  for(int i = 0; i < abs(tx-sx); ++i){
    printf("L");
  }

  for(int i = 0; i < abs(ty-sy); ++i){
    printf("D");
  }

  printf("D");

  for(int i = 0; i < abs(tx-sx)+1; ++i){
    printf("R");
  }

  for(int i = 0; i < abs(ty-sy)+1; ++i){
    printf("U");
  }

  printf("LU");

  for(int i = 0; i < abs(tx-sx)+1; ++i){
    printf("L");
  }

  for(int i = 0; i < abs(ty-sy)+1; ++i){
    printf("D");
  }

  printf("R\n");

  return 0;

}
//  [c]
#include<stdio.h>
#include<stdlib.h>

#define string(num,c) \
    for(i = 0;i < num;i++){ \
        printf("%s",c); \
    } \

int main(void){

    int sx,sy,tx,ty,i,dx,dy;

    scanf("%d %d %d %d",&sx,&sy,&tx,&ty);

    dx = tx - sx;
    dy = ty - sy;

    string(dy,"U");
    string(dx,"R");
    string(dy,"D");
    string(dx,"L");
    printf("L");
    string(dy+1,"U");
    string(dx+1,"R");
    printf("D");
    printf("R");
    string(dy+1,"U");
    string(dx+1,"L");
    printf("U\n");
    
    return 0;
}
//  [javascript]
inp = require('fs').readFileSync('/dev/stdin', 'utf8').trim().split('\n')
l = inp.shift().split(' ')
sx = l.shift() * 1
sy = l.shift() * 1 
tx = l.shift() * 1 
ty = l.shift() * 1 
ans = ''
for (i=sx; i<tx; i++) {
    ans += 'R'
}
for (i=sy; i<ty; i++) {
    ans += 'U'
}
for (i=tx; i>sx; i--) {
    ans += 'L'
}
for (i=ty; i>sy; i--) {
    ans += 'D'
}
ans += 'D'
for (i=sx; i<=tx; i++) {
    ans += 'R'
}
for (i=sy; i<=ty; i++) {
    ans += 'U'
}
ans += 'L'
ans += 'U'
for (i=tx; i>=sx; i--) {
    ans += 'L'
}
for (i=ty; i>=sy; i--) {
    ans += 'D'
}
ans += 'R'
console.log(ans)
//  [javascript]
module.exports=function(r){var e={};function t(n){if(e[n])return e[n].exports;var o=e[n]={i:n,l:!1,exports:{}};return r[n].call(o.exports,o,o.exports,t),o.l=!0,o.exports}return t.m=r,t.c=e,t.d=function(r,e,n){t.o(r,e)||Object.defineProperty(r,e,{enumerable:!0,get:n})},t.r=function(r){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(r,"__esModule",{value:!0})},t.t=function(r,e){if(1&e&&(r=t(r)),8&e)return r;if(4&e&&"object"==typeof r&&r&&r.__esModule)return r;var n=Object.create(null);if(t.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:r}),2&e&&"string"!=typeof r)for(var o in r)t.d(n,o,function(e){return r[e]}.bind(null,o));return n},t.n=function(r){var e=r&&r.__esModule?function(){return r.default}:function(){return r};return t.d(e,"a",e),e},t.o=function(r,e){return Object.prototype.hasOwnProperty.call(r,e)},t.p="",t(t.s=0)}([function(r,e,t){t(1)(t(2).readFileSync("/dev/stdin","UTF-8").split("\n"))},function(r,e){function t(r,e){return function(r){if(Array.isArray(r))return r}(r)||function(r,e){var t=[],n=!0,o=!1,u=void 0;try{for(var i,f=r[Symbol.iterator]();!(n=(i=f.next()).done)&&(t.push(i.value),!e||t.length!==e);n=!0);}catch(r){o=!0,u=r}finally{try{n||null==f.return||f.return()}finally{if(o)throw u}}return t}(r,e)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance")}()}r.exports=function(r){var e=t(r[0].split(" ").map(function(r){return Number(r)}),4),n=e[0],o=e[1],u=e[2]-n,i=e[3]-o,f=l("R",u)+l("U",i)+l("L",u)+l("D",i)+"L"+l("U",i+1)+l("R",u+1)+"DR"+l("D",i+1)+l("L",u+1)+"U";function l(r,e){for(var t="",n=0;n<e;n++)t+=r;return t}console.log(f)}},function(r,e){r.exports=require("fs")}]);
//  [javascript]
'use strict';

function Main(INPUT) {
    const input = INPUT.split("\n")[0].split(" ");
    const sx = input[0];
    const sy = input[1];
    const tx = input[2];
    const ty = input[3];
    let ans = "";

    for (let i = 0; i < ty - sy; i++) {
        ans += "U";
    }
    for (let i = 0; i < tx - sx; i++) {
        ans += "R";
    }
    for (let i = 0; i < ty - sy; i++) {
        ans += "D";
    }
    for (let i = 0; i <= tx - sx; i++) {
        ans += "L";
    }

    for (let i = 0; i <= ty - sy; i++) {
        ans += "U";
    }
    for (let i = 0; i <= tx - sx; i++) {
        ans += "R";
    }
    ans += "DR"
    for (let i = 0; i <= ty - sy; i++) {
        ans += "D";
    }
    for (let i = 0; i <= tx - sx; i++) {
        ans += "L";
    }
    ans += "U";

    console.log(ans);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main (input) {
  input = input.split("\n")[0].split(" ").map(Number);
  var t = {
    x:input[2],
    y:input[3]
  };
  var ans = "";
  for (var i = 0; i < t.y; i++) {
    ans += "U";
  }
  for (var i = 0; i < t.x; i++) {
    ans += "R";
  }
  for (var i = 0; i < t.y; i++) {
    ans += "D";
  }
  for (var i = 0; i < t.x; i++) {
    ans += "L";
  }
  ans += "L";
  for (var i = 0; i < t.y+1; i++) {
    ans += "U";
  }
  for (var i = 0; i < t.x+1; i++) {
    ans += "R";
  }
  ans += "DR";
  for (var i = 0; i < t.y+1; i++) {
    ans += "D";
  }
  for (var i = 0; i < t.x+1; i++) {
    ans += "L";
  }
  ans += "U";
  console.log(ans);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
"use strict";
    
const main = arg => {
    arg = arg.trim().split("\n");
    const SX = parseInt(arg[0].split(" ")[0]);
    const SY = parseInt(arg[0].split(" ")[1]);
    const TX = parseInt(arg[0].split(" ")[2]);
    const TY = parseInt(arg[0].split(" ")[3]);
    
    const DX = TX - SX;
    const DY = TY - SY;
    
    let answer = [];
    
    for(let i=0; i<DX; i++) {
        answer.push("R");
    }
    
    for(let i=0; i<DY; i++) {
        answer.push("U");
    }
    
    for(let i=0; i<DX; i++) {
        answer.push("L");
    }
    
    for(let i=0; i<DY; i++) {
        answer.push("D");
    }
    
    answer.push("L");
    
    for(let i=0; i<DY+1; i++) {
        answer.push("U");
    }
    
    for(let i=0; i<DX+1; i++) {
        answer.push("R");
    }
    
    answer.push("D");
    
    for(let i=0; i<DY+1; i++) {
        answer.push("D");
    }
    
    for(let i=0; i<DX+1; i++) {
        answer.push("L");
    }
    
    answer.push("U");
    
    console.log(answer.join(""));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
"use strict";
    
const main = arg => {
    arg = arg.trim().split("\n");
    const SX = parseInt(arg[0].split(" ")[0]);
    const SY = parseInt(arg[0].split(" ")[1]);
    const TX = parseInt(arg[0].split(" ")[2]);
    const TY = parseInt(arg[0].split(" ")[3]);
    
    let answer = [];
    
    for(let i=0; i<TX; i++) {
        answer.push("R");
    }
    
    for(let i=0; i<TY; i++) {
        answer.push("U");
    }
    
    for(let i=0; i<TX; i++) {
        answer.push("L");
    }
    
    for(let i=0; i<TY; i++) {
        answer.push("D");
    }
    
    answer.push("L");
    
    for(let i=0; i<TY+1; i++) {
        answer.push("U");
    }
    
    for(let i=0; i<TX+1; i++) {
        answer.push("R");
    }
    
    answer.push("D");
    
    for(let i=0; i<TY+1; i++) {
        answer.push("D");
    }
    
    for(let i=0; i<TX+1; i++) {
        answer.push("L");
    }
    
    answer.push("U");
    
    console.log(answer.join(""));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
// はい
package main

import (
	"fmt"
	"strings"
)

func main() {
	var Sx, Sy, Tx, Ty int
	fmt.Scan(&Sx, &Sy, &Tx, &Ty)
	ans := ""
	ans += strings.Repeat("R", Tx-Sx) + strings.Repeat("U", Ty-Sy)
	ans += strings.Repeat("L", Tx-Sx) + strings.Repeat("D", Ty-Sy) + "D"
	ans += strings.Repeat("R", Tx-Sx+1) + strings.Repeat("U", Ty-Sy+1) + "LU"
	ans += strings.Repeat("L", Tx-Sx+1) + strings.Repeat("D", Ty-Sy+1) + "R"
	fmt.Println(ans)
}
//  [go]
package main

import (
	"fmt"
	"strings"
)

func main() {
	var sx, sy, tx, ty int
	fmt.Scan(&sx, &sy, &tx, &ty)

	dx, dy := tx-sx, ty-sy

	// s -> t
	fmt.Print(strings.Repeat("U", dy))
	fmt.Print(strings.Repeat("R", dx))

	// t -> s
	fmt.Print(strings.Repeat("D", dy))
	fmt.Print(strings.Repeat("L", dx))

	// s -> t
	fmt.Print("L")
	fmt.Print(strings.Repeat("U", dy+1))
	fmt.Print(strings.Repeat("R", dx+1))
	fmt.Print("D")

	// t -> s
	fmt.Print("R")
	fmt.Print(strings.Repeat("D", dy+1))
	fmt.Print(strings.Repeat("L", dx+1))
	fmt.Print("U")

	fmt.Println()
}
//  [go]
package main

import (
	"fmt"
	"strings"
)

func main() {
	var sx, sy, tx, ty int
	fmt.Scan(&sx, &sy, &tx, &ty)
	x := tx - sx
	y := ty - sy
	s := ""
	s = s + strings.Repeat("R", x)
	s = s + strings.Repeat("U", y)
	s = s + strings.Repeat("L", x)
	s = s + strings.Repeat("D", y)
	s = s + "D"
	s = s + strings.Repeat("R", x+1)
	s = s + strings.Repeat("U", y+1)
	s = s + "LU"
	s = s + strings.Repeat("L", x+1)
	s = s + strings.Repeat("D", y+1)
	s = s + "R"
	fmt.Println(s)
}
//  [ruby]
sx, sy, tx, ty = gets.split.map(&:to_i)
ret = []

a = ty - sy
b = tx - sx

ret << 'U' * a
ret << 'R' * b
ret << 'D' * a
ret << 'L' * b
ret << 'L'
ret << 'U' * (a + 1)
ret << 'R' * (b + 1)
ret << 'D'
ret << 'R'
ret << 'D' * (a + 1)
ret << 'L' * (b + 1)
ret << 'U'

puts ret.join
//  [ruby]
sx,sy,tx,ty=$<.read.split.map(&:to_i)
h = {
    'U' => 'D',
    'D' => 'U',
    'R' => 'L',
    'L' => 'R',
}

s = ''

s += 'R' * (tx-sx)
s += 'U' * (ty-sy)
s += 'L' * (tx-sx)
s += 'D' * (ty-sy)

s += 'D'
s += 'R' * (tx-sx+1)
s += 'U' * (ty-sy+1)
s += 'L'
s += 'U'
s += 'L' * (tx-sx+1)
s += 'D' * (ty-sy+1)
s += 'R'

puts s
//  [ruby]
sx, sy, tx, ty = gets.split.map(&:to_i)
x, y = (tx - sx), (ty - sy)
a  = "U" * y + "R" * x
a += "D" * y + "L" * x
a += "L" + "U" * (y + 1) + "R" * (x + 1) + "D"
a += "R" + "D" * (y + 1) + "L" * (x + 1) + "U"
puts a
//  [ruby]
s_x,s_y,t_x,t_y = gets.chomp.split(' ').map(&:to_i)
arr = []
arr << "U" * (t_y - s_y)
arr << "R" * (t_x - s_x)
arr << "D" * (t_y - s_y)
arr << "L" * (t_x - s_x + 1)
arr << "U" * (t_y - s_y + 1)
arr << "R" * (t_x - s_x + 1)
arr << "D"
arr << "R"
arr << "D" * (t_y - s_y + 1)
arr << "L" * (t_y - s_y + 1)
arr << "U"
puts arr.join
//  [ruby]
s_x,s_y,t_x,t_y = gets.chomp.split(' ').map(&:to_i)
arr = []
arr << "U" * (t_y - s_y)
arr << "R" * (t_x - s_x + 1)
arr << "D" * (t_y - s_y + 1)
arr << "U"
arr << "L"
arr << "U" * (t_y - s_y + 1)
arr << "R" * (t_x - s_x + 1)
arr << "D" * (t_y - s_y + 1)
arr << "L" * (t_x - s_x )
puts arr.join
//  [ruby]
sx, sy, tx, ty = gets.split(' ').map(&:to_i)
ans = []

dx = tx - sx
dy = ty - sy
# path1
# [rrr,uuuuuuuu]
ans << 'R'*dx << 'U'*dy
ans << 'D'*dx << 'L'*dy

# path2
ans << 'D' << 'R'*(dx+1) << 'U'*(dy+1) << 'L'
ans << 'U' << 'D'*(dx+1) << 'L'*(dy+1) << 'R'

puts ans.join