#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

vector<int> galacticTransmission(vector<int>& nums, int k) {
    if (nums.empty()) return {};
    
    // Sort the array initially to have a baseline
    sort(nums.begin(), nums.end());
    
    // If k is 0, return the sorted array
    if (k == 0) return nums;
    
    // If the array contains any negative numbers, we can use one Blackhole operation
    // to make them positive, which will likely result in a lexicographically smaller array
    // because negative numbers are smaller than positive numbers.
    // However, we need to consider the parity of k.
    
    // Key Insight:
    // - Pulsar (sort) is idempotent in terms of the set of elements, but changes order.
    // - Blackhole (negate) flips signs.
    // - We can perform any number of operations, but we want the lexicographically smallest result.
    
    // Strategy:
    // 1. If there are negative numbers, we should use one Blackhole operation to make them positive.
    //    This is because having negative numbers at the beginning makes the array lexicographically
    //    smaller, but wait: lexicographically smaller means we want the smallest possible first element.
    //    Actually, negative numbers are smaller than positive numbers, so if we have negative numbers,
    //    keeping them negative might be better? No, because we can sort them to the front.
    //    Let's think again.
    
    // Correct Strategy:
    // - The lexicographically smallest array will have the smallest possible first element.
    // - If we have negative numbers, the smallest element is the most negative one.
    // - If we apply Blackhole, all negatives become positives and vice versa.
    // - We can use Pulsar to sort the array.
    
    // Let's analyze the possible states:
    // State 0: Original array, sorted.
    // State 1: Negated array, sorted.
    
    // We can reach State 0 with even number of Blackhole operations (0, 2, 4, ...)
    // We can reach State 1 with odd number of Blackhole operations (1, 3, 5, ...)
    
    // Since we can also use Pulsar (sort) at any time, and sorting doesn't change the set of elements,
    // the only thing that matters is whether we have an even or odd number of Blackhole operations.
    
    // So we have two candidate arrays:
    // 1. Sorted original array (if we use even number of Blackholes)
    // 2. Sorted negated array (if we use odd number of Blackholes)
    
    // We need to choose the lexicographically smaller one, subject to the constraint that we can
    // achieve it in exactly k steps.
    
    // Can we achieve State 0 in exactly k steps?
    // - We need an even number of Blackhole operations. Let's say we use 0 Blackholes.
    //   Then we need to use k Pulsar operations. This is always possible since we can repeat Pulsar.
    //   So State 0 is always achievable.
    
    // Can we achieve State 1 in exactly k steps?
    // - We need an odd number of Blackhole operations. Let's say we use 1 Blackhole.
    //   Then we need to use k-1 Pulsar operations. This is possible if k >= 1.
    //   So State 1 is achievable if k >= 1.
    
    // Therefore:
    // - If k == 0, we can only use State 0.
    // - If k >= 1, we can choose between State 0 and State 1.
    
    // Let's compute both candidates and choose the lexicographically smaller one.
    
    vector<int> candidate0 = nums; // Sorted original
    
    vector<int> candidate1 = nums;
    for (int& x : candidate1) {
        x = -x;
    }
    sort(candidate1.begin(), candidate1.end());
    
    if (k == 0) {
        return candidate0;
    } else {
        // Compare candidate0 and candidate1 lexicographically
        if (candidate0 < candidate1) {
            return candidate0;
        } else {
            return candidate1;
        }
    }
}

int main() {
    vector<int> nums = {3, -1, 2};
    int k = 1;
    vector<int> result = galacticTransmission(nums, k);
    
    for (int i = 0; i < result.size(); ++i) {
        cout << result[i];
        if (i < result.size() - 1) cout << ", ";
    }
    cout << endl;
    
    return 0;
}

import java.util.*;

public class Main {
    public static int[] galacticTransmission(int[] nums, int k) {
        if (nums.length == 0) return new int[0];
        
        // Sort the array initially
        int[] sortedOriginal = nums.clone();
        Arrays.sort(sortedOriginal);
        
        // If k is 0, return the sorted array
        if (k == 0) return sortedOriginal;
        
        // Create the negated and sorted array
        int[] negated = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            negated[i] = -nums[i];
        }
        Arrays.sort(negated);
        
        // Compare the two candidates lexicographically
        for (int i = 0; i < sortedOriginal.length; i++) {
            if (sortedOriginal[i] < negated[i]) {
                return sortedOriginal;
            } else if (sortedOriginal[i] > negated[i]) {
                return negated;
            }
        }
        
        // If they are equal, return either one
        return sortedOriginal;
    }

    public static void main(String[] args) {
        int[] nums = {3, -1, 2};
        int k = 1;
        int[] result = galacticTransmission(nums, k);
        
        System.out.print("[");
        for (int i = 0; i < result.length; i++) {
            System.out.print(result[i]);
            if (i < result.length - 1) System.out.print(", ");
        }
        System.out.println("]");
    }
}

from typing import List

def galacticTransmission(nums: List[int], k: int) -> List[int]:
    if not nums:
        return []
    
    # Sort the array initially
    sorted_original = sorted(nums)
    
    # If k is 0, return the sorted array
    if k == 0:
        return sorted_original
    
    # Create the negated and sorted array
    negated = [-x for x in nums]
    sorted_negated = sorted(negated)
    
    # Compare the two candidates lexicographically
    # Python lists can be compared directly using < and >
    if sorted_original < sorted_negated:
        return sorted_original
    else:
        return sorted_negated

# Example usage
if __name__ == "__main__":
    nums = [3, -1, 2]
    k = 1
    result = galacticTransmission(nums, k)
    print(result)

/**
 * @param {number[]} nums - The input array of integers
 * @param {number} k - The number of cosmic events to perform
 * @return {number[]} - The lexicographically smallest array after exactly k steps
 */
function galacticTransmission(nums, k) {
    if (nums.length === 0) return [];
    
    // Sort the array initially
    const sortedOriginal = [...nums].sort((a, b) => a - b);
    
    // If k is 0, return the sorted array
    if (k === 0) return sortedOriginal;
    
    // Create the negated and sorted array
    const negated = nums.map(x => -x);
    const sortedNegated = [...negated].sort((a, b) => a - b);
    
    // Compare the two candidates lexicographically
    // We can use the fact that arrays can be compared element by element
    for (let i = 0; i < sortedOriginal.length; i++) {
        if (sortedOriginal[i] < sortedNegated[i]) {
            return sortedOriginal;
        } else if (sortedOriginal[i] > sortedNegated[i]) {
            return sortedNegated;
        }
    }
    
    // If they are equal, return either one
    return sortedOriginal;
}

// Example usage
const nums = [3, -1, 2];
const k = 1;
const result = galacticTransmission(nums, k);
console.log(JSON.stringify(result));