diff --git a/Regex/Common.h b/Regex/Common.h
index efb2eeff..55dbe44e 100644
--- a/Regex/Common.h
+++ b/Regex/Common.h
@@ -18,7 +18,7 @@ unsigned int U_CHAR_AT(Ptr p) noexcept {
 template <class T>
 T *OPERAND(T *p) noexcept {
 	static_assert(sizeof(T) == 1, "Invalid Pointer Type");
-	return p + NODE_SIZE;
+	return p + NODE_SIZE<size_t>;
 }
 
 template <class T>
diff --git a/Regex/Compile.cpp b/Regex/Compile.cpp
index 8fc70c12..ac8ce1c0 100644
--- a/Regex/Compile.cpp
+++ b/Regex/Compile.cpp
@@ -15,6 +15,7 @@
 #include <cctype>
 #include <cstring>
 #include <limits>
+#include <gsl/gsl_util>
 
 namespace {
 
@@ -180,7 +181,7 @@ template <class T>
 uint8_t *emit_node(T op_code) noexcept {
 
 	if (pContext.FirstPass) {
-		pContext.Reg_Size += NODE_SIZE;
+		pContext.Reg_Size += NODE_SIZE<size_t>;
 		return reinterpret_cast<uint8_t *>(1);
 	}
 
@@ -246,18 +247,18 @@ uint8_t *emit_special(Ch op_code, uint32_t test_val, size_t index) noexcept {
 		switch (op_code) {
 		case POS_BEHIND_OPEN:
 		case NEG_BEHIND_OPEN:
-			pContext.Reg_Size += LENGTH_SIZE; // Length of the look-behind match
-			pContext.Reg_Size += NODE_SIZE;   // Make room for the node
+			pContext.Reg_Size += LENGTH_SIZE<size_t>; // Length of the look-behind match
+			pContext.Reg_Size += NODE_SIZE<size_t>;   // Make room for the node
 			break;
 
 		case TEST_COUNT:
-			pContext.Reg_Size += NEXT_PTR_SIZE; // Make room for a test value.
+			pContext.Reg_Size += NEXT_PTR_SIZE<size_t>; // Make room for a test value.
 			NEDIT_FALLTHROUGH();
 		case INC_COUNT:
-			pContext.Reg_Size += INDEX_SIZE; // Make room for an index value.
+			pContext.Reg_Size += INDEX_SIZE<size_t>; // Make room for an index value.
 			NEDIT_FALLTHROUGH();
 		default:
-			pContext.Reg_Size += NODE_SIZE; // Make room for the node.
+			pContext.Reg_Size += NODE_SIZE<size_t>; // Make room for the node.
 		}
 
 		return reinterpret_cast<uint8_t *>(1);
@@ -319,14 +320,14 @@ uint8_t *insert(uint8_t op, const uint8_t *insert_pos, uint32_t min, uint32_t ma
 
 	if (pContext.FirstPass) {
 
-		size_t insert_size = NODE_SIZE;
+		size_t insert_size = NODE_SIZE<size_t>;
 
 		if (op == BRACE || op == LAZY_BRACE) {
 			// Make room for the min and max values.
-			insert_size += (2 * NEXT_PTR_SIZE);
+			insert_size += (2 * NEXT_PTR_SIZE<size_t>);
 		} else if (op == INIT_COUNT) {
 			// Make room for an index value.
-			insert_size += INDEX_SIZE;
+			insert_size += INDEX_SIZE<size_t>;
 		}
 
 		pContext.Reg_Size += insert_size;
@@ -1227,8 +1228,8 @@ uint8_t *piece(int *flag_param, len_range &range_param) {
 	*flag_param = (min_max[0] > 0) ? (WORST | HAS_WIDTH) : WORST;
 	if (range_local.lower >= 0) {
 		if (min_max[1] != REG_INFINITY) {
-			range_param.lower = range_local.lower * min_max[0];
-			range_param.upper = range_local.upper * min_max[1];
+			range_param.lower = gsl::narrow<int32_t>(range_local.lower * min_max[0]);
+			range_param.upper = gsl::narrow<int32_t>(range_local.upper * min_max[1]);
 		} else {
 			range_param.lower = -1; // Not a fixed-size length
 			range_param.upper = -1;
@@ -1282,15 +1283,15 @@ uint8_t *piece(int *flag_param, len_range &range_param) {
 
 		next = emit_node(NOTHING); // 2,3
 
-		offset_tail(ret_val, NODE_SIZE, next);        // 2
+		offset_tail(ret_val, NODE_SIZE<size_t>, next);        // 2
 		tail(ret_val, next);                          // 3
 		insert(BRANCH, ret_val, 0UL, 0UL, 0);         // 4,5
-		tail(ret_val, ret_val + (2 * NODE_SIZE));     // 4
-		offset_tail(ret_val, 3 * NODE_SIZE, ret_val); // 5
+		tail(ret_val, ret_val + (2 * NODE_SIZE<size_t>));     // 4
+		offset_tail(ret_val, 3 * NODE_SIZE<size_t>, ret_val); // 5
 
 		if (op_code == '+') {
 			insert(NOTHING, ret_val, 0UL, 0UL, 0);    // 6
-			tail(ret_val, ret_val + (4 * NODE_SIZE)); // 6
+			tail(ret_val, ret_val + (4 * NODE_SIZE<size_t>)); // 6
 		}
 	} else if (op_code == '*') {
 		/* Node structure for (x)* construct.
@@ -1302,8 +1303,8 @@ uint8_t *piece(int *flag_param, len_range &range_param) {
 		 */
 
 		insert(BRANCH, ret_val, 0UL, 0UL, 0);             // 1,3
-		offset_tail(ret_val, NODE_SIZE, emit_node(BACK)); // 2
-		offset_tail(ret_val, NODE_SIZE, ret_val);         // 1
+		offset_tail(ret_val, NODE_SIZE<size_t>, emit_node(BACK)); // 2
+		offset_tail(ret_val, NODE_SIZE<size_t>, ret_val);         // 1
 		tail(ret_val, emit_node(BRANCH));                 // 3
 		tail(ret_val, emit_node(NOTHING));                // 4
 	} else if (op_code == '+') {
@@ -1336,11 +1337,11 @@ uint8_t *piece(int *flag_param, len_range &range_param) {
 
 		next = emit_node(NOTHING); // 1,2,3
 
-		offset_tail(ret_val, 2 * NODE_SIZE, next);  // 1
-		offset_tail(ret_val, NODE_SIZE, next);      // 2
+		offset_tail(ret_val, 2 * NODE_SIZE<size_t>, next);  // 1
+		offset_tail(ret_val, NODE_SIZE<size_t>, next);      // 2
 		tail(ret_val, next);                        // 3
 		insert(BRANCH, ret_val, 0UL, 0UL, 0);       // 4
-		tail(ret_val, (ret_val + (2 * NODE_SIZE))); // 4
+		tail(ret_val, (ret_val + (2 * NODE_SIZE<size_t>))); // 4
 
 	} else if (op_code == '?') {
 		/* Node structure for (x)? construct.
@@ -1356,7 +1357,7 @@ uint8_t *piece(int *flag_param, len_range &range_param) {
 		next = emit_node(NOTHING); // 2,3
 
 		tail(ret_val, next);                   // 2
-		offset_tail(ret_val, NODE_SIZE, next); // 3
+		offset_tail(ret_val, NODE_SIZE<size_t>, next); // 3
 	} else if (op_code == '{' && min_max[0] == min_max[1]) {
 		/* Node structure for (x){m}, (x){m}?, (x){m,m}, or (x){m,m}? constructs.
 		 * Note that minimal and maximal matching mean the same thing when we
@@ -1400,13 +1401,13 @@ uint8_t *piece(int *flag_param, len_range &range_param) {
 			insert(NOTHING, ret_val, 0UL, 0UL, pContext.Num_Braces); // 5
 			insert(BRANCH, ret_val, 0UL, 0UL, pContext.Num_Braces);  // 3,4,8
 			tail(emit_node(BACK), ret_val);                          // 3
-			tail(ret_val, ret_val + (2 * NODE_SIZE));                // 4
+			tail(ret_val, ret_val + (2 * NODE_SIZE<size_t>));                // 4
 
 			next = emit_node(NOTHING); // 5,6,7
 
-			offset_tail(ret_val, NODE_SIZE, next);     // 5
-			offset_tail(ret_val, 2 * NODE_SIZE, next); // 6
-			offset_tail(ret_val, 3 * NODE_SIZE, next); // 7
+			offset_tail(ret_val, NODE_SIZE<size_t>, next);     // 5
+			offset_tail(ret_val, 2 * NODE_SIZE<size_t>, next); // 6
+			offset_tail(ret_val, 3 * NODE_SIZE<size_t>, next); // 7
 
 			next = insert(INIT_COUNT, ret_val, 0UL, 0UL, pContext.Num_Braces); // 8
 
@@ -1436,13 +1437,13 @@ uint8_t *piece(int *flag_param, len_range &range_param) {
 
 			next = emit_node(NOTHING); // 5,6
 
-			offset_tail(ret_val, NODE_SIZE, next);                      // 5
+			offset_tail(ret_val, NODE_SIZE<size_t>, next);                      // 5
 			tail(ret_val, next);                                        // 6
 			insert(BRANCH, ret_val, 0UL, 0UL, 0);                       // 7,8
-			tail(ret_val, ret_val + (2 * NODE_SIZE));                   // 7
-			offset_tail(ret_val, 3 * NODE_SIZE, ret_val);               // 8
+			tail(ret_val, ret_val + (2 * NODE_SIZE<size_t>));                   // 7
+			offset_tail(ret_val, 3 * NODE_SIZE<size_t>, ret_val);               // 8
 			insert(INIT_COUNT, ret_val, 0UL, 0UL, pContext.Num_Braces); // 9
-			tail(ret_val, ret_val + INDEX_SIZE + (4 * NODE_SIZE));      // 9
+			tail(ret_val, ret_val + INDEX_SIZE<size_t> + (4 * NODE_SIZE<size_t>));      // 9
 
 		} else {
 			/* Node structure for (x){m,n}? construct.
@@ -1473,13 +1474,13 @@ uint8_t *piece(int *flag_param, len_range &range_param) {
 
 			next = emit_node(NOTHING); // 5,6,7
 
-			offset_tail(ret_val, NODE_SIZE, next);                      // 5
-			offset_tail(ret_val, 2 * NODE_SIZE, next);                  // 6
-			offset_tail(ret_val, 3 * NODE_SIZE, next);                  // 7
-			tail(ret_val, ret_val + (2 * NODE_SIZE));                   // 8
-			offset_tail(next, -NODE_SIZE, ret_val);                     // 9
+			offset_tail(ret_val, NODE_SIZE<size_t>, next);                      // 5
+			offset_tail(ret_val, 2 * NODE_SIZE<size_t>, next);                  // 6
+			offset_tail(ret_val, 3 * NODE_SIZE<size_t>, next);                  // 7
+			tail(ret_val, ret_val + (2 * NODE_SIZE<size_t>));                   // 8
+			offset_tail(next, -NODE_SIZE<int>, ret_val);                     // 9
 			insert(INIT_COUNT, ret_val, 0UL, 0UL, pContext.Num_Braces); // 10
-			tail(ret_val, ret_val + INDEX_SIZE + (4 * NODE_SIZE));      // 10
+			tail(ret_val, ret_val + INDEX_SIZE<size_t> + (4 * NODE_SIZE<size_t>));      // 10
 		}
 
 		pContext.Num_Braces++;
@@ -1507,7 +1508,7 @@ uint8_t *piece(int *flag_param, len_range &range_param) {
 
 			tail(ret_val, next);                   // 4
 			tail(next, emit_node(NOTHING));        // 5,6
-			offset_tail(ret_val, NODE_SIZE, next); // 6
+			offset_tail(ret_val, NODE_SIZE<size_t>, next); // 6
 
 			next = insert(INIT_COUNT, ret_val, 0UL, 0UL, pContext.Num_Braces); // 7
 
@@ -1535,13 +1536,13 @@ uint8_t *piece(int *flag_param, len_range &range_param) {
 			next = emit_node(BACK); // 4
 
 			tail(next, ret_val);                   // 4
-			offset_tail(ret_val, NODE_SIZE, next); // 5
+			offset_tail(ret_val, NODE_SIZE<size_t>, next); // 5
 			tail(ret_val, emit_node(BRANCH));      // 6
 			tail(ret_val, emit_node(NOTHING));     // 7
 
 			insert(INIT_COUNT, ret_val, 0UL, 0UL, pContext.Num_Braces); // 8
 
-			tail(ret_val, ret_val + INDEX_SIZE + (2 * NODE_SIZE)); // 8
+			tail(ret_val, ret_val + INDEX_SIZE<size_t> + (2 * NODE_SIZE<size_t>)); // 8
 
 		} else {
 			/* Node structure for (x){m,n} construct.
@@ -1570,15 +1571,15 @@ uint8_t *piece(int *flag_param, len_range &range_param) {
 			next = emit_node(BRANCH); // 5,8
 
 			tail(ret_val, next);                    // 5
-			offset_tail(next, -NODE_SIZE, ret_val); // 6
+			offset_tail(next, -NODE_SIZE<int>, ret_val); // 6
 
 			next = emit_node(NOTHING); // 7,8
 
-			offset_tail(ret_val, NODE_SIZE, next); // 7
+			offset_tail(ret_val, NODE_SIZE<size_t>, next); // 7
 
-			offset_tail(next, -NODE_SIZE, next);                        // 8
+			offset_tail(next, -NODE_SIZE<int>, next);                        // 8
 			insert(INIT_COUNT, ret_val, 0UL, 0UL, pContext.Num_Braces); // 9
-			tail(ret_val, ret_val + INDEX_SIZE + (2 * NODE_SIZE));      // 9
+			tail(ret_val, ret_val + INDEX_SIZE<size_t> + (2 * NODE_SIZE<size_t>));      // 9
 		}
 
 		pContext.Num_Braces++;
@@ -1703,7 +1704,7 @@ uint8_t *chunk(int paren, int *flag_param, len_range &range_param) {
 		look_only   = true;
 		// We'll overwrite the zero length later on, so we save the ptr
 		ret_val                 = emit_special(paren, 0, 0);
-		emit_look_behind_bounds = ret_val + NODE_SIZE;
+		emit_look_behind_bounds = ret_val + NODE_SIZE<size_t>;
 	} else if (paren == INSENSITIVE) {
 		pContext.Is_Case_Insensitive = true;
 	} else if (paren == SENSITIVE) {
@@ -1777,7 +1778,7 @@ uint8_t *chunk(int paren, int *flag_param, len_range &range_param) {
 
 	// Hook the tails of the branch alternatives to the closing node.
 	for (uint8_t *this_branch = ret_val; this_branch != nullptr; this_branch = next_ptr(this_branch)) {
-		branch_tail(this_branch, NODE_SIZE, ender);
+		branch_tail(this_branch, NODE_SIZE<size_t>, ender);
 	}
 
 	// Check for proper termination.
@@ -1788,7 +1789,7 @@ uint8_t *chunk(int paren, int *flag_param, len_range &range_param) {
 		if (*pContext.Reg_Parse == ')') {
 			Raise<RegexError>("missing left parenthesis '('");
 		} else {
-			Raise<RegexError>("junk on end"); // "Can't happen" - NOTREACHED
+			Raise<RegexError>("junk on end"); // "Can't happen" - NOT REACHED
 		}
 	}
 
@@ -1923,9 +1924,9 @@ Regex::Regex(view::string_view exp, int defaultFlags) {
 		 *    Match_Newline:       Newlines are NOT matched by default
 		 *                         in character classes
 		 */
-		pContext.Is_Case_Insensitive = ((defaultFlags & REDFLT_CASE_INSENSITIVE) != 0);
+		pContext.Is_Case_Insensitive = ((defaultFlags & RE_DEFAULT_CASE_INSENSITIVE) != 0);
 #if 0 // Currently not used. Uncomment if needed.
-		pContext.Match_Newline       = ((defaultFlags & REDFLT_MATCH_NEWLINE) != 0);
+		pContext.Match_Newline       = ((defaultFlags & RE_DEFAULT_MATCH_NEWLINE) != 0);
 #else
 		pContext.Match_Newline = false;
 #endif
@@ -1987,8 +1988,8 @@ Regex::Regex(view::string_view exp, int defaultFlags) {
 			/* Allow x+ or x+? at the start of the regex to be
 			   optimized. */
 
-			if (GET_OP_CODE(scan + NODE_SIZE) == EXACTLY) {
-				re->match_start = static_cast<char>(*OPERAND(scan + NODE_SIZE));
+			if (GET_OP_CODE(scan + NODE_SIZE<size_t>) == EXACTLY) {
+				re->match_start = static_cast<char>(*OPERAND(scan + NODE_SIZE<size_t>));
 			}
 		} else if (GET_OP_CODE(scan) == BOL) {
 			re->anchor++;
diff --git a/Regex/Constants.h b/Regex/Constants.h
index e964a0d8..651508fc 100644
--- a/Regex/Constants.h
+++ b/Regex/Constants.h
@@ -2,6 +2,7 @@
 #ifndef CONSTANTS_H_
 #define CONSTANTS_H_
 
+#include <cstddef>
 #include <cstdint>
 
 /* The first byte of the Regex internal 'program' is a magic number to help
@@ -22,11 +23,20 @@ constexpr auto MaxSubExpr = 50u;
  */
 constexpr int RecursionLimit = 10000;
 
-constexpr int OP_CODE_SIZE  = 1;
-constexpr int NEXT_PTR_SIZE = 2;
-constexpr int INDEX_SIZE    = 1;
-constexpr int LENGTH_SIZE   = 4;
-constexpr int NODE_SIZE     = NEXT_PTR_SIZE + OP_CODE_SIZE;
+template <class T>
+constexpr T OP_CODE_SIZE = 1;
+
+template <class T>
+constexpr T NEXT_PTR_SIZE = 2;
+
+template <class T>
+constexpr T INDEX_SIZE = 1;
+
+template <class T>
+constexpr T LENGTH_SIZE = 4;
+
+template <class T>
+constexpr T NODE_SIZE = NEXT_PTR_SIZE<T> + OP_CODE_SIZE<T>;
 
 constexpr auto REG_INFINITY = 0UL;
 
diff --git a/Regex/Decompile.cpp b/Regex/Decompile.cpp
index c9215b36..ca6195fc 100644
--- a/Regex/Decompile.cpp
+++ b/Regex/Decompile.cpp
@@ -4,12 +4,12 @@
 
 namespace {
 
-constexpr int16_t make_int16(uint8_t hi, uint16_t lo) {
-	return (static_cast<int16_t>(hi << 8)) | lo;
+constexpr uint16_t make_uint16(uint8_t hi, uint8_t lo) {
+	return (static_cast<uint16_t>(hi) << 8) | lo;
 }
 
-constexpr uint16_t make_uint16(uint8_t hi, uint16_t lo) {
-	return (static_cast<uint16_t>(hi << 8)) | lo;
+constexpr int16_t make_int16(uint8_t hi, uint8_t lo) {
+	return static_cast<int16_t>(make_uint16(hi, lo));
 }
 
 }
@@ -337,11 +337,11 @@ std::vector<Instruction> decompileRegex(const Regex &re) {
 			uint8_t offset_hi = *it++;
 			uint8_t offset_lo = *it++;
 
-			int16_t min_hi = *it++;
-			int16_t min_lo = *it++;
+			uint8_t min_hi = *it++;
+			uint8_t min_lo = *it++;
 
-			int16_t max_hi = *it++;
-			int16_t max_lo = *it++;
+			uint8_t max_hi = *it++;
+			uint8_t max_lo = *it++;
 
 			results.emplace_back(Instruction3{static_cast<Opcode>(opcode), make_int16(offset_hi, offset_lo), make_uint16(min_hi, min_lo), make_uint16(max_hi, max_lo)});
 			break;
@@ -352,11 +352,11 @@ std::vector<Instruction> decompileRegex(const Regex &re) {
 			uint8_t offset_hi = *it++;
 			uint8_t offset_lo = *it++;
 
-			int16_t min_hi = *it++;
-			int16_t min_lo = *it++;
+			uint8_t min_hi = *it++;
+			uint8_t min_lo = *it++;
 
-			int16_t max_hi = *it++;
-			int16_t max_lo = *it++;
+			uint8_t max_hi = *it++;
+			uint8_t max_lo = *it++;
 
 			results.emplace_back(Instruction3{static_cast<Opcode>(opcode), make_int16(offset_hi, offset_lo), make_uint16(min_hi, min_lo), make_uint16(max_hi, max_lo)});
 			break;
diff --git a/Regex/Execute.cpp b/Regex/Execute.cpp
index d902fbac..6fa0ec1d 100644
--- a/Regex/Execute.cpp
+++ b/Regex/Execute.cpp
@@ -73,7 +73,7 @@ FORCE_INLINE bool end_of_string(const char *ptr) noexcept {
  * @return
  */
 FORCE_INLINE uint16_t get_lower(const uint8_t *p) noexcept {
-	return static_cast<uint8_t>(((p[NODE_SIZE + 0] & 0xff) << 8) + ((p[NODE_SIZE + 1]) & 0xff));
+	return static_cast<uint8_t>(((p[NODE_SIZE<size_t> + 0] & 0xff) << 8) + ((p[NODE_SIZE<size_t> + 1]) & 0xff));
 }
 
 /**
@@ -82,7 +82,7 @@ FORCE_INLINE uint16_t get_lower(const uint8_t *p) noexcept {
  * @return
  */
 FORCE_INLINE uint16_t get_upper(const uint8_t *p) noexcept {
-	return static_cast<uint8_t>(((p[NODE_SIZE + 2] & 0xff) << 8) + ((p[NODE_SIZE + 3]) & 0xff));
+	return static_cast<uint8_t>(((p[NODE_SIZE<size_t> + 2] & 0xff) << 8) + ((p[NODE_SIZE<size_t> + 3]) & 0xff));
 }
 
 /**
@@ -625,14 +625,14 @@ bool match(uint8_t *prog, size_t *branch_index_param) {
 				lazy = true;
 				NEDIT_FALLTHROUGH();
 			case BRACE:
-				min = static_cast<uint32_t>(GET_OFFSET(scan + NEXT_PTR_SIZE));
-				max = static_cast<uint32_t>(GET_OFFSET(scan + (2 * NEXT_PTR_SIZE)));
+				min = static_cast<uint32_t>(GET_OFFSET(scan + NEXT_PTR_SIZE<size_t>));
+				max = static_cast<uint32_t>(GET_OFFSET(scan + (2 * NEXT_PTR_SIZE<size_t>)));
 
 				if (max <= REG_INFINITY) {
 					max = std::numeric_limits<uint32_t>::max();
 				}
 
-				next_op = OPERAND(scan + (2 * NEXT_PTR_SIZE));
+				next_op = OPERAND(scan + (2 * NEXT_PTR_SIZE<size_t>));
 			}
 
 			save = eContext.Reg_Input;
@@ -693,8 +693,8 @@ bool match(uint8_t *prog, size_t *branch_index_param) {
 			break;
 
 		case TEST_COUNT:
-			if (eContext.BraceCounts[*OPERAND(scan)] < static_cast<uint32_t>(GET_OFFSET(scan + NEXT_PTR_SIZE + INDEX_SIZE))) {
-				next = scan + NODE_SIZE + INDEX_SIZE + NEXT_PTR_SIZE;
+			if (eContext.BraceCounts[*OPERAND(scan)] < static_cast<uint32_t>(GET_OFFSET(scan + NEXT_PTR_SIZE<size_t> + INDEX_SIZE<size_t>))) {
+				next = scan + NODE_SIZE<size_t> + INDEX_SIZE<size_t> + NEXT_PTR_SIZE<size_t>;
 			}
 			break;
 
@@ -869,7 +869,7 @@ bool match(uint8_t *prog, size_t *branch_index_param) {
 				   node. The look-behind node is followed by a chain of
 				   branches (contents of the look-behind expression), and
 				   terminated by a look-behind-close node. */
-				next = NEXT_PTR(OPERAND(scan) + LENGTH_SIZE); // 1st branch
+				next = NEXT_PTR(OPERAND(scan) + LENGTH_SIZE<size_t>); // 1st branch
 
 				// Skip the chained branches inside the look-ahead
 				while (GET_OP_CODE(next) == BRANCH) {
diff --git a/Regex/Regex.h b/Regex/Regex.h
index b38ad5e5..4e03d8a9 100644
--- a/Regex/Regex.h
+++ b/Regex/Regex.h
@@ -14,9 +14,9 @@
 
 /* Flags for CompileRE default settings (Markus Schwarzenberg) */
 enum RE_DEFAULT_FLAG {
-	REDFLT_STANDARD         = 0,
-	REDFLT_CASE_INSENSITIVE = 1
-	/* REDFLT_MATCH_NEWLINE = 2    Currently not used. */
+	RE_DEFAULT_STANDARD         = 0,
+	RE_DEFAULT_CASE_INSENSITIVE = 1
+	/* RE_DEFAULT_MATCH_NEWLINE = 2    Currently not used. */
 };
 
 class Regex {
diff --git a/Regex/Substitute.cpp b/Regex/Substitute.cpp
index 24826a1a..b7616b84 100644
--- a/Regex/Substitute.cpp
+++ b/Regex/Substitute.cpp
@@ -27,14 +27,14 @@ bool Regex::SubstituteRE(view::string_view source, std::string &dest) const {
 
 		char ch = *in++;
 
-		char chgcase    = '\0';
+		char changeCase = '\0';
 		size_t paren_no = InvalidParenNumber;
 
 		if (ch == '\\') {
 			// Process any case altering tokens, i.e \u, \U, \l, \L.
 
 			if (*in == 'u' || *in == 'U' || *in == 'l' || *in == 'L') {
-				chgcase = *in++;
+				changeCase = *in++;
 
 				if (in == source.end()) {
 					break;
@@ -82,7 +82,7 @@ bool Regex::SubstituteRE(view::string_view source, std::string &dest) const {
 
 			/* The tokens \u and \l only modify the first character while the
 			 * tokens \U and \L modify the entire string. */
-			switch (chgcase) {
+			switch (changeCase) {
 			case 'u': {
 				int count = 0;
 				std::transform(re->startp[paren_no], re->endp[paren_no], out, [&count](char ch) -> int {
diff --git a/Regex/test/Test.cpp b/Regex/test/Test.cpp
index 0e552d06..95f02d37 100644
--- a/Regex/test/Test.cpp
+++ b/Regex/test/Test.cpp
@@ -11,7 +11,7 @@ struct Test {
 };
 
 int test_regex_match(view::string_view regex, view::string_view input) {
-	Regex re(regex, REDFLT_STANDARD);
+	Regex re(regex, RE_DEFAULT_STANDARD);
 
 	if (re.execute(input)) {
 		return 0;
@@ -726,7 +726,7 @@ int main() {
 
 	for (Test t : tests) {
 		try {
-			Regex re(t.input, REDFLT_STANDARD);
+			Regex re(t.input, RE_DEFAULT_STANDARD);
 
 			std::string bytes;
 
@@ -773,17 +773,17 @@ int main() {
 		return -1;
 	}
 
-#if 0 // testing "catastrophic backtracking" 
+#if 0 // testing "catastrophic backtracking"
     if (test_regex_match(R"((\\?.)*\\\n)", R"(Ada:Default\n\tAwk:Default\n\tC++:Default\n\tC:Default\n\tCSS:Default\n\tCsh:Default\n\tFortran:Default\n\tJava:Default\n\tJavaScript:Default\n\tLaTeX:Default\n\tLex:Default\n\tMakefile:Default\n\tMatlab:Default\n\tNEdit Macro:Default\n\tPascal:Default\n\tPerl:Default\n\tPostScript:Default\n\tPython:Default\n\tRegex:Default\n\tSGML HTML:Default\n\tSQL:Default\n\tSh Ksh Bash:Default\n\tTcl:Default\n\tVHDL:Default\n\tVerilog:Default\n\tXML:Default\n\tX Resources:Default\n\tYacc:Default)") != 0) {
 		std::cerr << "ERROR    : Failed to X resources match" << std::endl;
-		return -1;    
+		return -1;
     }
 #endif
 
 #if defined(NEDIT_INCLUDE_DECOMPILER)
 	for (Test t : tests) {
 		try {
-			Regex re(t.input, REDFLT_STANDARD);
+			Regex re(t.input, RE_DEFAULT_STANDARD);
 			decompileRegex(re);
 		} catch (...) {
 			std::cerr << "EXCEPTION: " << t.input.to_string() << '\n';
diff --git a/client/nc.cpp b/client/nc.cpp
index 600d4c93..17d0e5c4 100644
--- a/client/nc.cpp
+++ b/client/nc.cpp
@@ -18,6 +18,7 @@
 
 #include <boost/optional.hpp>
 #include <chrono>
+#include <gsl/gsl_util>
 #include <iostream>
 #include <memory>
 
@@ -271,7 +272,7 @@ boost::optional<CommandLine> parseCommandLine(const QStringList &args) {
 
 			int isTabbed;
 
-			/* determine if file is to be openned in new tab, by
+			/* determine if file is to be opened in new tab, by
 			   factoring the options -group, -tabbed & -untabbed */
 			if (group == 2) {
 				isTabbed = 0; // start a new window for new group
@@ -404,10 +405,10 @@ int startServer(const char *message, const QStringList &commandLineArgs) {
 }
 
 bool writeToSocket(QLocalSocket *socket, const QByteArray &data) {
-	int remaining   = data.size();
-	const char *ptr = data.data();
+	int64_t remaining = data.size();
+	const char *ptr   = data.data();
 
-	constexpr int MaxChunk = 4096;
+	constexpr int64_t MaxChunk = 4096;
 
 	while (socket->isOpen() && remaining > 0) {
 		const int64_t written = socket->write(ptr, std::min(MaxChunk, remaining));
@@ -482,7 +483,7 @@ int main(int argc, char *argv[]) {
 
 		auto socket = std::make_unique<QLocalSocket>();
 		socket->connectToServer(socketName, QIODevice::WriteOnly);
-		if (!socket->waitForConnected(timeout.count())) {
+		if (!socket->waitForConnected(gsl::narrow<int>(timeout.count()))) {
 			if (i == 0) {
 				switch (startServer("No servers available, start one? (y|n) [y]: ", commandLine.arguments)) {
 				case -1: // Start failed
diff --git a/cspell.config.yaml b/cspell.config.yaml
index e02dada1..8f1e6292 100644
--- a/cspell.config.yaml
+++ b/cspell.config.yaml
@@ -5,25 +5,23 @@ dictionaries: []
 ignoreWords: []
 import: []
 words:
-  - Balinski
-  - Edel
-  - Greef
-  - Markus
-  - Rebecca
-  - Schwarzenberg
-  - Teran
-  - Vohlken
   - amai
   - backlighting
+  - Balinski
+  - bground
   - burlywood
   - calltip
   - calltips
   - clearcase
   - cornsilk
   - decompile
+  - Edel
   - eteran
+  - fground
   - gainsboro
+  - Greef
   - konsole
+  - Markus
   - nedit
   - overtype
   - pixmap
@@ -36,7 +34,12 @@ words:
   - qvsnprintf
   - rangeset
   - rangesets
+  - Rebecca
   - reparse
+  - Schwarzenberg
+  - Teran
+  - unblank
   - unhighlight
   - unixware
   - untabbed
+  - Vohlken
diff --git a/src/DialogFind.cpp b/src/DialogFind.cpp
index 367f2765..e48f8ce1 100644
--- a/src/DialogFind.cpp
+++ b/src/DialogFind.cpp
@@ -257,10 +257,10 @@ boost::optional<DialogFind::Fields> DialogFind::readFields() {
 		int regexDefault;
 		if (ui.checkCase->isChecked()) {
 			fields.searchType = SearchType::Regex;
-			regexDefault      = REDFLT_STANDARD;
+			regexDefault      = RE_DEFAULT_STANDARD;
 		} else {
 			fields.searchType = SearchType::RegexNoCase;
-			regexDefault      = REDFLT_CASE_INSENSITIVE;
+			regexDefault      = RE_DEFAULT_CASE_INSENSITIVE;
 		}
 		/* If the search type is a regular expression, test compile it
 		   immediately and present error messages */
diff --git a/src/DialogLanguageModes.cpp b/src/DialogLanguageModes.cpp
index 33032202..42e3cd1b 100644
--- a/src/DialogLanguageModes.cpp
+++ b/src/DialogLanguageModes.cpp
@@ -259,7 +259,7 @@ boost::optional<LanguageMode> DialogLanguageModes::readFields(Verbosity verbosit
 	QString recognitionExpr = ui.editRegex->text();
 	if (!recognitionExpr.isEmpty()) {
 		try {
-			auto compiledRE = make_regex(recognitionExpr, REDFLT_STANDARD);
+			auto compiledRE = make_regex(recognitionExpr, RE_DEFAULT_STANDARD);
 		} catch (const RegexError &e) {
 			if (verbosity == Verbosity::Verbose) {
 				QMessageBox::warning(this, tr("Regex"), tr("Recognition expression:\n%1").arg(QString::fromLatin1(e.what())));
diff --git a/src/DialogReplace.cpp b/src/DialogReplace.cpp
index 9948a795..103b6423 100644
--- a/src/DialogReplace.cpp
+++ b/src/DialogReplace.cpp
@@ -609,10 +609,10 @@ boost::optional<DialogReplace::Fields> DialogReplace::readFields() {
 		int regexDefault;
 		if (ui.checkCase->isChecked()) {
 			fields.searchType = SearchType::Regex;
-			regexDefault      = REDFLT_STANDARD;
+			regexDefault      = RE_DEFAULT_STANDARD;
 		} else {
 			fields.searchType = SearchType::RegexNoCase;
-			regexDefault      = REDFLT_CASE_INSENSITIVE;
+			regexDefault      = RE_DEFAULT_CASE_INSENSITIVE;
 		}
 		/* If the search type is a regular expression, test compile it
 		   immediately and present error messages */
diff --git a/src/DocumentWidget.cpp b/src/DocumentWidget.cpp
index fc37a9c6..6f2eba96 100644
--- a/src/DocumentWidget.cpp
+++ b/src/DocumentWidget.cpp
@@ -348,7 +348,7 @@ QLatin1String createRepeatMacro(int how) {
 ** Replaces '%' with <fullName> and '#' with <lineNumber>. But '%%' and '##'
 ** are replaced by '%' and '#'.
 */
-QString escapeCommand(const QString &command, const QString &fullName, int lineNumber) {
+QString escapeCommand(const QString &command, const QString &fullName, int64_t lineNumber) {
 	QString ret;
 	for (int i = 0; i < command.size(); ++i) {
 		auto c = command[i];
@@ -2217,7 +2217,7 @@ bool DocumentWidget::compareDocumentToFile(const QString &fileName) const {
 	int64_t restLen = std::min(PREFERRED_CMPBUF_LEN, fileLen);
 
 	TextCursor bufPos = {};
-	int filePos       = 0;
+	int64_t filePos   = 0;
 	char fileString[PREFERRED_CMPBUF_LEN + 2];
 
 	/* For large files, the comparison can take a while. If it takes too long,
@@ -2231,7 +2231,7 @@ bool DocumentWidget::compareDocumentToFile(const QString &fileName) const {
 
 	while (restLen > 0) {
 
-		size_t offset = 0;
+		int64_t offset = 0;
 		if (pendingCR) {
 			fileString[offset++] = pendingCR;
 		}
@@ -2789,7 +2789,7 @@ bool DocumentWidget::writeBckVersion() {
 #endif
 
 		// Allocate I/O buffer
-		constexpr size_t IO_BUFFER_SIZE = (1024 * 1024);
+		constexpr size_t IO_BUFFER_SIZE = (1024ul * 1024ul);
 		auto io_buffer                  = std::make_unique<char[]>(IO_BUFFER_SIZE);
 
 		// copy loop
@@ -4438,7 +4438,7 @@ void DocumentWidget::setOverstrike(bool overstrike) {
  * @param lineNum
  * @param column
  */
-void DocumentWidget::gotoAP(TextArea *area, int line, int column) {
+void DocumentWidget::gotoAP(TextArea *area, int64_t line, int64_t column) {
 
 	TextCursor position;
 
@@ -6004,7 +6004,7 @@ void DocumentWidget::startHighlighting(Verbosity verbosity) {
 		ctx.prev_char         = &prev_char;
 		ctx.delimiters        = documentDelimiters();
 		ctx.text              = info_->buffer->BufAsString();
-		const char *stringPtr = &ctx.text[0];
+		const char *stringPtr = ctx.text.data();
 
 		Highlight::parseString(
 			&highlightData->pass1Patterns[0],
@@ -6349,12 +6349,12 @@ std::unique_ptr<HighlightData[]> DocumentWidget::compilePatterns(const std::vect
 				Input in(&patternSrc[i].startRE);
 				Q_FOREVER {
 					if (in.match(QLatin1Char('&'))) {
-						compiledPats[i].startSubexprs.push_back(0);
+						compiledPats[i].startSubexpressions.push_back(0);
 					} else if (in.match(QLatin1Char('\\'))) {
 
 						QString number;
 						if (in.match(re, &number)) {
-							compiledPats[i].startSubexprs.push_back(number.toUInt());
+							compiledPats[i].startSubexpressions.push_back(number.toUInt());
 						} else {
 							break;
 						}
@@ -6370,12 +6370,12 @@ std::unique_ptr<HighlightData[]> DocumentWidget::compilePatterns(const std::vect
 				Input in(&patternSrc[i].endRE);
 				Q_FOREVER {
 					if (in.match(QLatin1Char('&'))) {
-						compiledPats[i].endSubexprs.push_back(0);
+						compiledPats[i].endSubexpressions.push_back(0);
 					} else if (in.match(QLatin1Char('\\'))) {
 
 						QString number;
 						if (in.match(re, &number)) {
-							compiledPats[i].endSubexprs.push_back(number.toUInt());
+							compiledPats[i].endSubexpressions.push_back(number.toUInt());
 						} else {
 							break;
 						}
@@ -6483,7 +6483,7 @@ std::unique_ptr<HighlightData[]> DocumentWidget::compilePatterns(const std::vect
 		bigPattern.pop_back(); // remove last '|' character
 
 		try {
-			compiledPats[patternNum].subPatternRE = std::make_unique<Regex>(bigPattern, REDFLT_STANDARD);
+			compiledPats[patternNum].subPatternRE = std::make_unique<Regex>(bigPattern, RE_DEFAULT_STANDARD);
 		} catch (const RegexError &e) {
 			qWarning("NEdit: Error compiling syntax highlight patterns:\n%s", e.what());
 			if (verbosity == Verbosity::Verbose) {
@@ -6507,7 +6507,7 @@ std::unique_ptr<HighlightData[]> DocumentWidget::compilePatterns(const std::vect
 std::unique_ptr<Regex> DocumentWidget::compileRegexAndWarn(const QString &re) {
 
 	try {
-		return make_regex(re, REDFLT_STANDARD);
+		return make_regex(re, RE_DEFAULT_STANDARD);
 	} catch (const RegexError &e) {
 
 		constexpr int MaxLength = 4096;
@@ -7304,7 +7304,7 @@ void DocumentWidget::editTaggedLocation(TextArea *area, int i) {
 
 	QPointer<TextArea> tagArea = MainWindow::fromDocument(documentToSearch)->lastFocus();
 	int rows                   = tagArea->getRows();
-	tagArea->verticalScrollBar()->setValue(lineNum - (rows / 4));
+	tagArea->verticalScrollBar()->setValue(gsl::narrow<int>(lineNum - (rows / 4)));
 	tagArea->horizontalScrollBar()->setValue(0);
 	tagArea->TextSetCursorPos(TextCursor(endPos));
 }
diff --git a/src/DocumentWidget.h b/src/DocumentWidget.h
index 1d433794..9bd70c1b 100644
--- a/src/DocumentWidget.h
+++ b/src/DocumentWidget.h
@@ -173,7 +173,7 @@ class DocumentWidget : public QWidget {
 	void findDefinitionCalltip(TextArea *area, const QString &tipName);
 	void findDefinitionHelper(TextArea *area, const QString &arg, Tags::SearchMode search_type);
 	void finishMacroCmdExecution();
-	void gotoAP(TextArea *area, int lineNum, int column);
+	void gotoAP(TextArea *area, int64_t lineNum, int64_t column);
 	void gotoMark(TextArea *area, QChar label, bool extendSel);
 	void gotoMatchingCharacter(TextArea *area, bool select);
 	void handleUnparsedRegion(const std::shared_ptr<TextBuffer> &styleBuf, TextCursor pos) const;
diff --git a/src/Highlight.cpp b/src/Highlight.cpp
index 074ddfe8..4bd9c627 100644
--- a/src/Highlight.cpp
+++ b/src/Highlight.cpp
@@ -1207,7 +1207,7 @@ bool parseString(const HighlightData *pattern, const char *&string_ptr, char *&s
 							subExecuted = true;
 						}
 
-						for (size_t subExpr : subPat->endSubexprs) {
+						for (size_t subExpr : subPat->endSubexpressions) {
 							recolorSubexpression(pattern->endRE, subExpr, subPat->style, string_ptr, style_ptr);
 						}
 					}
@@ -1306,7 +1306,7 @@ bool parseString(const HighlightData *pattern, const char *&string_ptr, char *&s
 					subExecuted = true;
 				}
 
-				for (size_t subExpr : subSubPat->startSubexprs) {
+				for (size_t subExpr : subSubPat->startSubexpressions) {
 					recolorSubexpression(subPat->startRE, subExpr, subSubPat->style, string_ptr, style_ptr);
 				}
 			}
diff --git a/src/HighlightData.h b/src/HighlightData.h
index fc0b7180..98b571d4 100644
--- a/src/HighlightData.h
+++ b/src/HighlightData.h
@@ -13,8 +13,8 @@ struct HighlightData {
 	std::unique_ptr<Regex> endRE;
 	std::unique_ptr<Regex> errorRE;
 	std::unique_ptr<Regex> subPatternRE;
-	std::vector<size_t> startSubexprs;
-	std::vector<size_t> endSubexprs;
+	std::vector<size_t> startSubexpressions;
+	std::vector<size_t> endSubexpressions;
 	std::unique_ptr<HighlightData *[]> subPatterns;
 	size_t userStyleIndex;
 	size_t nSubPatterns;
diff --git a/src/Location.h b/src/Location.h
index 7d3aa7d8..45d9d4ca 100644
--- a/src/Location.h
+++ b/src/Location.h
@@ -2,9 +2,11 @@
 #ifndef LOCATION_H_
 #define LOCATION_H_
 
+#include <cstdint>
+
 struct Location {
-	int line;
-	int column;
+	int64_t line;
+	int64_t column;
 };
 
 #endif
diff --git a/src/Rangeset.cpp b/src/Rangeset.cpp
index ce15fb9f..0a37bda6 100644
--- a/src/Rangeset.cpp
+++ b/src/Rangeset.cpp
@@ -73,11 +73,11 @@ int64_t at_or_before(const T *table, int64_t base, int64_t len, T val) {
 	int64_t mid = 0;
 
 	if (base >= len) {
-		return len; /* not sure what this means! */
+		return len; // not sure what this means!
 	}
 
-	int64_t lo = base;    /* first valid index */
-	int64_t hi = len - 1; /* last valid index */
+	int64_t lo = base;    // first valid index
+	int64_t hi = len - 1; // last valid index
 
 	while (lo <= hi) {
 		mid = (lo + hi) / 2;
@@ -93,7 +93,7 @@ int64_t at_or_before(const T *table, int64_t base, int64_t len, T val) {
 		}
 	}
 
-	/* if we get here, we didn't find val itself */
+	// if we get here, we didn't find val itself
 	if (val > table[mid]) {
 		mid++;
 	}
@@ -107,17 +107,17 @@ int64_t weighted_at_or_before(const T *table, int64_t base, int64_t len, T val)
 	int64_t mid = 0;
 
 	if (base >= len) {
-		return len; /* not sure what this means! */
+		return len; // not sure what this means!
 	}
 
-	int64_t lo = base;    /* first valid index */
-	int64_t hi = len - 1; /* last valid index */
+	int64_t lo = base;    // first valid index
+	int64_t hi = len - 1; // last valid index
 
-	TextCursor min = table[lo]; /* establish initial min/max */
+	TextCursor min = table[lo]; // establish initial min/max
 	TextCursor max = table[hi];
 
-	if (val <= min) { /* initial range checks */
-		return lo;    /* needed to avoid out-of-range mid values */
+	if (val <= min) { // initial range checks
+		return lo;    // needed to avoid out-of-range mid values
 	}
 
 	if (val > max) {
@@ -129,9 +129,9 @@ int64_t weighted_at_or_before(const T *table, int64_t base, int64_t len, T val)
 	}
 
 	while (lo <= hi) {
-		/* Beware of integer overflow when multiplying large numbers! */
-		mid = lo + static_cast<int>((hi - lo) * static_cast<double>(val - min) / (max - min));
-		/* we won't worry about min == max - values should be unique */
+		// Beware of integer overflow when multiplying large numbers!
+		mid = lo + static_cast<int64_t>((hi - lo) * static_cast<long double>(val - min) / (max - min));
+		// we won't worry about min == max - values should be unique
 
 		if (val == table[mid]) {
 			return mid;
@@ -140,13 +140,13 @@ int64_t weighted_at_or_before(const T *table, int64_t base, int64_t len, T val)
 		if (val < table[mid]) {
 			hi  = mid - 1;
 			max = table[mid];
-		} else { /* val > table[mid] */
+		} else { // val > table[mid]
 			lo  = mid + 1;
 			min = table[mid];
 		}
 	}
 
-	/* if we get here, we didn't find val itself */
+	// if we get here, we didn't find val itself
 	if (val > table[mid]) {
 		return mid + 1;
 	}
@@ -156,6 +156,13 @@ int64_t weighted_at_or_before(const T *table, int64_t base, int64_t len, T val)
 
 // --------------------------------------------------------------------------
 
+TextCursor *flattenRanges(std::vector<TextRange> &ranges) {
+	// NOTE(eteran): ranges_ contains TextRange objects which are POD structs
+	// with two TextCursors in them. So by casting to TextCursor *, we can
+	// iterate through the individual elements of the pairs.
+	return reinterpret_cast<TextCursor *>(ranges.data());
+}
+
 /*
 ** Find the index of the first entry in the range set's ranges table (viewed as
 ** an int array) whose value is equal to or greater than pos. As a side effect,
@@ -165,9 +172,10 @@ int64_t weighted_at_or_before(const T *table, int64_t base, int64_t len, T val)
 int64_t rangesetWeightedAtOrBefore(Rangeset *rangeset, TextCursor pos) {
 
 	int64_t i;
-	auto rangeTable = reinterpret_cast<TextCursor *>(rangeset->ranges_.data());
 
-	int64_t n = rangeset->ranges_.size();
+	TextCursor *rangeTable = flattenRanges(rangeset->ranges_);
+
+	auto n = static_cast<int64_t>(rangeset->ranges_.size());
 	if (n == 0) {
 		return 0;
 	}
@@ -204,30 +212,30 @@ int64_t rangesetShuffleToFrom(T *table, int64_t to, int64_t from, int64_t n, int
 	}
 
 	if (delta != 0) {
-		if (diff > 0) { /* shuffle entries down */
+		if (diff > 0) { // shuffle entries down
 			for (end = to + n; to < end; to++) {
 				table[to] = table[to + diff] + delta;
 			}
-		} else if (diff < 0) { /* shuffle entries up */
+		} else if (diff < 0) { // shuffle entries up
 			for (end = to, to += n; --to >= end;) {
 				table[to] = table[to + diff] + delta;
 			}
-		} else { /* diff == 0: just run through */
+		} else { // diff == 0: just run through
 			for (end = n; end--;) {
 				table[to++] += delta;
 			}
 		}
 	} else {
-		if (diff > 0) { /* shuffle entries down */
+		if (diff > 0) { // shuffle entries down
 			for (end = to + n; to < end; to++) {
 				table[to] = table[to + diff];
 			}
-		} else if (diff < 0) { /* shuffle entries up */
+		} else if (diff < 0) { // shuffle entries up
 			for (end = to, to += n; --to >= end;) {
 				table[to] = table[to + diff];
 			}
 		}
-		/* else diff == 0: nothing to do */
+		// else diff == 0: nothing to do
 	}
 
 	return n;
@@ -244,13 +252,13 @@ int64_t rangesetShuffleToFrom(T *table, int64_t to, int64_t from, int64_t n, int
 */
 Rangeset *rangesetInsDelMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins, int64_t del) {
 
-	auto rangeTable = reinterpret_cast<TextCursor *>(rangeset->ranges_.data());
-	int64_t n       = 2 * rangeset->ranges_.size();
+	TextCursor *rangeTable = flattenRanges(rangeset->ranges_);
+	auto n                 = 2 * static_cast<int64_t>(rangeset->ranges_.size());
 
 	int64_t i = rangesetWeightedAtOrBefore(rangeset, pos);
 
 	if (i == n) {
-		return rangeset; /* all beyond the end */
+		return rangeset; // all beyond the end
 	}
 
 	TextCursor end_del = pos + del;
@@ -261,7 +269,7 @@ Rangeset *rangesetInsDelMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins
 	   position by movement only. (They may need shuffling up or down, depending
 	   on whether ranges have been deleted or created by the change.) */
 	int64_t j = i;
-	while (j < n && rangeTable[j] <= end_del) { /* skip j to first ind beyond changes */
+	while (j < n && rangeTable[j] <= end_del) { // skip j to first ind beyond changes
 		j++;
 	}
 
@@ -294,13 +302,13 @@ Rangeset *rangesetInsDelMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins
 */
 Rangeset *rangesetInclMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins, int64_t del) {
 
-	auto rangeTable = reinterpret_cast<TextCursor *>(rangeset->ranges_.data());
-	int64_t n       = 2 * rangeset->ranges_.size();
+	TextCursor *rangeTable = flattenRanges(rangeset->ranges_);
+	auto n                 = 2 * static_cast<int64_t>(rangeset->ranges_.size());
 
 	int64_t i = rangesetWeightedAtOrBefore(rangeset, pos);
 
 	if (i == n) {
-		return rangeset; /* all beyond the end */
+		return rangeset; // all beyond the end
 	}
 
 	/* if the insert occurs at the start of a range, the following lines will
@@ -318,7 +326,7 @@ Rangeset *rangesetInclMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins,
 	   position by movement only. (They may need shuffling up or down, depending
 	   on whether ranges have been deleted or created by the change.) */
 	int64_t j = i;
-	while (j < n && rangeTable[j] <= end_del) { /* skip j to first ind beyond changes */
+	while (j < n && rangeTable[j] <= end_del) { // skip j to first ind beyond changes
 		j++;
 	}
 
@@ -352,13 +360,13 @@ Rangeset *rangesetInclMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins,
 */
 Rangeset *rangesetDelInsMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins, int64_t del) {
 
-	auto rangeTable = reinterpret_cast<TextCursor *>(rangeset->ranges_.data());
-	int64_t n       = 2 * rangeset->ranges_.size();
+	TextCursor *rangeTable = flattenRanges(rangeset->ranges_);
+	auto n                 = 2 * static_cast<int64_t>(rangeset->ranges_.size());
 
 	int64_t i = rangesetWeightedAtOrBefore(rangeset, pos);
 
 	if (i == n) {
-		return rangeset; /* all beyond the end */
+		return rangeset; // all beyond the end
 	}
 
 	TextCursor end_del = pos + del;
@@ -369,7 +377,7 @@ Rangeset *rangesetDelInsMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins
 	   position by movement only. (They may need shuffling up or down, depending
 	   on whether ranges have been deleted or created by the change.) */
 	int64_t j = i;
-	while (j < n && rangeTable[j] <= end_del) { /* skip j to first ind beyond changes */
+	while (j < n && rangeTable[j] <= end_del) { // skip j to first ind beyond changes
 		j++;
 	}
 
@@ -405,13 +413,13 @@ Rangeset *rangesetDelInsMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins
 */
 Rangeset *rangesetExclMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins, int64_t del) {
 
-	auto rangeTable = reinterpret_cast<TextCursor *>(rangeset->ranges_.data());
-	int64_t n       = 2 * rangeset->ranges_.size();
+	TextCursor *rangeTable = flattenRanges(rangeset->ranges_);
+	int64_t n              = 2 * static_cast<int64_t>(rangeset->ranges_.size());
 
 	int64_t i = rangesetWeightedAtOrBefore(rangeset, pos);
 
 	if (i == n) {
-		return rangeset; /* all beyond the end */
+		return rangeset; // all beyond the end
 	}
 
 	/* if the insert occurs at the end of a range, the following lines will
@@ -429,7 +437,7 @@ Rangeset *rangesetExclMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins,
 	   position by movement only. (They may need shuffling up or down, depending
 	   on whether ranges have been deleted or created by the change.) */
 	int64_t j = i;
-	while (j < n && rangeTable[j] <= end_del) { /* skip j to first ind beyond changes */
+	while (j < n && rangeTable[j] <= end_del) { // skip j to first ind beyond changes
 		j++;
 	}
 
@@ -462,14 +470,14 @@ Rangeset *rangesetExclMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins,
 */
 Rangeset *rangesetBreakMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins, int64_t del) {
 
-	auto rangeTable = reinterpret_cast<TextCursor *>(rangeset->ranges_.data());
+	TextCursor *rangeTable = flattenRanges(rangeset->ranges_);
 
-	int64_t n = 2 * rangeset->ranges_.size();
+	auto n = 2 * static_cast<int64_t>(rangeset->ranges_.size());
 
 	int64_t i = rangesetWeightedAtOrBefore(rangeset, pos);
 
 	if (i == n) {
-		return rangeset; /* all beyond the end */
+		return rangeset; // all beyond the end
 	}
 
 	/* if the insert occurs at the end of a range, the following lines will
@@ -487,7 +495,7 @@ Rangeset *rangesetBreakMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins,
 	   position by movement only. (They may need shuffling up or down, depending
 	   on whether ranges have been deleted or created by the change.) */
 	int64_t j = i;
-	while (j < n && rangeTable[j] <= end_del) { /* skip j to first ind beyond changes */
+	while (j < n && rangeTable[j] <= end_del) { // skip j to first ind beyond changes
 		j++;
 	}
 
@@ -495,7 +503,7 @@ Rangeset *rangesetBreakMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins,
 		rangeTable[i] = pos;
 	}
 
-	/* do we need to insert a gap? yes if pos is in a range and ins > 0 */
+	// do we need to insert a gap? yes if pos is in a range and ins > 0
 
 	/* The logic for the next statement: if i and j are both range ends, range
 	   boundaries indicated by index values between i and j (if any) have been
@@ -504,27 +512,27 @@ Rangeset *rangesetBreakMaintain(Rangeset *rangeset, TextCursor pos, int64_t ins,
 
 	bool need_gap = (is_end(i) && is_end(j) && ins > 0);
 
-	/* if we've got start-end or end-start, skip rangeTable[i] */
-	if (is_start(i) != is_start(j)) { /* one is start, other is end */
+	// if we've got start-end or end-start, skip rangeTable[i]
+	if (is_start(i) != is_start(j)) { // one is start, other is end
 		if (is_start(i)) {
 			if (rangeTable[i] == pos) {
-				rangeTable[i] = pos + ins; /* move the range start */
+				rangeTable[i] = pos + ins; // move the range start
 			}
 		}
-		i++; /* skip to next index */
+		i++; // skip to next index
 	}
 
 	/* values rangeTable[j] to rangeTable[n-1] must be adjusted by movement and placed in
 	   position. */
 
 	if (need_gap) {
-		i += 2; /* make space for the break */
+		i += 2; // make space for the break
 	}
 
-	/* adjust other position values: shuffle them up or down if necessary */
+	// adjust other position values: shuffle them up or down if necessary
 	rangesetShuffleToFrom(rangeTable, i, j, n - j, movement);
 
-	if (need_gap) { /* add the gap informations */
+	if (need_gap) { // add the gap informations
 		rangeTable[i - 2] = pos;
 		rangeTable[i - 1] = pos + ins;
 	}
@@ -587,32 +595,32 @@ int64_t Rangeset::RangesetFindRangeOfPos(TextCursor pos, bool incl_end) const {
 		return -1;
 	}
 
-	auto ranges       = reinterpret_cast<const TextCursor *>(ranges_.data()); /* { s1,e1, s2,e2, s3,e3,... } */
-	const int64_t len = ranges_.size() * 2;
+	auto ranges       = reinterpret_cast<const TextCursor *>(ranges_.data()); // { s1,e1, s2,e2, s3,e3,... }
+	const auto len    = static_cast<int64_t>(ranges_.size()) * 2;
 	const int64_t ind = at_or_before(ranges, 0, len, pos);
 
 	if (ind == len) {
-		return -1; /* beyond end */
+		return -1; // beyond end
 	}
 
 	if (is_end(ind)) {
 		if (pos < ranges[ind] || (incl_end && pos == ranges[ind])) {
-			return ind / 2; /* return the range index */
+			return ind / 2; // return the range index
 		}
-	} else { /* ind even: references start marker */
+	} else { // ind even: references start marker
 		if (pos == ranges[ind]) {
-			return ind / 2; /* return the range index */
+			return ind / 2; // return the range index
 		}
 	}
 
-	return -1; /* not in any range */
+	return -1; // not in any range
 }
 
 /*
 ** Get number of ranges in rangeset.
 */
 int64_t Rangeset::size() const {
-	return ranges_.size();
+	return static_cast<int64_t>(ranges_.size());
 }
 
 /*
@@ -657,7 +665,7 @@ int64_t Rangeset::RangesetInverse() {
 	}
 
 	RangesetRefreshRange(buffer_, first, last);
-	return ranges_.size();
+	return static_cast<int64_t>(ranges_.size());
 }
 
 /*
@@ -665,8 +673,8 @@ int64_t Rangeset::RangesetInverse() {
 */
 bool Rangeset::setColor(TextBuffer *buffer, const QString &color_name) {
 
-	/* store new color name value */
-	color_name_ = color_name.isEmpty() ? QString() : color_name; /* "" invalid */
+	// store new color name value
+	color_name_ = color_name.isEmpty() ? QString() : color_name; // "" invalid
 	color_set_  = 0;
 
 	rangesetRefreshAllRanges(buffer, this);
@@ -715,38 +723,38 @@ int64_t Rangeset::RangesetCheckRangeOfPos(TextCursor pos) {
 
 	int64_t index;
 
-	int64_t len = ranges_.size();
+	auto len = static_cast<int64_t>(ranges_.size());
 	if (ranges_.empty()) {
-		return -1; /* no ranges */
+		return -1; // no ranges
 	}
 
-	auto ranges  = reinterpret_cast<TextCursor *>(ranges_.data()); /* { s1,e1, s2,e2, s3,e3,... } */
-	int64_t last = last_index_;
+	TextCursor *ranges = flattenRanges(ranges_); // { s1,e1, s2,e2, s3,e3,... }
+	int64_t last       = last_index_;
 
-	/* try to profit from the last lookup by using its index */
+	// try to profit from the last lookup by using its index
 	if (last >= len || last < 0) {
-		last        = (len > 0) ? len - 1 : 0; /* make sure last is in range */
+		last        = (len > 0) ? len - 1 : 0; // make sure last is in range
 		last_index_ = last;
 	}
 
 	len *= 2;
 	last *= 2;
 
-	if (pos >= ranges[last]) {        /* last even: this is a start */
-		if (pos < ranges[last + 1]) { /* checking an end here */
-			return last / 2;          /* no need to change rangeset->last_index */
+	if (pos >= ranges[last]) {        // last even: this is a start
+		if (pos < ranges[last + 1]) { // checking an end here
+			return last / 2;          // no need to change rangeset->last_index
 		}
 
-		last += 2; /* not in this range: move on */
+		last += 2; // not in this range: move on
 
 		if (last == len) {
-			return -1; /* moved on too far */
+			return -1; // moved on too far
 		}
 
-		/* find the entry in the upper portion of ranges */
-		index = weighted_at_or_before(ranges, last, len, pos); /* search end only */
+		// find the entry in the upper portion of ranges
+		index = weighted_at_or_before(ranges, last, len, pos); // search end only
 	} else if (last > 0) {
-		index = weighted_at_or_before(ranges, 0, last, pos); /* search front only */
+		index = weighted_at_or_before(ranges, 0, last, pos); // search front only
 	} else {
 		index = 0;
 	}
@@ -754,20 +762,20 @@ int64_t Rangeset::RangesetCheckRangeOfPos(TextCursor pos) {
 	last_index_ = index / 2;
 
 	if (index == len) {
-		return -1; /* beyond end */
+		return -1; // beyond end
 	}
 
 	if (is_end(index)) {
 		if (pos < ranges[index]) {
-			return index / 2; /* return the range index */
+			return index / 2; // return the range index
 		}
-	} else { /* index even: references start marker */
+	} else { // index even: references start marker
 		if (pos == ranges[index]) {
-			return index / 2; /* return the range index */
+			return index / 2; // return the range index
 		}
 	}
 
-	return -1; /* not in any range */
+	return -1; // not in any range
 }
 
 /*
@@ -777,7 +785,7 @@ int64_t Rangeset::RangesetAdd(const Rangeset &other) {
 
 	if (other.ranges_.empty()) {
 		// no ranges in plusSet - nothing to do
-		return ranges_.size();
+		return static_cast<int64_t>(ranges_.size());
 	}
 
 	if (ranges_.empty()) {
@@ -788,7 +796,7 @@ int64_t Rangeset::RangesetAdd(const Rangeset &other) {
 			RangesetRefreshRange(buffer_, range.start, range.end);
 		}
 
-		return ranges_.size();
+		return static_cast<int64_t>(ranges_.size());
 	}
 
 	auto origRanges    = ranges_.cbegin();
@@ -804,11 +812,11 @@ int64_t Rangeset::RangesetAdd(const Rangeset &other) {
 	   ranges (from origSet and plusSet) - don't worry, they're both considered
 	   read-only - building the merged set in newRanges */
 
-	bool isOld = true; /* true if origRanges points to a range in oldRanges[] */
+	bool isOld = true; // true if origRanges points to a range in oldRanges[]
 
 	while (nOrigRanges > 0 || nPlusRanges > 0) {
 
-		/* make the range with the lowest start value the origRanges range */
+		// make the range with the lowest start value the origRanges range
 		if (nOrigRanges == 0 || (nPlusRanges > 0 && origRanges->start > plusRanges->start)) {
 			std::swap(origRanges, plusRanges);
 			std::swap(nOrigRanges, nPlusRanges);
@@ -823,7 +831,7 @@ int64_t Rangeset::RangesetAdd(const Rangeset &other) {
 			RangesetRefreshRange(buffer_, newRange->start, newRange->end);
 		}
 
-		/* now we must cycle over plusRanges, merging in the overlapped ranges */
+		// now we must cycle over plusRanges, merging in the overlapped ranges
 		while (nPlusRanges > 0 && newRange->end >= plusRanges->start) {
 			do {
 				if (newRange->end < plusRanges->end) {
@@ -845,9 +853,9 @@ int64_t Rangeset::RangesetAdd(const Rangeset &other) {
 		}
 	}
 
-	/* finally, forget the old rangeset values, and reallocate the new ones */
+	// finally, forget the old rangeset values, and reallocate the new ones
 	ranges_ = std::move(newRanges);
-	return ranges_.size();
+	return static_cast<int64_t>(ranges_.size());
 }
 
 /*
@@ -888,7 +896,7 @@ int64_t Rangeset::RangesetRemove(const Rangeset &other) {
 			if (nMinusRanges > 0) {
 				// keep all origRanges ranges strictly in front of *minusRanges
 				while (nOrigRanges > 0 && origRanges->end <= minusRanges->start) {
-					*newRangeOut++ = *origRanges++; /* *minusRanges beyond *origRanges: save *origRanges in *newRangeOut */
+					*newRangeOut++ = *origRanges++; // *minusRanges beyond *origRanges: save *origRanges in *newRangeOut
 					--nOrigRanges;
 				}
 			} else {
@@ -898,7 +906,7 @@ int64_t Rangeset::RangesetRemove(const Rangeset &other) {
 					--nOrigRanges;
 				}
 			}
-		} while (nMinusRanges > 0 && minusRanges->end <= origRanges->start); /* any more non-overlaps */
+		} while (nMinusRanges > 0 && minusRanges->end <= origRanges->start); // any more non-overlaps
 
 		// when we get here either we're done, or we have overlap
 		if (nOrigRanges > 0) {
@@ -912,23 +920,23 @@ int64_t Rangeset::RangesetRemove(const Rangeset &other) {
 				} else {
 					// all *origRanges inside *minusRanges
 					RangesetRefreshRange(buffer_, origRanges->start, origRanges->end);
-					origRanges++; /* all of *origRanges can be skipped */
+					origRanges++; // all of *origRanges can be skipped
 					nOrigRanges--;
 				}
 			} else {
-				/* minusRanges->start inside *origRanges: save front, adjust or skip rest */
-				*newRangeOut++ = {origRanges->start, minusRanges->start}; /* save front of *origRanges in *newRanges */
+				// minusRanges->start inside *origRanges: save front, adjust or skip rest
+				*newRangeOut++ = {origRanges->start, minusRanges->start}; // save front of *origRanges in *newRanges
 
 				if (minusRanges->end < origRanges->end) {
-					/* all *minusRanges inside *origRanges */
+					// all *minusRanges inside *origRanges
 					RangesetRefreshRange(buffer_, minusRanges->start, minusRanges->end);
-					origRanges->start = minusRanges->end; /* cut front of *origRanges upto end *minusRanges */
-					minusRanges++;                        /* dealt with this *minusRanges: move on */
+					origRanges->start = minusRanges->end; // cut front of *origRanges upto end *minusRanges
+					minusRanges++;                        // dealt with this *minusRanges: move on
 					nMinusRanges--;
 				} else {
-					/* minusRanges->end beyond *origRanges */
+					// minusRanges->end beyond *origRanges
 					RangesetRefreshRange(buffer_, minusRanges->start, origRanges->end);
-					origRanges++; /* skip rest of *origRanges */
+					origRanges++; // skip rest of *origRanges
 					nOrigRanges--;
 				}
 			}
@@ -937,7 +945,7 @@ int64_t Rangeset::RangesetRemove(const Rangeset &other) {
 
 	// finally, forget the old rangeset values, and reallocate the new ones
 	ranges_ = std::move(newRanges);
-	return ranges_.size();
+	return static_cast<int64_t>(ranges_.size());
 }
 
 /*
@@ -951,14 +959,14 @@ int64_t Rangeset::RangesetAdd(TextRange r) {
 		std::swap(r.start, r.end);
 	} else if (r.start == r.end) {
 		// no-op - empty range == no range
-		return ranges_.size();
+		return static_cast<int64_t>(ranges_.size());
 	}
 
 	// if it's the first range, just insert it
 	if (ranges_.empty()) {
 		ranges_.push_back(r);
 		RangesetRefreshRange(buffer_, r.start, r.end);
-		return ranges_.size();
+		return static_cast<int64_t>(ranges_.size());
 	}
 
 	auto next = std::lower_bound(ranges_.begin(), ranges_.end(), r);
@@ -994,7 +1002,7 @@ int64_t Rangeset::RangesetAdd(TextRange r) {
 	}
 
 	RangesetRefreshRange(buffer_, r.start, r.end);
-	return ranges_.size();
+	return static_cast<int64_t>(ranges_.size());
 }
 
 /*
@@ -1008,11 +1016,11 @@ int64_t Rangeset::RangesetRemove(TextRange r) {
 		std::swap(r.start, r.end);
 	} else if (r.start == r.end) {
 		// no-op - empty range == no range
-		return ranges_.size();
+		return static_cast<int64_t>(ranges_.size());
 	}
 
 	if (ranges_.empty()) {
-		return ranges_.size();
+		return static_cast<int64_t>(ranges_.size());
 	}
 
 	auto next = std::lower_bound(ranges_.begin(), ranges_.end(), r);
@@ -1039,7 +1047,7 @@ int64_t Rangeset::RangesetRemove(TextRange r) {
 	}
 
 	RangesetRefreshRange(buffer_, r.start, r.end);
-	return ranges_.size();
+	return static_cast<int64_t>(ranges_.size());
 }
 
 /**
@@ -1080,7 +1088,7 @@ RangesetInfo Rangeset::RangesetGetInfo() const {
 	RangesetInfo info;
 	info.defined = true;
 	info.label   = static_cast<int>(label_);
-	info.count   = ranges_.size();
+	info.count   = static_cast<int64_t>(ranges_.size());
 	info.color   = color_name_;
 	info.name    = name_;
 	info.mode    = update_name_;
diff --git a/src/Search.cpp b/src/Search.cpp
index 1cb8d296..e0a91b84 100644
--- a/src/Search.cpp
+++ b/src/Search.cpp
@@ -421,9 +421,9 @@ boost::optional<Search::Result> SearchStringEx(view::string_view string, view::s
 	case SearchType::Literal:
 		return searchLiteral(string, searchString, direction, wrap, beginPos, Qt::CaseInsensitive);
 	case SearchType::Regex:
-		return searchRegex(string, searchString, direction, wrap, beginPos, delimiters, REDFLT_STANDARD);
+		return searchRegex(string, searchString, direction, wrap, beginPos, delimiters, RE_DEFAULT_STANDARD);
 	case SearchType::RegexNoCase:
-		return searchRegex(string, searchString, direction, wrap, beginPos, delimiters, REDFLT_CASE_INSENSITIVE);
+		return searchRegex(string, searchString, direction, wrap, beginPos, delimiters, RE_DEFAULT_CASE_INSENSITIVE);
 	}
 
 	Q_UNREACHABLE();
@@ -469,12 +469,12 @@ boost::optional<std::string> Search::ReplaceAllInString(view::string_view inStri
 
 	/* rehearse the search first to determine the size of the buffer needed
 	   to hold the substituted text.  No substitution done here yet */
-	bool found       = true;
-	int replaceLen   = replaceString.size();
-	int nFound       = 0;
-	int removeLen    = 0;
-	int addLen       = 0;
-	int64_t beginPos = 0;
+	bool found        = true;
+	int replaceLen    = replaceString.size();
+	int nFound        = 0;
+	int64_t removeLen = 0;
+	int64_t addLen    = 0;
+	int64_t beginPos  = 0;
 
 	*copyStart = -1;
 
@@ -512,7 +512,7 @@ boost::optional<std::string> Search::ReplaceAllInString(view::string_view inStri
 					delimiters,
 					defaultRegexFlags(searchType));
 
-				addLen += replaceResult.size();
+				addLen += gsl::narrow<int64_t>(replaceResult.size());
 			} else {
 				addLen += replaceLen;
 			}
@@ -730,12 +730,12 @@ bool Search::isRegexType(SearchType searchType) {
 int Search::defaultRegexFlags(SearchType searchType) {
 	switch (searchType) {
 	case SearchType::Regex:
-		return REDFLT_STANDARD;
+		return RE_DEFAULT_STANDARD;
 	case SearchType::RegexNoCase:
-		return REDFLT_CASE_INSENSITIVE;
+		return RE_DEFAULT_CASE_INSENSITIVE;
 	default:
 		// We should never get here, but just in case ...
-		return REDFLT_STANDARD;
+		return RE_DEFAULT_STANDARD;
 	}
 }
 
diff --git a/src/TextArea.cpp b/src/TextArea.cpp
index 35029477..c5cabcda 100644
--- a/src/TextArea.cpp
+++ b/src/TextArea.cpp
@@ -226,7 +226,7 @@ void findTextMargins(TextBuffer *buf, TextCursor start, TextCursor end, int64_t
 ** Find a text position in buffer "buf" by counting forward or backward
 ** from a reference position with known line number
 */
-TextCursor findRelativeLineStart(const TextBuffer *buf, TextCursor referencePos, int referenceLineNum, int newLineNum) {
+TextCursor findRelativeLineStart(const TextBuffer *buf, TextCursor referencePos, int64_t referenceLineNum, int64_t newLineNum) {
 
 	if (newLineNum < referenceLineNum) {
 		return buf->BufCountBackwardNLines(referencePos, referenceLineNum - newLineNum);
@@ -259,8 +259,8 @@ void bufModifiedCB(TextCursor pos, int64_t nInserted, int64_t nDeleted, int64_t
 /*
 ** Count the number of newlines in a text string
 */
-int countNewlines(view::string_view string) {
-	return static_cast<int>(std::count(string.begin(), string.end(), '\n'));
+int64_t countNewlines(view::string_view string) {
+	return static_cast<int64_t>(std::count(string.begin(), string.end(), '\n'));
 }
 
 void ringIfNecessary(bool silent) {
@@ -926,18 +926,20 @@ TextArea::~TextArea() {
  */
 void TextArea::verticalScrollBar_valueChanged(int value) {
 
+	int64_t value64 = value;
+
 	// Limit the requested scroll position to allowable values
 	if (continuousWrap_) {
-		if ((value > topLineNum_) && (value > (nBufferLines_ + 2 + cursorVPadding_ - nVisibleLines_))) {
-			value = std::max(topLineNum_, nBufferLines_ + 2 + cursorVPadding_ - nVisibleLines_);
+		if ((value64 > topLineNum_) && (value64 > (nBufferLines_ + 2 + cursorVPadding_ - nVisibleLines_))) {
+			value64 = std::max(topLineNum_, nBufferLines_ + 2 + cursorVPadding_ - nVisibleLines_);
 		}
 	}
 
-	const int lineDelta = topLineNum_ - value;
+	const int64_t lineDelta = topLineNum_ - value64;
 
 	/* If the vertical scroll position has changed, update the line
 	   starts array and related counters in the text display */
-	offsetLineStarts(value);
+	offsetLineStarts(value64);
 
 	/* Update the scroll bar ranges, note: updating the horizontal scroll bars
 	 * can have the further side-effect of changing the horizontal scroll
@@ -1596,7 +1598,7 @@ void TextArea::measureDeletedLines(TextCursor pos, int64_t nDeleted) {
 	TextCursor retPos;
 	const int nVisLines = nVisibleLines_;
 	int nLines          = 0;
-	int retLines;
+	int64_t retLines;
 
 	/*
 	** Determine where to begin searching: either the previous newline, or
@@ -1677,7 +1679,7 @@ void TextArea::measureDeletedLines(TextCursor pos, int64_t nDeleted) {
 **   retLineStart:  Start of the line where counting ended
 **   retLineEnd:    End position of the last line traversed
 */
-void TextArea::wrappedLineCounter(const TextBuffer *buf, TextCursor startPos, TextCursor maxPos, int maxLines, bool startPosIsLineStart, TextCursor *retPos, int *retLines, TextCursor *retLineStart, TextCursor *retLineEnd) const {
+void TextArea::wrappedLineCounter(const TextBuffer *buf, TextCursor startPos, TextCursor maxPos, int64_t maxLines, bool startPosIsLineStart, TextCursor *retPos, int64_t *retLines, TextCursor *retLineStart, TextCursor *retLineEnd) const {
 
 	const QRect viewRect = viewport()->contentsRect();
 	TextCursor lineStart;
@@ -1687,8 +1689,8 @@ void TextArea::wrappedLineCounter(const TextBuffer *buf, TextCursor startPos, Te
 	bool countPixels;
 	bool foundBreak;
 	int wrapMargin;
-	int maxWidth;
-	int nLines        = 0;
+	int64_t maxWidth;
+	int64_t nLines    = 0;
 	const int tabDist = buffer_->BufGetTabDistance();
 
 	/* If there's a wrap margin set, it's more efficient to measure in columns,
@@ -1698,7 +1700,7 @@ void TextArea::wrappedLineCounter(const TextBuffer *buf, TextCursor startPos, Te
 	if (wrapMargin_ != 0) {
 		countPixels = false;
 		wrapMargin  = wrapMargin_;
-		maxWidth    = INT_MAX;
+		maxWidth    = INT64_MAX;
 	} else {
 		countPixels = true;
 		wrapMargin  = INT_MAX;
@@ -1718,8 +1720,8 @@ void TextArea::wrappedLineCounter(const TextBuffer *buf, TextCursor startPos, Te
 	** (actually, continues beyond maxPos to end of line containing maxPos,
 	** in case later characters cause a word wrap back before maxPos)
 	*/
-	int colNum = 0;
-	int width  = 0;
+	int64_t colNum = 0;
+	int64_t width  = 0;
 	for (TextCursor p = lineStart; p < buf->BufEndOfBuffer(); ++p) {
 		const char ch = buf->BufGetCharacter(p);
 
@@ -1787,8 +1789,8 @@ void TextArea::wrappedLineCounter(const TextBuffer *buf, TextCursor startPos, Te
 
 			if (p >= maxPos) {
 				*retPos       = maxPos;
-				*retLines     = maxPos < newLineStart ? nLines : nLines + 1;
-				*retLineStart = maxPos < newLineStart ? lineStart : newLineStart;
+				*retLines     = (maxPos < newLineStart) ? nLines : nLines + 1;
+				*retLineStart = (maxPos < newLineStart) ? lineStart : newLineStart;
 				*retLineEnd   = maxPos;
 				return;
 			}
@@ -1818,7 +1820,7 @@ void TextArea::wrappedLineCounter(const TextBuffer *buf, TextCursor startPos, Te
 ** Measure the width in pixels of a character "ch" at a particular column
 ** "colNum".
 */
-int TextArea::widthInPixels(char ch, int column) const {
+int TextArea::widthInPixels(char ch, int64_t column) const {
 	return lengthToWidth(TextBuffer::BufCharWidth(ch, column, buffer_->BufGetTabDistance()));
 }
 
@@ -1834,7 +1836,7 @@ int TextArea::lengthToWidth(int length) const noexcept {
 ** rather than the last newline.
 */
 TextCursor TextArea::startOfLine(TextCursor pos) const {
-	int retLines;
+	int64_t retLines;
 	TextCursor retPos;
 	TextCursor retLineStart;
 	TextCursor retLineEnd;
@@ -1848,7 +1850,7 @@ TextCursor TextArea::startOfLine(TextCursor pos) const {
 		buffer_,
 		buffer_->BufStartOfLine(pos),
 		pos,
-		INT_MAX,
+		INT64_MAX,
 		true,
 		&retPos,
 		&retLines,
@@ -1885,7 +1887,7 @@ void TextArea::findWrapRange(view::string_view deletedText, TextCursor pos, int6
 	TextCursor countFrom;
 	TextCursor countTo;
 	TextCursor adjLineStart;
-	int retLines;
+	int64_t retLines;
 	int visLineNum      = 0;
 	int nLines          = 0;
 	const int nVisLines = nVisibleLines_;
@@ -2027,7 +2029,7 @@ void TextArea::findWrapRange(view::string_view deletedText, TextCursor pos, int6
 		&deletedTextBuf,
 		buffer_->BufStartOfBuffer(),
 		TextCursor(length),
-		INT_MAX,
+		INT64_MAX,
 		true,
 		&retPos,
 		&retLines,
@@ -2056,7 +2058,7 @@ void TextArea::findWrapRange(view::string_view deletedText, TextCursor pos, int6
 */
 TextCursor TextArea::endOfLine(TextCursor pos, bool startPosIsLineStart) const {
 
-	int retLines;
+	int64_t retLines;
 	TextCursor retPos;
 	TextCursor retLineStart;
 	TextCursor retLineEnd;
@@ -2083,9 +2085,9 @@ bool TextArea::updateLineStarts(TextCursor pos, int64_t charsInserted, int64_t c
 
 	int lineOfPos;
 	int lineOfEnd;
-	const int nVisLines     = nVisibleLines_;
-	const int64_t charDelta = charsInserted - charsDeleted;
-	const int64_t lineDelta = linesInserted - linesDeleted;
+	const int nVisLines  = nVisibleLines_;
+	const auto charDelta = gsl::narrow<int>(charsInserted - charsDeleted);
+	const auto lineDelta = gsl::narrow<int>(linesInserted - linesDeleted);
 
 	/* If all of the changes were before the displayed text, the display
 	   doesn't change, just update the top line num and offset the line
@@ -2106,7 +2108,7 @@ bool TextArea::updateLineStarts(TextCursor pos, int64_t charsInserted, int64_t c
 	if (pos < firstChar_) {
 		// If some text remains in the window, anchor on that
 		if (posToVisibleLineNum(pos + charsDeleted, &lineOfEnd) && ++lineOfEnd < nVisLines && lineStarts_[lineOfEnd] != -1) {
-			topLineNum_ = std::max<int>(1, topLineNum_ + lineDelta);
+			topLineNum_ = std::max<int64_t>(1, topLineNum_ + lineDelta);
 			firstChar_  = countBackwardNLines(lineStarts_[lineOfEnd] + charDelta, lineOfEnd);
 			// Otherwise anchor on original line number and recount everything
 		} else {
@@ -2150,7 +2152,7 @@ bool TextArea::updateLineStarts(TextCursor pos, int64_t charsInserted, int64_t c
 
 			// fill in the missing line starts
 			if (linesInserted >= 0) {
-				calcLineStarts(lineOfPos + 1, lineOfPos + linesInserted);
+				calcLineStarts(lineOfPos + 1, gsl::narrow<int>(lineOfPos + linesInserted));
 			}
 
 			if (lineDelta < 0) {
@@ -2167,7 +2169,7 @@ bool TextArea::updateLineStarts(TextCursor pos, int64_t charsInserted, int64_t c
 	   of being an insert at the end of the buffer into visible blank lines */
 	if (emptyLinesVisible()) {
 		if (posToVisibleLineNum(pos, &lineOfPos)) {
-			calcLineStarts(lineOfPos, lineOfPos + linesInserted);
+			calcLineStarts(lineOfPos, gsl::narrow<int>(lineOfPos + linesInserted));
 			calcLastChar();
 		}
 		return false;
@@ -2265,21 +2267,21 @@ void TextArea::calcLastChar() {
 ** Same as BufCountBackwardNLines, but takes in to account line breaks when
 ** wrapping is turned on.
 */
-TextCursor TextArea::countBackwardNLines(TextCursor startPos, int nLines) const {
+TextCursor TextArea::countBackwardNLines(TextCursor startPos, int64_t nLines) const {
 
 	// If we're not wrapping, use the more efficient BufCountBackwardNLines
 	if (!continuousWrap_) {
 		return buffer_->BufCountBackwardNLines(startPos, nLines);
 	}
 
-	int retLines;
+	int64_t retLines;
 	TextCursor retPos;
 	TextCursor retLineStart;
 	TextCursor retLineEnd;
 	TextCursor pos = startPos;
 	while (true) {
 		const TextCursor lineStart = buffer_->BufStartOfLine(pos);
-		wrappedLineCounter(buffer_, lineStart, pos, INT_MAX, true, &retPos, &retLines, &retLineStart, &retLineEnd);
+		wrappedLineCounter(buffer_, lineStart, pos, INT64_MAX, true, &retPos, &retLines, &retLineStart, &retLineEnd);
 
 		if (retLines > nLines) {
 			return forwardNLines(lineStart, retLines - nLines, true);
@@ -2330,12 +2332,12 @@ void TextArea::redisplayRect(const QRect &rect) {
  */
 void TextArea::updateVScrollBarRange() {
 	/* NOTE(eteran) Originally, it seemed that some special handling was needed
-	 * to handle continuous wrap mode. Upong further inspection, it looks like
+	 * to handle continuous wrap mode. Upon further inspection, it looks like
 	 * nBufferLines_ properly tracks the number of conceptual lines in the
 	 * buffer, including those that are due to wrapping. So we can just use that
 	 * value regardless */
-	verticalScrollBar()->setRange(1, std::max(1, nBufferLines_ - nVisibleLines_ + 2));
-	verticalScrollBar()->setPageStep(std::max(1, nVisibleLines_ - 1));
+	verticalScrollBar()->setRange(1, gsl::narrow<int>(std::max<int64_t>(1, nBufferLines_ - nVisibleLines_ + 2)));
+	verticalScrollBar()->setPageStep(gsl::narrow<int>(std::max(1, nVisibleLines_ - 1)));
 }
 
 /**
@@ -2350,7 +2352,7 @@ void TextArea::updateVScrollBarRange() {
  * @param startPosIsLineStart
  * @return
  */
-TextCursor TextArea::forwardNLines(TextCursor startPos, int nLines, bool startPosIsLineStart) const {
+TextCursor TextArea::forwardNLines(TextCursor startPos, int64_t nLines, bool startPosIsLineStart) const {
 
 	// if we're not wrapping use more efficient BufCountForwardNLines
 	if (!continuousWrap_) {
@@ -2366,7 +2368,7 @@ TextCursor TextArea::forwardNLines(TextCursor startPos, int nLines, bool startPo
 	TextCursor retPos;
 	TextCursor retLineStart;
 	TextCursor retLineEnd;
-	int retLines;
+	int64_t retLines;
 	wrappedLineCounter(buffer_, startPos, buffer_->BufEndOfBuffer(), nLines, startPosIsLineStart, &retPos, &retLines, &retLineStart, &retLineEnd);
 	return retPos;
 }
@@ -2406,7 +2408,7 @@ void TextArea::findLineEnd(TextCursor startPos, bool startPosIsLineStart, TextCu
 	}
 
 	// use the wrapped line counter routine to count forward one line
-	int retLines;
+	int64_t retLines;
 	TextCursor retLineStart;
 	wrappedLineCounter(
 		buffer_,
@@ -2443,12 +2445,12 @@ bool TextArea::updateHScrollBarRange() {
 	const int origHOffset = horizontalScrollBar()->value();
 
 	// Scan all the displayed lines to find the width of the longest line
-	int maxWidth = 0;
+	int64_t maxWidth = 0;
 	for (int i = 0; i < nVisibleLines_ && lineStarts_[i] != -1; i++) {
 		maxWidth = std::max(measureVisLine(i), maxWidth);
 	}
 
-	horizontalScrollBar()->setRange(0, std::max(maxWidth - viewRect.width() + 1, 0));
+	horizontalScrollBar()->setRange(0, gsl::narrow<int>(std::max<int64_t>(maxWidth - viewRect.width() + 1, 0)));
 	horizontalScrollBar()->setPageStep(std::max(viewRect.width() - 100, 10));
 
 	// Return true if scroll position was changed
@@ -2515,16 +2517,16 @@ bool TextArea::posToVisibleLineNum(TextCursor pos, int *lineNum) const {
  * @param visLineNum
  * @return
  */
-int TextArea::measureVisLine(int visLineNum) const {
+int64_t TextArea::measureVisLine(int visLineNum) const {
 
-	int width                     = 0;
-	int charCount                 = 0;
-	const int lineLen             = visLineLength(visLineNum);
+	int64_t width                 = 0;
+	int64_t charCount             = 0;
+	const int64_t lineLen         = visLineLength(visLineNum);
 	const TextCursor lineStartPos = lineStarts_[visLineNum];
 
 	for (int i = 0; i < lineLen; i++) {
 		char expandedChar[TextBuffer::MAX_EXP_CHAR_LEN];
-		const int len = buffer_->BufGetExpandedChar(lineStartPos + i, charCount, expandedChar);
+		const int64_t len = buffer_->BufGetExpandedChar(lineStartPos + i, charCount, expandedChar);
 		width += (fixedFontWidth_ * len);
 		charCount += len;
 	}
@@ -3108,7 +3110,7 @@ void TextArea::drawString(QPainter *painter, uint32_t style, int x, int y, int t
 
 		// wipes out to right hand edge of widget
 		if (toX >= viewRect.left()) {
-			const int left = std::max(x, viewRect.left());
+			const auto left = std::max(x, viewRect.left());
 			painter->fillRect(QRect(left, y, toX - left, fixedFontHeight_), bground);
 		}
 
@@ -3286,7 +3288,7 @@ void TextArea::handleResize(bool widthChanged) {
 	/* if the window became taller, there may be an opportunity to display
 	   more text by scrolling down */
 	if (oldVisibleLines < newVisibleLines && topLineNum_ + nVisibleLines_ > nBufferLines_) {
-		verticalScrollBar()->setValue(std::max(1, nBufferLines_ - nVisibleLines_ + 2 + cursorVPadding_));
+		verticalScrollBar()->setValue(gsl::narrow<int>(std::max<int64_t>(1, nBufferLines_ - nVisibleLines_ + 2 + cursorVPadding_)));
 	}
 
 	/* Update the scroll bar bar parameters.
@@ -3305,14 +3307,14 @@ void TextArea::handleResize(bool widthChanged) {
 ** can pass "startPosIsLineStart" as true to make the call more efficient
 ** by avoiding the additional step of scanning back to the last newline.
 */
-int TextArea::countLines(TextCursor startPos, TextCursor endPos, bool startPosIsLineStart) {
+int64_t TextArea::countLines(TextCursor startPos, TextCursor endPos, bool startPosIsLineStart) {
 
 	// If we're not wrapping use simple (and more efficient) BufCountLines
 	if (!continuousWrap_) {
 		return buffer_->BufCountLines(startPos, endPos);
 	}
 
-	int retLines;
+	int64_t retLines;
 	TextCursor retPos;
 	TextCursor retLineStart;
 	TextCursor retLineEnd;
@@ -3321,7 +3323,7 @@ int TextArea::countLines(TextCursor startPos, TextCursor endPos, bool startPosIs
 		buffer_,
 		startPos,
 		endPos,
-		INT_MAX,
+		INT64_MAX,
 		startPosIsLineStart,
 		&retPos,
 		&retLines,
@@ -3353,7 +3355,7 @@ void TextArea::TextDBlankCursor() {
 }
 
 /**
- * @brief TextArea::TextDUnblankCursor
+ * @brief TextArea::unblankCursor
  */
 void TextArea::unblankCursor() {
 	if (!cursorOn_) {
@@ -3369,11 +3371,11 @@ void TextArea::unblankCursor() {
 ** count lines from the nearest known line start (start or end of buffer, or
 ** the closest value in the lineStarts array)
 */
-void TextArea::offsetLineStarts(int newTopLineNum) {
+void TextArea::offsetLineStarts(int64_t newTopLineNum) {
 
 	const TextCursor oldFirstChar = firstChar_;
-	const int oldTopLineNum       = topLineNum_;
-	const int lineDelta           = newTopLineNum - oldTopLineNum;
+	const int64_t oldTopLineNum   = topLineNum_;
+	const auto lineDelta          = gsl::narrow<int>(newTopLineNum - oldTopLineNum);
 	const int nVisLines           = nVisibleLines_;
 
 	// If there was no offset, nothing needs to be changed
@@ -3384,14 +3386,14 @@ void TextArea::offsetLineStarts(int newTopLineNum) {
 	/* Find the new value for firstChar by counting lines from the nearest
 	   known line start (start or end of buffer, or the closest value in the
 	   lineStarts array) */
-	const int lastLineNum = oldTopLineNum + nVisLines - 1;
+	const int64_t lastLineNum = oldTopLineNum + nVisLines - 1;
 
 	if (newTopLineNum < oldTopLineNum && newTopLineNum < -lineDelta) {
 		firstChar_ = forwardNLines(buffer_->BufStartOfBuffer(), newTopLineNum - 1, true);
 	} else if (newTopLineNum < oldTopLineNum) {
 		firstChar_ = countBackwardNLines(firstChar_, -lineDelta);
 	} else if (newTopLineNum < lastLineNum) {
-		firstChar_ = lineStarts_[newTopLineNum - oldTopLineNum];
+		firstChar_ = lineStarts_[gsl::narrow<int>(newTopLineNum - oldTopLineNum)];
 	} else if (newTopLineNum - lastLineNum < nBufferLines_ - newTopLineNum) {
 		firstChar_ = forwardNLines(lineStarts_[nVisLines - 1], newTopLineNum - lastLineNum, true);
 	} else {
@@ -3835,8 +3837,8 @@ void TextArea::TextDMakeInsertPosVisible() {
 	const QRect viewRect       = viewport()->contentsRect();
 	const TextCursor cursorPos = cursorPos_;
 	const int cursorVPadding   = cursorVPadding_;
-	int linesFromTop           = 0;
-	int topLine                = topLineNum_;
+	int64_t linesFromTop       = 0;
+	int64_t topLine            = topLineNum_;
 
 	// Don't do padding if this is a mouse operation
 	const bool do_padding = ((dragState_ == NOT_CLICKED) && (cursorVPadding > 0));
@@ -3866,10 +3868,10 @@ void TextArea::TextDMakeInsertPosVisible() {
 		// Keep the cursor away from the top or bottom of screen.
 		if (nVisibleLines_ <= 2 * cursorVPadding) {
 			topLine += (linesFromTop - nVisibleLines_ / 2);
-			topLine = std::max(topLine, 1);
+			topLine = std::max<int64_t>(topLine, 1);
 		} else if (linesFromTop < cursorVPadding) {
 			topLine -= (cursorVPadding - linesFromTop);
-			topLine = std::max(topLine, 1);
+			topLine = std::max<int64_t>(topLine, 1);
 		} else if (linesFromTop > nVisibleLines_ - cursorVPadding - 1) {
 			topLine += (linesFromTop - (nVisibleLines_ - cursorVPadding - 1));
 		}
@@ -3881,7 +3883,7 @@ void TextArea::TextDMakeInsertPosVisible() {
 	   horizontal */
 	QPoint p;
 	if (!positionToXY(cursorPos, &p)) {
-		verticalScrollBar()->setValue(topLine);
+		verticalScrollBar()->setValue(gsl::narrow<int>(topLine));
 
 		if (!positionToXY(cursorPos, &p)) {
 			return; // Give up, it's not worth it (but why does it fail?)
@@ -3897,7 +3899,7 @@ void TextArea::TextDMakeInsertPosVisible() {
 	}
 
 	// Do the scroll
-	verticalScrollBar()->setValue(topLine);
+	verticalScrollBar()->setValue(gsl::narrow<int>(topLine));
 	horizontalScrollBar()->setValue(horizOffset);
 }
 
@@ -3991,9 +3993,9 @@ void TextArea::keyMoveExtendSelection(TextCursor origPos, bool rectangular) {
 	if ((sel->hasSelection() || sel->isZeroWidth()) && sel->isRectangular() && rectangular) {
 
 		// rect -> rect
-		const int newCol          = buffer_->BufCountDispChars(buffer_->BufStartOfLine(newPos), newPos);
-		const int startCol        = std::min(rectAnchor_, newCol);
-		const int endCol          = std::max(rectAnchor_, newCol);
+		const int64_t newCol      = buffer_->BufCountDispChars(buffer_->BufStartOfLine(newPos), newPos);
+		const int64_t startCol    = std::min(rectAnchor_, newCol);
+		const int64_t endCol      = std::max(rectAnchor_, newCol);
 		const TextCursor startPos = buffer_->BufStartOfLine(std::min(anchor_, newPos));
 		const TextCursor endPos   = buffer_->BufEndOfLine(std::max(anchor_, newPos));
 
@@ -4001,7 +4003,7 @@ void TextArea::keyMoveExtendSelection(TextCursor origPos, bool rectangular) {
 
 	} else if (sel->hasSelection() && rectangular) { // plain -> rect
 
-		const int newCol = buffer_->BufCountDispChars(buffer_->BufStartOfLine(newPos), newPos);
+		const int64_t newCol = buffer_->BufCountDispChars(buffer_->BufStartOfLine(newPos), newPos);
 		TextCursor anchor;
 
 		if (std::abs(newPos - sel->start()) < std::abs(newPos - sel->end())) {
@@ -4011,7 +4013,7 @@ void TextArea::keyMoveExtendSelection(TextCursor origPos, bool rectangular) {
 		}
 
 		const TextCursor anchorLineStart = buffer_->BufStartOfLine(anchor);
-		const int rectAnchor             = buffer_->BufCountDispChars(anchorLineStart, anchor);
+		const int64_t rectAnchor         = buffer_->BufCountDispChars(anchorLineStart, anchor);
 
 		anchor_     = anchor;
 		rectAnchor_ = rectAnchor;
@@ -4050,10 +4052,10 @@ void TextArea::keyMoveExtendSelection(TextCursor origPos, bool rectangular) {
 
 	} else if (rectangular) { // no sel -> rect
 
-		const int origCol         = buffer_->BufCountDispChars(buffer_->BufStartOfLine(origPos), origPos);
-		const int newCol          = buffer_->BufCountDispChars(buffer_->BufStartOfLine(newPos), newPos);
-		const int startCol        = std::min(newCol, origCol);
-		const int endCol          = std::max(newCol, origCol);
+		const int64_t origCol     = buffer_->BufCountDispChars(buffer_->BufStartOfLine(origPos), origPos);
+		const int64_t newCol      = buffer_->BufCountDispChars(buffer_->BufStartOfLine(newPos), newPos);
+		const int64_t startCol    = std::min(newCol, origCol);
+		const int64_t endCol      = std::max(newCol, origCol);
 		const TextCursor startPos = buffer_->BufStartOfLine(std::min(origPos, newPos));
 		const TextCursor endPos   = buffer_->BufEndOfLine(std::max(origPos, newPos));
 
@@ -4491,7 +4493,7 @@ bool TextArea::wrapLine(TextBuffer *buf, int64_t bufOffset, TextCursor lineStart
 	buf->BufReplace(p, p + 1, indentStr);
 
 	*breakAt    = p;
-	*charsAdded = indentStr.size() - 1;
+	*charsAdded = static_cast<int64_t>(indentStr.size() - 1);
 	return true;
 }
 
@@ -5149,9 +5151,9 @@ void TextArea::endOfFileAP(EventFlags flags) {
 
 	cancelDrag();
 	if (flags & ScrollbarFlag) {
-		const int lastTopLine = std::max(1, nBufferLines_ - (nVisibleLines_ - 2) + cursorVPadding_);
+		const auto lastTopLine = std::max<int64_t>(1, nBufferLines_ - (nVisibleLines_ - 2) + cursorVPadding_);
 		if (lastTopLine != topLineNum_) {
-			verticalScrollBar()->setValue(lastTopLine);
+			verticalScrollBar()->setValue(gsl::narrow<int>(lastTopLine));
 		}
 	} else {
 		setInsertPosition(buffer_->BufEndOfBuffer());
@@ -5497,7 +5499,7 @@ int TextArea::offsetWrappedColumn(int row, int column) const {
 	}
 
 	const TextCursor lineStart = buffer_->BufStartOfLine(dispLineStart);
-	return column + buffer_->BufCountDispChars(lineStart, dispLineStart);
+	return gsl::narrow<int>(column + buffer_->BufCountDispChars(lineStart, dispLineStart));
 }
 
 /*
@@ -5584,7 +5586,7 @@ void TextArea::extendStartAP(QMouseEvent *event, EventFlags flags) {
 
 	const TextBuffer::Selection *sel = &buffer_->primary;
 	TextCursor anchor;
-	int rectAnchor;
+	int64_t rectAnchor;
 	TextCursor anchorLineStart;
 	int row;
 	int column;
@@ -5623,8 +5625,8 @@ void TextArea::extendStartAP(QMouseEvent *event, EventFlags flags) {
 		buffer_->BufRectSelect(
 			buffer_->BufStartOfLine(std::min(anchor, newPos)),
 			buffer_->BufEndOfLine(std::max(anchor, newPos)),
-			std::min(rectAnchor, column),
-			std::max(rectAnchor, column));
+			std::min<int64_t>(rectAnchor, column),
+			std::max<int64_t>(rectAnchor, column));
 	} else {
 		buffer_->BufSelect(std::minmax(anchor, newPos));
 	}
@@ -5696,8 +5698,8 @@ void TextArea::adjustSelection(const QPoint &coord) {
 
 		coordToUnconstrainedPosition(coord, &row, &column);
 		column                    = offsetWrappedColumn(row, column);
-		const int startCol        = std::min(rectAnchor_, column);
-		const int endCol          = std::max(rectAnchor_, column);
+		const auto startCol       = std::min<int64_t>(rectAnchor_, column);
+		const auto endCol         = std::max<int64_t>(rectAnchor_, column);
 		const TextCursor startPos = buffer_->BufStartOfLine(std::min(anchor_, newPos));
 		const TextCursor endPos   = buffer_->BufEndOfLine(std::max(anchor_, newPos));
 		buffer_->BufRectSelect(startPos, endPos, startCol, endCol);
@@ -6094,12 +6096,12 @@ void TextArea::beginBlockDrag() {
 	   selection (the position where text will actually be inserted In dragging
 	   non-rectangular selections)  */
 	if (sel.isRectangular()) {
-		dragXOffset_ = btnDownCoord_.x() + horizontalScrollBar()->value() - viewRect.left() - sel.rectStart() * fontWidth;
+		dragXOffset_ = gsl::narrow<int>(btnDownCoord_.x() + horizontalScrollBar()->value() - viewRect.left() - sel.rectStart() * fontWidth);
 	} else {
 		int x;
 		int y;
 		if (!positionToXY(sel.start(), &x, &y)) {
-			x = buffer_->BufCountDispChars(startOfLine(sel.start()), sel.start()) * fontWidth + viewRect.left() - horizontalScrollBar()->value();
+			x = gsl::narrow<int>(buffer_->BufCountDispChars(startOfLine(sel.start()), sel.start()) * fontWidth + viewRect.left() - horizontalScrollBar()->value());
 		}
 		dragXOffset_ = btnDownCoord_.x() - x;
 	}
@@ -6107,7 +6109,7 @@ void TextArea::beginBlockDrag() {
 	const TextCursor mousePos = coordToPosition(btnDownCoord_);
 	const int64_t nLines      = buffer_->BufCountLines(sel.start(), mousePos);
 
-	dragYOffset_ = nLines * fontHeight + (((btnDownCoord_.y() - viewRect.top()) % fontHeight) - fontHeight / 2);
+	dragYOffset_ = gsl::narrow<int>(nLines * fontHeight + (((btnDownCoord_.y() - viewRect.top()) % fontHeight) - fontHeight / 2));
 	dragNLines_  = buffer_->BufCountLines(sel.start(), sel.end());
 
 	/* Record the current drag insert position and the information for
@@ -6183,8 +6185,8 @@ void TextArea::blockDragSelection(const QPoint &pos, BlockDragTypes dragType) {
 	int64_t sourceInserted;
 	int64_t sourceDeleted;
 	int64_t insRectStart;
-	int insLineNum;
-	int referenceLine;
+	int64_t insLineNum;
+	int64_t referenceLine;
 
 	if (dragState_ != PRIMARY_BLOCK_DRAG) {
 		return;
@@ -6242,7 +6244,7 @@ void TextArea::blockDragSelection(const QPoint &pos, BlockDragTypes dragType) {
 	}
 
 	if (!rectangular && overlay && nLines != 0) {
-		dragXOffset -= fontWidth * (origSel.rectStart() - (origSel.start() - origSelLineStart));
+		dragXOffset -= fontWidth * gsl::narrow<int>(origSel.rectStart() - (origSel.start() - origSelLineStart));
 	}
 
 	/* If the drag operation is of a different type than the last one, and the
@@ -6299,7 +6301,7 @@ void TextArea::blockDragSelection(const QPoint &pos, BlockDragTypes dragType) {
 	int column;
 	coordToUnconstrainedPosition(
 		QPoint(
-			std::max(0, pos.x() - dragXOffset),
+			std::max(0, (pos.x() - dragXOffset)),
 			std::max(0, pos.y() - (dragYOffset_ % fontHeight))),
 		&row,
 		&column);
@@ -6419,8 +6421,8 @@ void TextArea::adjustSecondarySelection(const QPoint &coord) {
 		int column;
 		coordToUnconstrainedPosition(coord, &row, &column);
 		column                    = offsetWrappedColumn(row, column);
-		const int startCol        = std::min(rectAnchor_, column);
-		const int endCol          = std::max(rectAnchor_, column);
+		const auto startCol       = std::min<int64_t>(rectAnchor_, column);
+		const auto endCol         = std::max<int64_t>(rectAnchor_, column);
 		const TextCursor startPos = buffer_->BufStartOfLine(std::min(anchor_, newPos));
 		const TextCursor endPos   = buffer_->BufEndOfLine(std::max(anchor_, newPos));
 		buffer_->BufSecRectSelect(startPos, endPos, startCol, endCol);
@@ -6441,7 +6443,7 @@ int TextArea::offsetWrappedRow(int row) const {
 		return row;
 	}
 
-	return buffer_->BufCountLines(firstChar_, lineStarts_[row]);
+	return gsl::narrow<int>(buffer_->BufCountLines(firstChar_, lineStarts_[row]));
 }
 
 void TextArea::setWordDelimiters(const std::string &delimiters) {
@@ -6765,7 +6767,7 @@ void TextArea::exchangeSelections() {
 ** Returns the absolute (non-wrapped) line number of the first line displayed.
 ** Returns 0 if the absolute top line number is not being maintained.
 */
-int TextArea::getAbsTopLineNum() const {
+int64_t TextArea::getAbsTopLineNum() const {
 
 	if (!continuousWrap_) {
 		return topLineNum_;
@@ -6821,7 +6823,7 @@ void TextArea::setFont(const QFont &font) {
 	// force recalculation of font related parameters
 	handleResize(/*widthChanged=*/false);
 
-	// force a recalc of the line numbers
+	// force a recalculation of the line numbers
 	setLineNumCols(getLineNumCols());
 
 	horizontalScrollBar()->setSingleStep(fixedFontWidth_);
@@ -6871,8 +6873,8 @@ void TextArea::pageLeftAP(EventFlags flags) {
 			ringIfNecessary(silent);
 			return;
 		}
-		const int indent = buffer_->BufCountDispChars(lineStartPos, insertPos);
-		TextCursor pos   = buffer_->BufCountForwardDispChars(lineStartPos, std::max(0, indent - viewRect.width() / fixedFontWidth_));
+		const int64_t indent = buffer_->BufCountDispChars(lineStartPos, insertPos);
+		TextCursor pos       = buffer_->BufCountForwardDispChars(lineStartPos, std::max<int64_t>(0, indent - viewRect.width() / fixedFontWidth_));
 		setInsertPosition(pos);
 
 		horizontalScrollBar()->triggerAction(QAbstractSlider::SliderPageStepSub);
@@ -6924,12 +6926,12 @@ void TextArea::nextPageAP(EventFlags flags) {
 
 	EMIT_EVENT_0("next_page");
 
-	int lastTopLine            = std::max(1, nBufferLines_ - (nVisibleLines_ - 2) + cursorVPadding_);
+	auto lastTopLine           = std::max<int64_t>(1, nBufferLines_ - (nVisibleLines_ - 2) + cursorVPadding_);
 	const TextCursor insertPos = cursorPos_;
-	int column                 = 0;
+	int64_t column             = 0;
 	int visLineNum;
 	TextCursor lineStartPos;
-	int targetLine;
+	int64_t targetLine;
 	int pageForwardCount = std::max(1, nVisibleLines_ - 1);
 
 	const bool silent         = flags & NoBellFlag;
@@ -6944,14 +6946,14 @@ void TextArea::nextPageAP(EventFlags flags) {
 			return;
 		}
 
-		verticalScrollBar()->setValue(targetLine);
+		verticalScrollBar()->setValue(gsl::narrow<int>(targetLine));
 
 	} else if (flags & StutterFlag) { // Mac style
 		// move to bottom line of visible area
 		// if already there, page down maintaining preferred column
-		targetLine = std::max(std::min(nVisibleLines_ - 1, nBufferLines_), 0);
+		targetLine = std::max<int64_t>(std::min<int64_t>(nVisibleLines_ - 1, nBufferLines_), 0);
 		column     = preferredColumn(&visLineNum, &lineStartPos);
-		if (lineStartPos == lineStarts_[targetLine]) {
+		if (lineStartPos == lineStarts_[gsl::narrow<int>(targetLine)]) {
 			if (insertPos >= buffer_->length() || topLineNum_ == lastTopLine) {
 				ringIfNecessary(silent);
 				return;
@@ -6966,13 +6968,13 @@ void TextArea::nextPageAP(EventFlags flags) {
 
 			setInsertPosition(pos);
 
-			verticalScrollBar()->setValue(targetLine);
+			verticalScrollBar()->setValue(gsl::narrow<int>(targetLine));
 		} else {
-			TextCursor pos = lineStarts_[targetLine];
+			TextCursor pos = lineStarts_[gsl::narrow<int>(targetLine)];
 
 			while (targetLine > 0 && pos == -1) {
 				--targetLine;
-				pos = lineStarts_[targetLine];
+				pos = lineStarts_[gsl::narrow<int>(targetLine)];
 			}
 
 			if (lineStartPos == pos) {
@@ -7007,7 +7009,7 @@ void TextArea::nextPageAP(EventFlags flags) {
 		}
 
 		targetLine = topLineNum_ + nVisibleLines_ - 1;
-		targetLine = qBound(1, targetLine, lastTopLine);
+		targetLine = qBound<int64_t>(1, targetLine, lastTopLine);
 
 		TextCursor pos = forwardNLines(insertPos, nVisibleLines_ - 1, false);
 		if (maintainColumn) {
@@ -7016,7 +7018,7 @@ void TextArea::nextPageAP(EventFlags flags) {
 
 		setInsertPosition(pos);
 
-		verticalScrollBar()->setValue(targetLine);
+		verticalScrollBar()->setValue(gsl::narrow<int>(targetLine));
 
 		checkMoveSelectionChange(flags, insertPos);
 		checkAutoShowInsertPos();
@@ -7036,33 +7038,33 @@ void TextArea::previousPageAP(EventFlags flags) {
 	const TextCursor insertPos = cursorPos_;
 	int visLineNum;
 	TextCursor lineStartPos;
-	const int pageBackwardCount = std::max(1, nVisibleLines_ - 1);
+	const int64_t pageBackwardCount = std::max(1, nVisibleLines_ - 1);
 
 	const bool silent         = flags & NoBellFlag;
 	const bool maintainColumn = flags & ColumnFlag;
 
 	cancelDrag();
 	if (flags & ScrollbarFlag) { // scrollbar only
-		const int targetLine = std::max(topLineNum_ - pageBackwardCount, 1);
+		const auto targetLine = std::max<int64_t>(topLineNum_ - pageBackwardCount, 1);
 
 		if (targetLine == topLineNum_) {
 			ringIfNecessary(silent);
 			return;
 		}
 
-		verticalScrollBar()->setValue(targetLine);
+		verticalScrollBar()->setValue(gsl::narrow<int>(targetLine));
 
 	} else if (flags & StutterFlag) { // Mac style
 		// move to top line of visible area
 		// if already there, page up maintaining preferred column if required
-		int targetLine   = 0;
-		const int column = preferredColumn(&visLineNum, &lineStartPos);
-		if (lineStartPos == lineStarts_[targetLine]) {
+		int64_t targetLine   = 0;
+		const int64_t column = preferredColumn(&visLineNum, &lineStartPos);
+		if (lineStartPos == lineStarts_[gsl::narrow<int>(targetLine)]) {
 			if (topLineNum_ == 1 && (maintainColumn || column == 0)) {
 				ringIfNecessary(silent);
 				return;
 			}
-			targetLine = std::max(topLineNum_ - pageBackwardCount, 1);
+			targetLine = std::max<int64_t>(topLineNum_ - pageBackwardCount, 1);
 
 			TextCursor pos = countBackwardNLines(insertPos, pageBackwardCount);
 			if (maintainColumn) {
@@ -7071,9 +7073,9 @@ void TextArea::previousPageAP(EventFlags flags) {
 
 			setInsertPosition(pos);
 
-			verticalScrollBar()->setValue(targetLine);
+			verticalScrollBar()->setValue(gsl::narrow<int>(targetLine));
 		} else {
-			TextCursor pos = lineStarts_[targetLine];
+			TextCursor pos = lineStarts_[gsl::narrow<int>(targetLine)];
 			if (maintainColumn) {
 				pos = preferredColumnPos(column, pos);
 			}
@@ -7094,12 +7096,12 @@ void TextArea::previousPageAP(EventFlags flags) {
 			return;
 		}
 
-		int column = 0;
+		int64_t column = 0;
 		if (maintainColumn) {
 			column = preferredColumn(&visLineNum, &lineStartPos);
 		}
 
-		int targetLine = topLineNum_ - (nVisibleLines_ - 1);
+		int64_t targetLine = topLineNum_ - (nVisibleLines_ - 1);
 		if (targetLine < 1) {
 			targetLine = 1;
 		}
@@ -7111,7 +7113,7 @@ void TextArea::previousPageAP(EventFlags flags) {
 
 		setInsertPosition(pos);
 
-		verticalScrollBar()->setValue(targetLine);
+		verticalScrollBar()->setValue(gsl::narrow<int>(targetLine));
 
 		checkMoveSelectionChange(flags, insertPos);
 		checkAutoShowInsertPos();
@@ -7130,7 +7132,7 @@ void TextArea::previousPageAP(EventFlags flags) {
 ** visible line index (-1 if not visible) and the lineStartPos
 ** of the current insert position.
 */
-int TextArea::preferredColumn(int *visLineNum, TextCursor *lineStartPos) {
+int64_t TextArea::preferredColumn(int *visLineNum, TextCursor *lineStartPos) {
 
 	/* Find the position of the start of the line.  Use the line starts array
 	if possible, to avoid unbounded line-counting in continuous wrap mode */
@@ -7142,14 +7144,16 @@ int TextArea::preferredColumn(int *visLineNum, TextCursor *lineStartPos) {
 	}
 
 	// Decide what column to move to, if there's a preferred column use that
-	return (cursorPreferredCol_ >= 0) ? cursorPreferredCol_ : buffer_->BufCountDispChars(*lineStartPos, cursorPos_);
+	return (cursorPreferredCol_ >= 0)
+			   ? cursorPreferredCol_
+			   : buffer_->BufCountDispChars(*lineStartPos, cursorPos_);
 }
 
 /*
 ** Return the insert position of the requested column given
 ** the lineStartPos.
 */
-TextCursor TextArea::preferredColumnPos(int column, TextCursor lineStartPos) {
+TextCursor TextArea::preferredColumnPos(int64_t column, TextCursor lineStartPos) {
 
 	TextCursor newPos = buffer_->BufCountForwardDispChars(lineStartPos, column);
 	if (continuousWrap_) {
@@ -7498,7 +7502,7 @@ TextCursor TextArea::lineAndColToPosition(Location loc) const {
  * @param column
  * @return
  */
-TextCursor TextArea::lineAndColToPosition(int line, int column) const {
+TextCursor TextArea::lineAndColToPosition(int64_t line, int64_t column) const {
 
 	Location loc;
 	loc.line   = line;
@@ -7640,7 +7644,7 @@ int TextArea::maximumFontWidth() const {
  * @brief TextArea::TextNumVisibleLines
  * @return
  */
-int TextArea::TextNumVisibleLines() const {
+int64_t TextArea::TextNumVisibleLines() const {
 	return nVisibleLines_;
 }
 
@@ -7764,7 +7768,9 @@ void TextArea::scrollUpAP(int count, ScrollUnit units, EventFlags flags) {
 		nLines *= nVisibleLines_;
 	}
 
-	verticalScrollBar()->setValue(verticalScrollBar()->value() - nLines);
+	const int prevValue = verticalScrollBar()->value();
+	Q_ASSERT(prevValue > nLines);
+	verticalScrollBar()->setValue(prevValue - nLines);
 }
 
 void TextArea::scrollDownAP(int count, ScrollUnit units, EventFlags flags) {
@@ -7776,7 +7782,8 @@ void TextArea::scrollDownAP(int count, ScrollUnit units, EventFlags flags) {
 		nLines *= nVisibleLines_;
 	}
 
-	verticalScrollBar()->setValue(verticalScrollBar()->value() + nLines);
+	const int prevValue = verticalScrollBar()->value();
+	verticalScrollBar()->setValue(prevValue + nLines);
 }
 
 void TextArea::scrollLeftAP(int pixels, EventFlags flags) {
@@ -7879,38 +7886,38 @@ void TextArea::makeSelectionVisible() {
 		const int rows         = getRows();
 		const int scrollOffset = rows / 3;
 
-		const int topLineNum = verticalScrollBar()->value();
+		const int64_t topLineNum = verticalScrollBar()->value();
 
 		if (right > lastChar) {
 			// End of sel. is below bottom of screen
-			const int leftLineNum   = topLineNum + countLines(topChar, left, /*startPosIsLineStart=*/false);
-			const int targetLineNum = topLineNum + scrollOffset;
+			const int64_t leftLineNum   = topLineNum + countLines(topChar, left, /*startPosIsLineStart=*/false);
+			const int64_t targetLineNum = topLineNum + scrollOffset;
 
 			if (leftLineNum >= targetLineNum) {
 				// Start of sel. is not between top & target
-				int linesToScroll = countLines(lastChar, right, /*startPosIsLineStart=*/false) + scrollOffset;
+				int64_t linesToScroll = countLines(lastChar, right, /*startPosIsLineStart=*/false) + scrollOffset;
 				if (leftLineNum - linesToScroll < targetLineNum) {
 					linesToScroll = leftLineNum - targetLineNum;
 				}
 
 				// Scroll start of selection to the target line
-				verticalScrollBar()->setValue(topLineNum + linesToScroll);
+				verticalScrollBar()->setValue(gsl::narrow<int>(topLineNum + linesToScroll));
 			}
 		} else if (left < topChar) {
-			// Start of sel. is above top of screen
-			const int lastLineNum   = topLineNum + rows;
-			const int rightLineNum  = lastLineNum - countLines(right, lastChar, /*startPosIsLineStart=*/false);
-			const int targetLineNum = lastLineNum - scrollOffset;
+			// Start of sel. is above top of screenF
+			const int64_t lastLineNum   = topLineNum + rows;
+			const int64_t rightLineNum  = lastLineNum - countLines(right, lastChar, /*startPosIsLineStart=*/false);
+			const int64_t targetLineNum = lastLineNum - scrollOffset;
 
 			if (rightLineNum <= targetLineNum) {
 				// End of sel. is not between bottom & target
-				int linesToScroll = countLines(left, topChar, /*startPosIsLineStart=*/false) + scrollOffset;
+				int64_t linesToScroll = countLines(left, topChar, /*startPosIsLineStart=*/false) + scrollOffset;
 				if (rightLineNum + linesToScroll > targetLineNum) {
 					linesToScroll = targetLineNum - rightLineNum;
 				}
 
 				// Scroll end of selection to the target line
-				verticalScrollBar()->setValue(topLineNum - linesToScroll);
+				verticalScrollBar()->setValue(gsl::narrow<int>(topLineNum - linesToScroll));
 			}
 		}
 	}
diff --git a/src/TextArea.h b/src/TextArea.h
index 30e8502c..c1883001 100644
--- a/src/TextArea.h
+++ b/src/TextArea.h
@@ -198,42 +198,39 @@ private Q_SLOTS:
 	void secondaryStartAP(QMouseEvent *event, TextArea::EventFlags flags = NoneFlag);
 
 public:
-	DocumentWidget *document() const;
-	QColor getBackgroundColor() const;
-	QColor getForegroundColor() const;
-	QMargins getMargins() const;
-	QTimer *cursorBlinkTimer() const;
-	TextBuffer *buffer() const;
-	TextCursor lineAndColToPosition(int line, int column) const;
-	TextCursor firstVisiblePos() const;
-	TextCursor cursorPos() const;
-	TextCursor TextLastVisiblePos() const;
 	boost::optional<Location> positionToLineAndCol(TextCursor pos) const;
-	TextCursor lineAndColToPosition(Location loc) const;
-	TextBuffer *styleBuffer() const;
-	int TextDGetCalltipID(int id) const;
-	int maximumFontWidth() const;
-	int minimumFontWidth() const;
-	int TextDShowCalltip(const QString &text, bool anchored, CallTipPosition pos, TipHAlignMode hAlign, TipVAlignMode vAlign, TipAlignMode alignMode);
-	int TextNumVisibleLines() const;
-	int TextVisibleWidth() const;
+	DocumentWidget *document() const;
+	int fixedFontHeight() const;
+	int fixedFontWidth() const;
 	int getColumns() const;
 	int getEmulateTabs() const;
 	int getLineNumCols() const;
 	int getRows() const;
 	int getWrapMargin() const;
 	int lineNumberAreaWidth() const;
-	int fixedFontHeight() const;
-	int fixedFontWidth() const;
-	int64_t TextFirstVisibleLine() const;
+	int maximumFontWidth() const;
+	int minimumFontWidth() const;
+	int TextDGetCalltipID(int id) const;
+	int TextDShowCalltip(const QString &text, bool anchored, CallTipPosition pos, TipHAlignMode hAlign, TipVAlignMode vAlign, TipAlignMode alignMode);
+	int TextVisibleWidth() const;
 	int64_t getBufferLinesCount() const;
+	int64_t TextFirstVisibleLine() const;
+	int64_t TextNumVisibleLines() const;
+	QColor getBackgroundColor() const;
+	QColor getForegroundColor() const;
+	QMargins getMargins() const;
+	QTimer *cursorBlinkTimer() const;
 	std::string TextGetWrapped(TextCursor startPos, TextCursor endPos);
-	void removeWidgetHighlight();
+	TextBuffer *buffer() const;
+	TextBuffer *styleBuffer() const;
+	TextCursor cursorPos() const;
+	TextCursor firstVisiblePos() const;
+	TextCursor lineAndColToPosition(int64_t line, int64_t column) const;
+	TextCursor lineAndColToPosition(Location loc) const;
+	TextCursor TextLastVisiblePos() const;
 	void attachHighlightData(TextBuffer *styleBuffer, const std::vector<StyleTableEntry> &styleTable, uint32_t unfinishedStyle, UnfinishedStyleCallback unfinishedHighlightCB, void *user);
-	void TextDKillCalltip(int id);
-	void TextDMaintainAbsLineNum(bool state);
-	void TextSetCursorPos(TextCursor pos);
 	void makeSelectionVisible();
+	void removeWidgetHighlight();
 	void setAutoIndent(bool value);
 	void setAutoShowInsertPos(bool value);
 	void setAutoWrap(bool value);
@@ -251,6 +248,9 @@ private Q_SLOTS:
 	void setStyleBuffer(TextBuffer *buffer);
 	void setWordDelimiters(const std::string &delimiters);
 	void setWrapMargin(int value);
+	void TextDKillCalltip(int id);
+	void TextDMaintainAbsLineNum(bool state);
+	void TextSetCursorPos(TextCursor pos);
 
 public:
 	void bufPreDeleteCallback(TextCursor pos, int64_t nDeleted);
@@ -258,13 +258,12 @@ private Q_SLOTS:
 
 private:
 	QColor getRangesetColor(size_t ind, QColor bground) const;
-	QShortcut *createShortcut(const QString &name, const QKeySequence &keySequence, const char *member);
-	TextCursor preferredColumnPos(int column, TextCursor lineStartPos);
+	TextCursor preferredColumnPos(int64_t column, TextCursor lineStartPos);
 	TextCursor coordToPosition(const QPoint &coord) const;
-	TextCursor countBackwardNLines(TextCursor startPos, int nLines) const;
+	TextCursor countBackwardNLines(TextCursor startPos, int64_t nLines) const;
 	TextCursor endOfLine(TextCursor pos, bool startPosIsLineStart) const;
 	TextCursor endOfWord(TextCursor pos) const;
-	TextCursor forwardNLines(TextCursor startPos, int nLines, bool startPosIsLineStart) const;
+	TextCursor forwardNLines(TextCursor startPos, int64_t nLines, bool startPosIsLineStart) const;
 	TextCursor startOfLine(TextCursor pos) const;
 	TextCursor startOfWord(TextCursor pos) const;
 	TextCursor xyToPos(const QPoint &pos, PositionType posType) const;
@@ -293,14 +292,14 @@ private Q_SLOTS:
 	boost::optional<TextCursor> spanForward(TextBuffer *buf, TextCursor startPos, view::string_view searchChars, bool ignoreSpace) const;
 	int offsetWrappedColumn(int row, int column) const;
 	int offsetWrappedRow(int row) const;
-	int preferredColumn(int *visLineNum, TextCursor *lineStartPos);
-	int countLines(TextCursor startPos, TextCursor endPos, bool startPosIsLineStart);
-	int getAbsTopLineNum() const;
+	int64_t preferredColumn(int *visLineNum, TextCursor *lineStartPos);
+	int64_t countLines(TextCursor startPos, TextCursor endPos, bool startPosIsLineStart);
+	int64_t getAbsTopLineNum() const;
 	int getLineNumWidth() const;
 	int lengthToWidth(int length) const noexcept;
-	int measureVisLine(int visLineNum) const;
+	int64_t measureVisLine(int visLineNum) const;
 	int visLineLength(int visLineNum) const;
-	int widthInPixels(char ch, int column) const;
+	int widthInPixels(char ch, int64_t column) const;
 	std::string createIndentString(TextBuffer *buf, int64_t bufOffset, TextCursor lineStartPos, TextCursor lineEndPos, int *column);
 	std::string wrapText(view::string_view startLine, view::string_view text, int64_t bufOffset, int wrapMargin, int64_t *breakBefore);
 	uint32_t styleOfPos(TextCursor lineStartPos, size_t lineLen, size_t lineIndex, int64_t dispIndex, int thisChar) const;
@@ -344,7 +343,7 @@ private Q_SLOTS:
 	void keyMoveExtendSelection(TextCursor origPos, bool rectangular);
 	void measureDeletedLines(TextCursor pos, int64_t nDeleted);
 	void offsetAbsLineNum(TextCursor oldFirstChar);
-	void offsetLineStarts(int newTopLineNum);
+	void offsetLineStarts(int64_t newTopLineNum);
 	void redisplayLine(QPainter *painter, int visLineNum, int leftClip, int rightClip);
 	void redisplayLine(int visLineNum, int leftCharIndex, int rightCharIndex);
 	void redisplayRange(TextCursor start, TextCursor end);
@@ -363,7 +362,7 @@ private Q_SLOTS:
 	void updateCalltip(int calltipID);
 	void updateFontMetrics(const QFont &font);
 	void updateVScrollBarRange();
-	void wrappedLineCounter(const TextBuffer *buf, TextCursor startPos, TextCursor maxPos, int maxLines, bool startPosIsLineStart, TextCursor *retPos, int *retLines, TextCursor *retLineStart, TextCursor *retLineEnd) const;
+	void wrappedLineCounter(const TextBuffer *buf, TextCursor startPos, TextCursor maxPos, int64_t maxLines, bool startPosIsLineStart, TextCursor *retPos, int64_t *retLines, TextCursor *retLineStart, TextCursor *retLineEnd) const;
 	void xyToUnconstrainedPos(const QPoint &pos, int *row, int *column, PositionType posType) const;
 	void xyToUnconstrainedPos(int x, int y, int *row, int *column, PositionType posType) const;
 
@@ -414,29 +413,29 @@ private Q_SLOTS:
 	bool smartIndent_                              = false;
 	bool suppressResync_                           = false; // Suppress resynchronization of line starts during buffer updates
 	bool widerBold_                                = false;
-	int absTopLineNum_                             = 1; // In continuous wrap mode, the line number of the top line if the text were not wrapped (note that this is only maintained as needed).
+	int64_t absTopLineNum_                         = 1; // In continuous wrap mode, the line number of the top line if the text were not wrapped (note that this is only maintained as needed).
+	int64_t dragDeleted_                           = 0; // # of characters deleted at drag destination in last drag position
+	int64_t dragInserted_                          = 0; // # of characters inserted at drag destination in last drag position
+	int64_t dragNLines_                            = 0; // # of newlines in text being drag'd
+	int64_t dragRectStart_                         = 0;
+	int64_t dragSourceDeleted_                     = 0;  // # of chars. deleted when move source text was deleted
+	int64_t dragSourceInserted_                    = 0;  // # of chars. inserted when move source text was inserted
+	int64_t nBufferLines_                          = 0;  // # of newlines in the buffer
+	int64_t nLinesDeleted_                         = 0;  // Number of lines deleted during buffer modification (only used when resynchronization is suppressed)
+	int64_t topLineNum_                            = 1;  // Line number of top displayed line of file (first line of file is 1)
+	int64_t cursorPreferredCol_                    = -1; // Column for vert. cursor movement
+	int dragXOffset_                               = 0;  // offsets between cursor location and actual insertion point in drag
+	int dragYOffset_                               = 0;  // offsets between cursor location and actual insertion point in drag
+	int nVisibleLines_                             = 1;  // # of visible (displayed) lines
 	int clickCount_                                = 0;
-	int cursorPreferredCol_                        = -1; // Column for vert. cursor movement
 	int cursorVPadding_                            = 0;
-	int dragXOffset_                               = 0; // offsets between cursor location and actual insertion point in drag
-	int dragYOffset_                               = 0; // offsets between cursor location and actual insertion point in drag
 	int emTabsBeforeCursor_                        = 0; // If non-zero, number of consecutive emulated tabs just entered.  Saved so chars can be deleted as a unit
 	int emulateTabs_                               = 0;
 	int fixedFontHeight_                           = 0;
 	int fixedFontWidth_                            = 0; // Font width if all current fonts are fixed and match in width
 	int lineNumCols_                               = 0;
-	int nBufferLines_                              = 0; // # of newlines in the buffer
-	int nLinesDeleted_                             = 0; // Number of lines deleted during buffer modification (only used when resynchronization is suppressed)
-	int nVisibleLines_                             = 1; // # of visible (displayed) lines
-	int rectAnchor_                                = 0; // Anchor for rectangular drag operations
-	int topLineNum_                                = 1; // Line number of top displayed line of file (first line of file is 1)
+	int64_t rectAnchor_                            = 0; // Anchor for rectangular drag operations
 	int wrapMargin_                                = 0;
-	int64_t dragDeleted_                           = 0; // # of characters deleted at drag destination in last drag position
-	int64_t dragInserted_                          = 0; // # of characters inserted at drag destination in last drag position
-	int64_t dragNLines_                            = 0; // # of newlines in text being drag'd
-	int64_t dragRectStart_                         = 0;
-	int64_t dragSourceDeleted_                     = 0;       // # of chars. deleted when move source text was deleted
-	int64_t dragSourceInserted_                    = 0;       // # of chars. inserted when move source text was inserted
 	void *highlightCBArg_                          = nullptr; // Arg to unfinishedHighlightCB
 
 private:
diff --git a/src/macro.cpp b/src/macro.cpp
index 7c500be7..6b229910 100644
--- a/src/macro.cpp
+++ b/src/macro.cpp
@@ -4256,7 +4256,7 @@ std::error_code rangesetIncludesPosMS(DocumentWidget *document, Arguments argume
 	}
 
 	const int64_t maxpos = buffer->length();
-	int rangeIndex;
+	int64_t rangeIndex;
 	if (pos < 0 || pos > maxpos) {
 		rangeIndex = 0;
 	} else {
diff --git a/src/shift.cpp b/src/shift.cpp
index 7b05211d..66772621 100644
--- a/src/shift.cpp
+++ b/src/shift.cpp
@@ -305,11 +305,11 @@ TextCursor findParagraphStart(TextBuffer *buf, TextCursor startPos) {
 	return parStart > buf->BufStartOfBuffer() ? parStart : buf->BufStartOfBuffer();
 }
 
-int countLines(view::string_view text) {
+int64_t countLines(view::string_view text) {
 	return std::count(text.begin(), text.end(), '\n') + 1;
 }
 
-int countLines(const QString &text) {
+int64_t countLines(const QString &text) {
 	return std::count(text.begin(), text.end(), QLatin1Char('\n')) + 1;
 }
 
@@ -785,7 +785,7 @@ void fillSelection(DocumentWidget *document, TextArea *area) {
 ** shift lines left and right in a multi-line text string.
 */
 QString shiftText(const QString &text, ShiftDirection direction, bool tabsAllowed, int tabDist, int nChars) {
-	int bufLen;
+	int64_t bufLen;
 
 	/*
 	** Shift left adds a maximum of tabDist-2 characters per line
@@ -799,7 +799,7 @@ QString shiftText(const QString &text, ShiftDirection direction, bool tabsAllowe
 	}
 
 	QString shiftedText;
-	shiftedText.reserve(bufLen);
+	shiftedText.reserve(gsl::narrow<int>(bufLen));
 
 	auto shiftedPtr = std::back_inserter(shiftedText);
 
@@ -814,7 +814,9 @@ QString shiftText(const QString &text, ShiftDirection direction, bool tabsAllowe
 
 			auto segment = text.mid(gsl::narrow<int>(lineStartPtr - text.data()));
 
-			QString shiftedLineString = (direction == ShiftDirection::Right) ? shiftLineRight(segment, textPtr - lineStartPtr, tabsAllowed, tabDist, nChars) : shiftLineLeft(segment, textPtr - lineStartPtr, tabDist, nChars);
+			QString shiftedLineString = (direction == ShiftDirection::Right)
+											? shiftLineRight(segment, textPtr - lineStartPtr, tabsAllowed, tabDist, nChars)
+											: shiftLineLeft(segment, textPtr - lineStartPtr, tabDist, nChars);
 
 			std::copy(shiftedLineString.begin(), shiftedLineString.end(), shiftedPtr);