Based on the details of your 17:53:29Z post and your 21:09:02Z question updates, the range-end value appears to be exclusive, so we are dealing with half-open intervals . These are common in computer science and actually make some aspects of the range allocation logic simpler.

Since we are storing unallocated and allocated ranges in the same table, we will need an IsAllocated flag. Otherwise, repeated requests for the same size allocation will repeatedly allocate the same range. I have also taken the liberty of renaming the columns to something more meaningful to make the code easier to follow.

The following will find lowest available block of sufficient size and (if found) will either allocate the entire range or split the range into allocated and residual unallocated parts. If the requested range is greater than the largest available block size or is <= 0, no block is allocated and a null result is returned,

DECLARE @Requested INT = 200

-- Find lowest available block of sufficient size
DECLARE @SelectedStart INT
DECLARE @SelectedEnd INT

SELECT TOP 1 @SelectedStart = SequenceStart, @SelectedEnd = SequenceEndExclusive
FROM Sequences
WHERE SequenceEndExclusive - SequenceStart >= @Requested
AND IsAllocated = 0
AND @Requested > 0  -- Sanity check
ORDER BY SequenceStart

-- If found, either allocate the entire range or split the range into
-- allocated and residual unallocated parts
IF @SelectedStart IS NOT NULL
BEGIN
    IF (@SelectedEnd - @SelectedStart = @Requested)
    BEGIN
        -- Allocate entire range
        UPDATE Sequences
        SET IsAllocated = 1, Notes = 'Allocated entire range'
        WHERE SequenceStart = @SelectedStart
    END
    ELSE BEGIN
        -- Update existing range to reflect residual portion
        UPDATE Sequences
        SET SequenceStart = SequenceStart + @Requested, Notes = 'Residual'
        WHERE SequenceStart = @SelectedStart

        -- Insert new allocated range
        INSERT Sequences (SequenceStart, SequenceEndExclusive, IsAllocated, Notes)
        VALUES (@SelectedStart, @SelectedStart + @Requested, 1, 'Added and Allocated')
    END
END

-- Show Results
SELECT @Requested AS Requested, @SelectedStart AS AllocatedStart
SELECT * FROM Sequences

(The Notes logic and SELECT * FROM Sequences are present for demo purposes and can be removed prior to actual use.)

Sample results:
| Requested | AllocatedStart |
| ------------ | ------------ |
| 200 | 100 |

See this db<>fiddle for a demo.

There might also be a need for a deallocation mechanism. That could simply set IsAllocated to 0, but should likely also include cleanup logic for merging adjacent (preceding and/or following) unallocated ranges.

This is pretty ugly, there may be an argument that a temp table with a separate insert and update is cleaner than shoving it all in to one merge.

This assumes that at all points column_a will be unique, and that to avoid overlapping intervals we decrement by 100.

Note - Uses a declared variable for the search parameter. Your exact syntax will vary based on how these queries are coming in.

Steps:

1.) Find the records where x < (column_b - column_a)

2.) Of those, get the earliest by column_a

3.) The first Union clause is what you will insert with the new derived value of column_a

4.) The second Union clause is what you will update with the new derived value of column_b

https://dbfiddle.uk/C6M69gMD

create table some_test_data
  (
    column_a integer,
    column_b integer
  );

insert into some_test_data values (30000, 80000);
insert into some_test_data values (700, 4000);
insert into some_test_data values (9000, 120000);
insert into some_test_data values (150000, 250000);
insert into some_test_data values (100, 600);

DECLARE @some_search_value INT;
SET @some_search_value = 5000;
with filtered_match as (
  select
    *
  from
    (
      select
        *,
        column_b - @some_search_value as new_column_a,
        column_b as new_column_b,
        row_number() over (
          partition by 1
          order by
            column_a asc
        ) rn
      from
        some_test_data
      where
        @some_search_value <= column_b - column_a
    ) t
  where
    rn = 1
),
combine_for_single_upsert as (
  -- This will not match the original row for insert
  select *
    from filtered_match
   union
  -- This will match this original row for update
  select column_a,
         column_b,
         column_a as new_column_a,
         column_b - @some_search_value - 100 as new_column_b,
         0
    from filtered_match
)
merge into some_test_data tgt using (
  select
    *
  from
    combine_for_single_upsert
) as mrg on (
  tgt.column_a = mrg.new_column_a
)
when matched then
update
set
  tgt.column_b = (mrg.new_column_b)
  when not matched then
insert
values
  (mrg.new_column_a, mrg.column_b);

Edit: Separate update and inserts are probably much easier to read.

https://dbfiddle.uk/V7-kdrah

DECLARE @some_search_value INT;
SET @some_search_value = 300;
SELECT * 
  INTO #TempForUpsert
  from
    (
      select
        *,
        column_b - @some_search_value as new_column_a_for_new,
        column_b - @some_search_value - 100 new_column_b_for_orig,
        row_number() over (
          partition by 1
          order by
            column_a asc
        ) rn
      from
        some_test_data
      where
        @some_search_value <= column_b - column_a
    ) t
  where
    rn = 1;

update some_test_data
   set some_test_data.column_b = #TempForUpsert.new_column_b_for_orig
  from #TempForUpsert
 where some_test_data.column_a = #TempForUpsert.column_a;

insert into some_test_data
  select new_column_a_for_new,
         column_b
    from #TempForUpsert;

select * 
  from some_test_data
 order
    by column_a,
       column_b;