Adding Light Falloff for multiple Point Lights

I'm currently trying to add multiple point lights to my game. What I have done appears to be mostly working, except for a small problem of blending light falloff. Here's two images to show you what's happening. In the first one, Light Falloff is commented out. Both point lights appear correctly.

And here's the second image, where I have light falloff enabled. You will see that only light #2 is "mostly" visible. There are traces of light #1, but for the most part, light #1 appears to be overridden by light #2's falloff. In other words, each consecutive light's falloff overrides the light from previous lights.

Does anyone know how to add falloff for multiple point lights? I'm sure I'm doing something slightly wrong, and that's why the lights are not properly accumulated.

Here's my shader:

struct Vertex
{
    float4 pos : POSITION;
    float2 tex : TEXTURE;
    float3 norm : NORMAL;
};

struct PixelShaderArgs
{
    float4 pos : SV_POSITION;
    float2 col : TEXTURE;
    float3 norm : NORMAL;
    float3 worldPos : POSITION;
};

struct PointLightShaderArgs
{
    float3 pos;
    float radius;
    float intensity;
    float3 padding;
    float4 ambient;
    float4 diffuse;
};

Texture2D ShaderTexture : register(t0);
SamplerState Sampler : register(s0);

float4x4 localMatrix : register(b0);
cbuffer ShaderDataBuffer : register(b1)
{
    float2 TextureResolution;
};
cbuffer cbPerFrame : register(b3)
{
    PointLightShaderArgs light[8];
};

cbuffer WorldPositionBuffer : register(b4)
{
    float4x4 World;
};

PixelShaderArgs VertexShaderMain(Vertex vertex)
{
    PixelShaderArgs output;
    output.pos = mul(vertex.pos, localMatrix);
    output.col = vertex.tex;
    output.norm = mul(vertex.norm, World);
    output.worldPos = mul(vertex.pos, World);
    return output;
}

int2 convertUVToPixel(float u, float v)
{
    int width = TextureResolution.x;
    int height = TextureResolution.y;
    int xCoordinate = floor(u * width);
    int yCoordinate = floor(v * height);
    return int2(xCoordinate % width, yCoordinate % height);
}

float Falloff(float distance, float radius)
{
    return clamp(1.0f - (distance / radius), 0.0, 1.0);
}

#define ATTENUATION_CONSTANT 1.0f // 0% Constant
#define ATTENUATION_LINEAR 0.0f // 100% Linear
#define ATTENUATION_QUADRATIC 0.0f // 100% Quadratic


float4 PixelShaderMain(PixelShaderArgs pixelShaderArgs) : SV_Target
{
    float u = pixelShaderArgs.col.x;
    float v = pixelShaderArgs.col.y;
    // Lighting
    float3 fragColor = float3(0.0f, 0.0f, 0.0f);
    float4 diffuse = ShaderTexture.Load(int3(convertUVToPixel(u, v), 0));
    for (int i = 0; i < 2; i++)
    {
        
        
        float3 ambient = diffuse * light[i].ambient;
        pixelShaderArgs.norm = normalize(pixelShaderArgs.norm);
        float3 lightToPixelVec = light[i].pos - pixelShaderArgs.worldPos;
        float distance = length(lightToPixelVec);
        float luminosity = dot(lightToPixelVec / distance, pixelShaderArgs.norm);
        float intensity = 1.00f;
        if (luminosity > 0.0f)
        {
        
            // Do lighting attenuation
            fragColor += luminosity * diffuse * light[i].diffuse;
            fragColor /= ATTENUATION_CONSTANT + (ATTENUATION_LINEAR * distance) + (ATTENUATION_QUADRATIC * (distance * distance));
            fragColor *= light[i].intensity; // multiply the final result by the intensity.
            fragColor *= Falloff(distance, light[i].radius); // This is what's causing the problem!!
            //fragColor = saturate(fragColor + ambient);
        }
        
    }
    return float4(fragColor, diffuse.a);
        
}