diff --git a/cnn.c b/cnn.c
index 94de085..caf79f5 100644
--- a/cnn.c
+++ b/cnn.c
@@ -145,7 +145,7 @@ int main(){
     float* conv_rlst_3 = convolution(conv3_weight,conv3_bias,expand_matrix_3, 27);
             print_rslt(conv_rlst_3, 25, (1*25*25));
     float* pool_rslt_3 = pooling(conv3_weight, conv_rlst_3, 25);
-            print_rslt(pool_rslt_3, 25, (1*12*12));
+            print_rslt(pool_rslt_3, 12, (1*12*12));
 
 
 
@@ -161,68 +161,69 @@ int main(){
 
 
 
-//// 隐藏层参数地址
-//    float *affine1_w; // 指向第一个全连接层权重的内存地址的指针
-//    float *affine1_b; // 指向第一个全连接层偏置的内存地址的指针
-//    affine1_param_init(); // 初始化全连接层参数
-//    float *affine1_rslt; // 指向存储隐藏层计算结果的内存地址的指针
-//    float affine1_temp; // 临时变量，用于存储全连接层的中间结果
-//
-//// 遍历100个神经元（假设隐藏层有100个神经元）
-//    for(int n=0; n<100; n++)
-//    {
-//        affine1_temp = 0; // 每个神经元的输出初始化为0
-//
-//        // 进行矩阵乘法，将池化层输出展平为一维向量后，与全连接层权重进行点积
-//        for(int i=0; i<4320; i++)
-//        {
-//            affine1_temp = affine1_temp + pool_rslt_1[i] * affine1_w[i+4320*n];
-//        }
-//
-//        // 加上对应神经元的偏置
-//        affine1_temp = affine1_temp + affine1_b[n];
-//
-//        // 激活函数：ReLU（将小于0的值设为0）
-//        if(affine1_temp > 0)
-//            affine1_rslt[n] = affine1_temp; // 如果结果大于0，存入结果数组
-//        else
-//            affine1_rslt[n] = 0; // 否则存入0
-//    }
-//
-//
-//
-//    float *affine2_w; // 指向第二个全连接层（输出层）权重的内存地址的指针
-//    float *affine2_b; // 指向第二个全连接层（输出层）偏置的内存地址的指针
-//    float affine2_temp; // 临时变量，用于存储输出层的中间结果
-//    affine2_param_init(); // 初始化输出层参数
-//
-//    float affine2_rslt[10]; // 存储输出层的结果（假设输出层有10个神经元）
-//
-//// 比较输出层的最大值
-//    float temp = -100; // 用于存储最大值的临时变量，初始化为一个非常小的值
-//    int predict_num; // 用于存储预测的数字（对应最大值的索引）
-//
-//// 遍历10个输出神经元（假设有10个类别）
-//    for(int n=0; n<10; n++)
-//    {
-//        affine2_temp = 0; // 当前神经元的输出初始化为0
-//
-//        // 进行矩阵乘法，将隐藏层的输出与输出层权重进行点积
-//        for(int i=0; i<100; i++)
-//        {
-//            affine2_temp = affine2_temp + affine2_w[i+100*n] * affine1_rslt[i];
-//        }
-//
-//        // 加上对应神经元的偏置
-//        affine2_temp = affine2_temp + affine2_b[n];
-//        affine2_rslt[n] = affine2_temp; // 存储输出层的结果
-//
-//        // 寻找最大值
-//        if(temp <= affine2_rslt[n])
-//        {
-//            temp = affine2_rslt[n]; // 更新最大值
-//            predict_num = n; // 记录最大值对应的类别索引
-//        }
-//    }
+// 隐藏层参数地址
+    float *affine1_rslt = (float *) malloc(sizeof(float)*128);
+    memset(affine1_rslt, 0, sizeof(float)*128);
+    float affine1_temp; // 临时变量，用于存储全连接层的中间结果
+
+// 遍历128个神经元（假设隐藏层有128个神经元）
+    for(int n=0; n<128; n++)
+    {
+        affine1_temp = 0; // 每个神经元的输出初始化为0
+
+        // 进行矩阵乘法，将池化层输出展平为一维向量后，与全连接层权重进行点积
+        for(int i=0; i<(128*12*12); i++)
+        {
+            affine1_temp = affine1_temp + pool_rslt_3[i] * fc1_weight.array[i+(128*12*12)*n];
+        }
+
+        // 加上对应神经元的偏置
+        affine1_temp = affine1_temp + fc1_bias.array[n];
+
+        // 激活函数：ReLU（将小于0的值设为0）
+        if(affine1_temp > 0)
+            affine1_rslt[n] = affine1_temp; // 如果结果大于0，存入结果数组
+        else
+            affine1_rslt[n] = 0; // 否则存入0
+    }
+
+    print_rslt(affine1_rslt,1,128);
+
+
+
+    float affine2_temp; // 临时变量，用于存储输出层的中间结果
+    float affine2_rslt[7]; // 存储输出层的结果（假设输出层有7个神经元）
+
+// 比较输出层的最大值
+    float temp = -100; // 用于存储最大值的临时变量，初始化为一个非常小的值
+    int predict_num; // 用于存储预测的数字（对应最大值的索引）
+
+// 遍历7个输出神经元（假设有7个类别）
+    for(int n=0; n<7; n++)
+    {
+        affine2_temp = 0; // 当前神经元的输出初始化为0
+
+        // 进行矩阵乘法，将隐藏层的输出与输出层权重进行点积
+        for(int i=0; i<128; i++)
+        {
+            affine2_temp = affine2_temp + fc2_weight.array[i+100*n] * affine1_rslt[i];
+        }
+
+        // 加上对应神经元的偏置
+        affine2_temp = affine2_temp + fc2_bias.array[n];
+        affine2_rslt[n] = affine2_temp; // 存储输出层的结果
+
+        // 寻找最大值
+        if(temp <= affine2_rslt[n])
+        {
+            temp = affine2_rslt[n]; // 更新最大值
+            predict_num = n; // 记录最大值对应的类别索引
+        }
+    }
+
+    print_rslt(affine2_rslt,1,7);
+
+    printf("RES is:%d",predict_num+1);
+
     return 0;
 }