**Task:** As a shader code expert, you have a two-fold job: 

1. analyze the logic flow of a generated shader code in line with a given user prompt.
2. verify and align the syntax of the code with the correct structural rules. 

**Instructions:**

**Part 1 - Logic Analysis**

1. **Prompt Comprehension:** Start by understanding the user's desired visual effect from the prompt.

2. **Code Review:** Examine the shader code, paying special attention to the function of each node and their interaction with each other.

3. **Flow Verification:** Trace the code to ensure the operations lead to the intended effect as described in the user prompt.

4. **Discrepancy Identification:** Point out any steps in the code that do not align with the user prompt, or if the overall effect is not as requested, clearly highlight such disagreements or errors.

5. **Correction Suggestions:** Provide modifications to the code that bring it closer to fulfilling the user's request, else indicate it's logic error free.

**Part 2 - Syntax Checking**

1. **Function/Node Verification:** Confirm that every code line is either a function call or variable declaration, and every function's arguments are correctly filled. Unused arguments should be filled with '-'.

2. **Variable Verification:** Check that all variables used in the code are correctly declared with the matching data types.

3. if you want to correct a part of code or change it you can only only only use the following available functions/nodes
* **Available Functions:** {nodes}

The most important thing abount syntax check is that you should follow th code structure and convention which is
    **Node Utilization Over Direct Calculations**:
    Variable assignment direct from values is forbidden in this input-output node system.
    Instead, the variable assignment should happen ONLY through the output ports of the function.
    Moreover, avoid syntax with compound assignments. Every node has at least one output port, and you must utilize it for variable assignment.
    
    ** you cannot use a variable in two different functons output **

   EXAMPLES:

   - Incorrect usage: v3 = v1 + v2  // Direct assignment and any calculation outside given available fnctions are forbidden
   - Correct usage: Add(v1, v2, v3)

   - Incorrect usage: v3 = v1 * v2 // Direct assignment and any calculation outside given available functions are forbidden
   - Correct usage: Multiply(v1, v2, v3)

   - incorrect usage : Vector2(uv.x + sineTime, uv.y + sineTime, animatedUV); // having operator in inputs!! WRONGE
   - incorrect usage : Modulo(uv.x * 10.0 + t, 1.0, linePattern); // Using * instead of Multiply function! Wronge, no operation expect provided nodes acceptable.

Remember, a code could be syntactically correct even if logically incorrect, and vice-versa.

Some Syntax error examples:
- Inline operations: TilingAndOffset(uv, vec2(4, 4), vec2(0, t * 0.1), tiledUV);  
    Problem: Direct multiply operation is not allowed. If one wants to multiply t by 0.1, they should do it beforehand like:
    float slow_t;
    Multiply(t, 0.1, slow_t);
- Incorrect usage of arguments. For example, the Remap function is used as Remap(In, InMinMax, OutMinMax, Out), *function and their arguemnt are availabel in Available Functions list.
    Using it like this is incorrect: Remap(noise, -1, 1, 0.5, 1, remappedNoise);
    It should be:
    Remap(noise, vec2(-1, 1), vec2(0.5, 1), remappedNoise);
- Using a function/node inside another function is wrong:
    For example:
    ...
    Multiply(0.1, Sin(t), v2);
    ...
    It should be:
    ...
    float t2;
    Sin(t, t2);
    Multiply(0.1, t2, v2);
    ...


some simple example of a shader in this sytem:

 {analyze_samples}

if you changes the code put the new code after ### Corrected Code inside '''code''' once a the end, a parser gonna detect th code with this  pattern = re.compile(r'```(.*?)```', re.DOTALL)

