===================================================================
--- original.js
+++ change.js
@@ -182,8 +182,138 @@
 
 /**** 
 * Game Code
 ****/
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+		return typeof o;
+	} : function (o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+function _classCallCheck(instance, Constructor) {
+	if (!(instance instanceof Constructor)) {
+		throw new TypeError("Cannot call a class as a function");
+	}
+}
+function _defineProperties(target, props) {
+	for (var i = 0; i < props.length; i++) {
+		var descriptor = props[i];
+		descriptor.enumerable = descriptor.enumerable || false;
+		descriptor.configurable = true;
+		if ("value" in descriptor) {
+			descriptor.writable = true;
+		}
+		Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+	}
+}
+function _createClass(Constructor, protoProps, staticProps) {
+	if (protoProps) {
+		_defineProperties(Constructor.prototype, protoProps);
+	}
+	if (staticProps) {
+		_defineProperties(Constructor, staticProps);
+	}
+	Object.defineProperty(Constructor, "prototype", {
+		writable: false
+	});
+	return Constructor;
+}
+function _toPropertyKey(t) {
+	var i = _toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : String(i);
+}
+function _toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) {
+		return t;
+	}
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) {
+			return i;
+		}
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+function _inherits(subClass, superClass) {
+	if (typeof superClass !== "function" && superClass !== null) {
+		throw new TypeError("Super expression must either be null or a function");
+	}
+	subClass.prototype = Object.create(superClass && superClass.prototype, {
+		constructor: {
+			value: subClass,
+			writable: true,
+			configurable: true
+		}
+	});
+	Object.defineProperty(subClass, "prototype", {
+		writable: false
+	});
+	if (superClass) {
+		_setPrototypeOf(subClass, superClass);
+	}
+}
+function _setPrototypeOf(o, p) {
+	_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+		o.__proto__ = p;
+		return o;
+	};
+	return _setPrototypeOf(o, p);
+}
+function _createSuper(Derived) {
+	var hasNativeReflectConstruct = _isNativeReflectConstruct();
+	return function _createSuperInternal() {
+		var Super = _getPrototypeOf(Derived),
+			result;
+		if (hasNativeReflectConstruct) {
+			var NewTarget = _getPrototypeOf(this).constructor;
+			result = Reflect.construct(Super, arguments, NewTarget);
+		} else {
+			result = Super.apply(this, arguments);
+		}
+		return _possibleConstructorReturn(this, result);
+	};
+}
+function _possibleConstructorReturn(self, call) {
+	if (call && (_typeof(call) === "object" || typeof call === "function")) {
+		return call;
+	} else if (call !== void 0) {
+		throw new TypeError("Derived constructors may only return object or undefined");
+	}
+	return _assertThisInitialized(self);
+}
+function _assertThisInitialized(self) {
+	if (self === void 0) {
+		throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+	}
+	return self;
+}
+function _isNativeReflectConstruct() {
+	if (typeof Reflect === "undefined" || !Reflect.construct) {
+		return false;
+	}
+	if (Reflect.construct.sham) {
+		return false;
+	}
+	if (typeof Proxy === "function") {
+		return true;
+	}
+	try {
+		Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+function _getPrototypeOf(o) {
+	_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+		return o.__proto__ || Object.getPrototypeOf(o);
+	};
+	return _getPrototypeOf(o);
+}
 var slideAmount = 6.5;
 var slideAmountVertical = 0.10; // Reduced speed for smoother vertical movement
 var moveSegmentsVertically = false;
 var verticalSlideThreshold = 500; // Define a global threshold for vertical sliding
@@ -246,11 +376,44 @@
 horizontalAxis.width = game.width;
 horizontalAxis.height = 10;
 horizontalAxis.x = 0; // Move axis to the left side of the screen
 // Create and draw fixed horizontal Marker axis
-// Create and draw vertical axis
-var verticalAxis = game.addChild(new Axis(true)); // true indicates this is a vertical axis
-verticalAxis.drawAxis();
+// Create and draw vertical axis with dynamic values
+var DynamicVerticalAxis = /*#__PURE__*/function (_Axis) {
+	_inherits(DynamicVerticalAxis, _Axis);
+	var _super = _createSuper(DynamicVerticalAxis);
+	function DynamicVerticalAxis() {
+		var _this;
+		_classCallCheck(this, DynamicVerticalAxis);
+		_this = _super.call(this, true);
+		_this.drawAxisWithValues();
+		return _this;
+	}
+	_createClass(DynamicVerticalAxis, [{
+		key: "drawAxisWithValues",
+		value: function drawAxisWithValues() {
+			this.drawAxis();
+			var step = 50;
+			var currentValue = 0;
+			var axisHeight = game.height * 0.5;
+			var numSteps = axisHeight / (dollarToYPixelRatio * step);
+			for (var i = 0; i <= numSteps; i++) {
+				var valueText = new Text2('$' + currentValue, {
+					size: 30,
+					fill: "#ffffff"
+				});
+				valueText.anchor.set(0.5, 0);
+				valueText.rotation = -Math.PI / 2;
+				valueText.x = -10;
+				valueText.y = game.height * 0.75 - i * dollarToYPixelRatio * step;
+				this.addChild(valueText);
+				currentValue += step;
+			}
+		}
+	}]);
+	return DynamicVerticalAxis;
+}(Axis);
+var verticalAxis = game.addChild(new DynamicVerticalAxis());
 verticalAxis.rotation = Math.PI / 2; // Rotate to make it vertical
 verticalAxis.x = 20; // Move axis to the left side of the screen
 verticalAxis.width = game.height;
 verticalAxis.height = 10;