diff --git a/sam-neurons-words.js b/sam-neurons-words.js
new file mode 100644
index 0000000..fb4737b
--- /dev/null
+++ b/sam-neurons-words.js
@@ -0,0 +1,132 @@
+class NeuralNetwork {
+    constructor(inputNodes, hiddenNodes, outputNodes) {
+        this.inputNodes = inputNodes;
+        this.hiddenNodes = hiddenNodes;
+        this.outputNodes = outputNodes;
+
+        // Initialize weights with random values between -1 and 1
+        this.weights_ih = this.initializeWeights(this.hiddenNodes, this.inputNodes);
+        this.weights_ho = this.initializeWeights(this.outputNodes, this.hiddenNodes);
+
+        // Biases
+        this.bias_h = this.initializeBiases(this.hiddenNodes);
+        this.bias_o = this.initializeBiases(this.outputNodes);
+
+        // Learning rate
+        this.learningRate = 0.1;
+    }
+
+    // Helper method to initialize weights
+    initializeWeights(rows, cols) {
+        return Array(rows).fill().map(() => Array(cols).fill().map(() => Math.random() * 2 - 1));
+    }
+
+    // Helper method to initialize biases
+    initializeBiases(size) {
+        return Array(size).fill().map(() => Math.random() * 2 - 1);
+    }
+
+    // Sigmoid activation function
+    sigmoid(x) {
+        return 1 / (1 + Math.exp(-x));
+    }
+
+    // Sigmoid derivative (used for backpropagation)
+    sigmoidDerivative(x) {
+        return x * (1 - x);
+    }
+
+    // Feedforward function
+    feedforward(inputArray) {
+        // Calculate hidden layer outputs
+        let hidden = this.weights_ih.map((row, i) => 
+            this.sigmoid(row.reduce((sum, weight, j) => sum + weight * inputArray[j], 0) + this.bias_h[i])
+        );
+
+        // Calculate output layer outputs
+        let output = this.weights_ho.map((row, i) => 
+            this.sigmoid(row.reduce((sum, weight, j) => sum + weight * hidden[j], 0) + this.bias_o[i])
+        );
+
+        return output;
+    }
+
+    // Train the network
+    train(inputArray, targetArray) {
+        // Feedforward
+        let hidden = this.weights_ih.map((row, i) => 
+            this.sigmoid(row.reduce((sum, weight, j) => sum + weight * inputArray[j], 0) + this.bias_h[i])
+        );
+        let outputs = this.weights_ho.map((row, i) => 
+            this.sigmoid(row.reduce((sum, weight, j) => sum + weight * hidden[j], 0) + this.bias_o[i])
+        );
+
+        // Calculate the output errors
+        let outputErrors = targetArray.map((target, i) => target - outputs[i]);
+
+        // Calculate output gradients
+        let outputGradients = outputs.map((output, i) => 
+            this.sigmoidDerivative(output) * outputErrors[i] * this.learningRate
+        );
+
+        // Calculate hidden errors
+        let hiddenErrors = this.weights_ho[0].map((_, i) => 
+            this.weights_ho.reduce((sum, row) => sum + row[i] * outputErrors[0], 0)
+        );
+
+        // Calculate hidden gradients
+        let hiddenGradients = hidden.map((h, i) => 
+            this.sigmoidDerivative(h) * hiddenErrors[i] * this.learningRate
+        );
+
+        // Update weights and biases
+        this.weights_ho = this.weights_ho.map((row, i) => 
+            row.map((weight, j) => weight + outputGradients[i] * hidden[j])
+        );
+        this.weights_ih = this.weights_ih.map((row, i) => 
+            row.map((weight, j) => weight + hiddenGradients[i] * inputArray[j])
+        );
+        this.bias_o = this.bias_o.map((bias, i) => bias + outputGradients[i]);
+        this.bias_h = this.bias_h.map((bias, i) => bias + hiddenGradients[i]);
+    }
+}
+
+// Example usage:
+let nn = new NeuralNetwork(3, 4, 1);  // Increased hidden nodes to 4
+
+// Example dataset (XOR problem)
+let strings = ["hello", "neural", "world"]
+
+let inputs = [
+    [0, 0, 0],
+    [1, 0, 0],
+    [1, 0, 1],
+    [1, 1, 1]
+];
+let targets = [
+    [0],
+    [1],
+    [2],
+    [3]
+];
+
+// Training the neural network
+for (let i = 0; i < 50000; i++) {  // Increased training iterations
+    let index = Math.floor(Math.random() * 4);
+    nn.train(inputs[index], targets[index]);
+}
+
+// Testing the neural network
+let feeds = inputs;
+
+
+feeds.forEach((item, index) => {
+let feededVal = Math.round(nn.feedforward(item))
+console.log([feededVal, item])
+if (Math.round(feededVal)  == 1) {
+let sum = 0;
+item.forEach(num => sum += num);
+try { console.log(strings[sum - 1]) } catch {}
+}
+
+})
diff --git a/sam-neurons.js b/sam-neurons.js
new file mode 100644
index 0000000..3445d17
--- /dev/null
+++ b/sam-neurons.js
@@ -0,0 +1,122 @@
+class NeuralNetwork {
+    constructor(inputNodes, hiddenNodes, outputNodes) {
+        this.inputNodes = inputNodes;
+        this.hiddenNodes = hiddenNodes;
+        this.outputNodes = outputNodes;
+
+        // Initialize weights with random values between -1 and 1
+        this.weights_ih = this.initializeWeights(this.hiddenNodes, this.inputNodes);
+        this.weights_ho = this.initializeWeights(this.outputNodes, this.hiddenNodes);
+
+        // Biases
+        this.bias_h = this.initializeBiases(this.hiddenNodes);
+        this.bias_o = this.initializeBiases(this.outputNodes);
+
+        // Learning rate
+        this.learningRate = 0.1;
+    }
+
+    // Helper method to initialize weights
+    initializeWeights(rows, cols) {
+        return Array(rows).fill().map(() => Array(cols).fill().map(() => Math.random() * 2 - 1));
+    }
+
+    // Helper method to initialize biases
+    initializeBiases(size) {
+        return Array(size).fill().map(() => Math.random() * 2 - 1);
+    }
+
+    // Sigmoid activation function
+    sigmoid(x) {
+        return 1 / (1 + Math.exp(-x));
+    }
+
+    // Sigmoid derivative (used for backpropagation)
+    sigmoidDerivative(x) {
+        return x * (1 - x);
+    }
+
+    // Feedforward function
+    feedforward(inputArray) {
+        // Calculate hidden layer outputs
+        let hidden = this.weights_ih.map((row, i) => 
+            this.sigmoid(row.reduce((sum, weight, j) => sum + weight * inputArray[j], 0) + this.bias_h[i])
+        );
+
+        // Calculate output layer outputs
+        let output = this.weights_ho.map((row, i) => 
+            this.sigmoid(row.reduce((sum, weight, j) => sum + weight * hidden[j], 0) + this.bias_o[i])
+        );
+
+        return output;
+    }
+
+    // Train the network
+    train(inputArray, targetArray) {
+        // Feedforward
+        let hidden = this.weights_ih.map((row, i) => 
+            this.sigmoid(row.reduce((sum, weight, j) => sum + weight * inputArray[j], 0) + this.bias_h[i])
+        );
+        let outputs = this.weights_ho.map((row, i) => 
+            this.sigmoid(row.reduce((sum, weight, j) => sum + weight * hidden[j], 0) + this.bias_o[i])
+        );
+
+        // Calculate the output errors
+        let outputErrors = targetArray.map((target, i) => target - outputs[i]);
+
+        // Calculate output gradients
+        let outputGradients = outputs.map((output, i) => 
+            this.sigmoidDerivative(output) * outputErrors[i] * this.learningRate
+        );
+
+        // Calculate hidden errors
+        let hiddenErrors = this.weights_ho[0].map((_, i) => 
+            this.weights_ho.reduce((sum, row) => sum + row[i] * outputErrors[0], 0)
+        );
+
+        // Calculate hidden gradients
+        let hiddenGradients = hidden.map((h, i) => 
+            this.sigmoidDerivative(h) * hiddenErrors[i] * this.learningRate
+        );
+
+        // Update weights and biases
+        this.weights_ho = this.weights_ho.map((row, i) => 
+            row.map((weight, j) => weight + outputGradients[i] * hidden[j])
+        );
+        this.weights_ih = this.weights_ih.map((row, i) => 
+            row.map((weight, j) => weight + hiddenGradients[i] * inputArray[j])
+        );
+        this.bias_o = this.bias_o.map((bias, i) => bias + outputGradients[i]);
+        this.bias_h = this.bias_h.map((bias, i) => bias + hiddenGradients[i]);
+    }
+}
+
+// Example usage:
+let nn = new NeuralNetwork(2, 4, 1);  // Increased hidden nodes to 4
+
+// Example dataset (XOR problem)
+let inputs = [
+    [0, 0],
+    [0, 1],
+    [1, 0],
+    [1, 1]
+];
+let targets = [
+    [0],
+    [1],
+    [1],
+    [0]
+];
+
+// Training the neural network
+for (let i = 0; i < 50000; i++) {  // Increased training iterations
+    let index = Math.floor(Math.random() * 4);
+    nn.train(inputs[index], targets[index]);
+}
+
+// Testing the neural network
+console.log(nn.feedforward([0, 0]));
+console.log(nn.feedforward([0, 1]));
+console.log(nn.feedforward([1, 0]));
+console.log(nn.feedforward([1, 1]));
+