summaryrefslogblamecommitdiff
path: root/src/map/status.c
blob: fcefedbbe4891ae0373d6d9996ca68f419745a07 (plain) (tree)
1
2
3
4
5
6
7
8
9
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
6583
6584
6585
6586
6587
6588
6589
6590
6591
6592
6593
6594
6595
6596
6597
6598
6599
6600
6601
6602
6603
6604
6605
6606
6607
6608
6609
6610
6611
6612
6613
6614
6615
6616
6617
6618
6619
6620
6621
6622
6623
6624
6625
6626
6627
6628
6629
6630
6631
6632
6633
6634
6635
6636
6637
6638
6639
6640
6641
6642
6643
6644
6645
6646
6647
6648
6649
6650
6651
6652
6653
6654
6655
6656
6657
6658
6659
6660
6661
6662
6663
6664
6665
6666
6667
6668
6669
6670
6671
6672
6673
6674
6675
6676
6677
6678
6679
6680
6681
6682
6683
6684
6685
6686
6687
6688
6689
6690
6691
6692
6693
6694
6695
6696
6697
6698
6699
6700
6701
6702
6703
6704
6705
6706
6707
6708
6709
6710
6711
6712
6713
6714
6715
6716
6717
6718
6719
6720
6721
6722
6723
6724
6725
6726
6727
6728
6729
6730
6731
6732
6733
6734
6735
6736
6737
6738
6739
6740
6741
6742
6743
6744
6745
6746
6747
6748
6749
6750
6751
6752
6753
6754
6755
6756
6757
6758
6759
6760
6761
6762
6763
6764
6765
6766
6767
6768
6769
6770
6771
6772
6773
6774
6775
6776
6777
6778
6779
6780
6781
6782
6783
6784
6785
6786
6787
6788
6789
6790
6791
6792
6793
6794
6795
6796
6797
6798
6799
6800
6801
6802
6803
6804
6805
6806
6807
6808
6809
6810
6811
6812
6813
6814
6815
6816
6817
6818
6819
6820
6821
6822
6823
6824
6825
6826
6827
6828
6829
6830
6831
6832
6833
6834
6835
6836
6837
6838
6839
6840
6841
6842
6843
6844
6845
6846
6847
6848
6849
6850
6851
6852
6853
6854
6855
6856
6857
6858
6859
6860
6861
6862
6863
6864
6865
6866
6867
6868
6869
6870
6871
6872
6873
6874
6875
6876
6877
6878
6879
6880
6881
6882
6883
6884
6885
6886
6887
6888
6889
6890
6891
6892
6893
6894
6895
6896
6897
6898
6899
6900
6901
6902
6903
6904
6905
6906
6907
6908
6909
6910
6911
6912
6913
6914
6915
6916
6917
6918
6919
6920
6921
6922
6923
6924
6925
6926
6927
6928
6929
6930
6931
6932
6933
6934
6935
6936
6937
6938
6939
6940
6941
6942
6943
6944
6945
6946
6947
6948
6949
6950
6951
6952
6953
6954
6955
6956
6957
6958
6959
6960
6961
6962
6963
6964
6965
6966
6967
6968
6969
6970
6971
6972
6973
6974
6975
6976
6977
6978
6979
6980
6981
6982
6983
6984
6985
6986
6987
6988
6989
6990
6991
6992
6993
6994
6995
6996
6997
6998
6999
7000
7001
7002
7003
7004
7005
7006
7007
7008
7009
7010
7011
7012
7013
7014
7015
7016
7017
7018
7019
7020
7021
7022
7023
7024
7025
7026
7027
7028
7029
7030
7031
7032
7033
7034
7035
7036
7037
7038
7039
7040
7041
7042
7043
7044
7045
7046
7047
7048
7049
7050
7051
7052
7053
7054
7055
7056
7057
7058
7059
7060
7061
7062
7063
7064
7065
7066
7067
7068
7069
7070
7071
7072
7073
7074
7075
7076
7077
7078
7079
7080
7081
7082
7083
7084
7085
7086
7087
7088
7089
7090
7091
7092
7093
7094
7095
7096
7097
7098
7099
7100
7101
7102
7103
7104
7105
7106
7107
7108
7109
7110
7111
7112
7113
7114
7115
7116
7117
7118
7119
7120
7121
7122
7123
7124
7125
7126
7127
7128
7129
7130
7131
7132
7133
7134
7135
7136
7137
7138
7139
7140
7141
7142
7143
7144
7145
7146
7147
7148
7149
7150
7151
7152
7153
7154
7155
7156
7157
7158
7159
7160
7161
7162
7163
7164
7165
7166
7167
7168
7169
7170
7171
7172
7173
7174
7175
7176
7177
7178
7179
7180
7181
7182
7183
7184
7185
7186
7187
7188
7189
7190
7191
7192
7193
7194
7195
7196
7197
7198
7199
7200
7201
7202
7203
7204
7205
7206
7207
7208
7209
7210
7211
7212
7213
7214
7215
7216
7217
7218
7219
7220
7221
7222
7223
7224
7225
7226
7227
7228
7229
7230
7231
7232
7233
7234
7235
7236
7237
7238
7239
7240
7241
7242
7243
7244
7245
7246
7247
7248
7249
7250
7251
7252
7253
7254
7255
7256
7257
7258
7259
7260
7261
7262
7263
7264
7265
7266
7267
7268
7269
7270
7271
7272
7273
7274
7275
7276
7277
7278
7279
7280
7281
7282
7283
7284
7285
7286
7287
7288
7289
7290
7291
7292
7293
7294
7295
7296
7297
7298
7299
7300
7301
7302
7303
7304
7305
7306
7307
7308
7309
7310
7311
7312
7313
7314
7315
7316
7317
7318
7319
7320
7321
7322
7323
7324
7325
7326
7327
7328
7329
7330
7331
7332
7333
7334
7335
7336
7337
7338
7339
7340
7341
7342
7343
7344
7345
7346
7347
7348
7349
7350
7351
7352
7353
7354
7355
7356
7357
7358
7359
7360
7361
7362
7363
7364
7365
7366
7367
7368
7369
7370
7371
7372
7373
7374
7375
7376
7377
7378
7379
7380
7381
7382
7383
7384
7385
7386
7387
7388
7389
7390
7391
7392
7393
7394
7395
7396
7397
7398
7399
7400
7401
7402
7403
7404
7405
7406
7407
7408
7409
7410
7411
7412
7413
7414
7415
7416
7417
7418
7419
7420
7421
7422
7423
7424
7425
7426
7427
7428
7429
7430
7431
7432
7433
7434
7435
7436
7437
7438
7439
7440
7441
7442
7443
7444
7445
7446
7447
7448
7449
7450
7451
7452
7453
7454
7455
7456
7457
7458
7459
7460
7461
7462
7463
7464
7465
7466
7467
7468
7469
7470
7471
7472
7473
7474
7475
7476
7477
7478
7479
7480
7481
7482
7483
7484
7485
7486
7487
7488
7489
7490
7491
7492
7493
7494
7495
7496
7497
7498
7499
7500
7501
7502
7503
7504
7505
7506
7507
7508
7509
7510
7511
7512
7513
7514
7515
7516
7517
7518
7519
7520
7521
7522
7523
7524
7525
7526
7527
7528
7529
7530
7531
7532
7533
7534
7535
7536
7537
7538
7539
7540
7541
7542
7543
7544
7545
7546
7547
7548
7549
7550
7551
7552
7553
7554
7555
7556
7557
7558
7559
7560
7561
7562
7563
7564
7565
7566
7567
7568
7569
7570
7571
7572
7573
7574
7575
7576
7577
7578
7579
7580
7581
7582
7583
7584
7585
7586
7587
7588
7589
7590
7591
7592
7593
7594
7595
7596
7597
7598
7599
7600
7601
7602
7603
7604
7605
7606
7607
7608
7609
7610
7611
7612
7613
7614
7615
7616
7617
7618
7619
7620
7621
7622
7623
7624
7625
7626
7627
7628
7629
7630
7631
7632
7633
7634
7635
7636
7637
7638
7639
7640
7641
7642
7643
7644
7645
7646
7647
7648
7649
7650
7651
7652
7653
7654
7655
7656
7657
7658
7659
7660
7661
7662
7663
7664
7665
7666
7667
7668
7669
7670
7671
7672
7673
7674
7675
7676
7677
7678
7679
7680
7681
7682
7683
7684
7685
7686
7687
7688
7689
7690
7691
7692
7693
7694
7695
7696
7697
7698
7699
7700
7701
7702
7703
7704
7705
7706
7707
7708
7709
7710
7711
7712
7713
7714
7715
7716
7717
7718
7719
7720
7721
7722
7723
7724
7725
7726
7727
7728
7729
7730
7731
7732
7733
7734
7735
7736
7737
7738
7739
7740
7741
7742
7743
7744
7745
7746
7747
7748
7749
7750
7751
7752
7753
7754
7755
7756
7757
7758
7759
7760
7761
7762
7763
7764
7765
7766
7767
7768
7769
7770
7771
7772
7773
7774
7775
7776
7777
7778
7779
7780
7781
7782
7783
7784
7785
7786
7787
7788
7789
7790
7791
7792
7793
7794
7795
7796
7797
7798
7799
7800
7801
7802
7803
7804
7805
7806
7807
7808
7809
7810
7811
7812
7813
7814
7815
7816
7817
7818
7819
7820
7821
7822
7823
7824
7825
7826
7827
7828
7829
7830
7831
7832
7833
7834
7835
7836
7837
7838
7839
7840
7841
7842
7843
7844
7845
7846
7847
7848
7849
7850
7851
7852
7853
7854
7855
7856
7857
7858
7859
7860
7861
7862
7863
7864
7865
7866
7867
7868
7869
7870
7871
7872
7873
7874
7875
7876
7877
7878
7879
7880
7881
7882
7883
7884
7885
7886
7887
7888
7889
7890
7891
7892
7893
7894
7895
7896
7897
7898
7899
7900
7901
7902
7903
7904
7905
7906
7907
7908
7909
7910
7911
7912
7913
7914
7915
7916
7917
7918
7919
7920
7921
7922
7923
7924
7925
7926
7927
7928
7929
7930
7931
7932
7933
7934
7935
7936
7937
7938
7939
7940
7941
7942
7943
7944
7945
7946
7947
7948
7949
7950
7951
7952
7953
7954
7955
7956
7957
7958
7959
7960
7961
7962
7963
7964
7965
7966
7967
7968
7969
7970
7971
7972
7973
7974
7975
7976
7977
7978
7979
7980
7981
7982
7983
7984
7985
7986
7987
7988
7989
7990
7991
7992
7993
7994
7995
7996
7997
7998
7999
8000
8001
8002
8003
8004
8005
8006
8007
8008
8009
8010
8011
8012
8013
8014
8015
8016
8017
8018
8019
8020
8021
8022
8023
8024
8025
8026
8027
8028
8029
8030
8031
8032
8033
8034
8035
8036
8037
8038
8039
8040
8041
8042
8043
8044
8045
8046
8047
8048
8049
8050
8051
8052
8053
8054
8055
8056
8057
8058
8059
8060
8061
8062
8063
8064
8065
8066
8067
8068
8069
8070
8071
8072
8073
8074
8075
8076
8077
8078
8079
8080
8081
8082
8083
8084
8085
8086
8087
8088
8089
8090
8091
8092
8093
8094
8095
8096
8097
8098
8099
8100
8101
8102
8103
8104
8105
8106
8107
8108
8109
8110
8111
8112
8113
8114
8115
8116
8117
8118
8119
8120
8121
8122
8123
8124
8125
8126
8127
8128
8129
8130
8131
8132
8133
8134
8135
8136
8137
8138
8139
8140
8141
8142
8143
8144
8145
8146
8147
8148
8149
8150
8151
8152
8153
8154
8155
8156
8157
8158
8159
8160
8161
8162
8163
8164
8165
8166
8167
8168
8169
8170
8171
8172
8173
8174
8175
8176
8177
8178
8179
8180
8181
8182
8183
8184
8185
8186
8187
8188
8189
8190
8191
8192
8193
8194
8195
8196
8197
8198
8199
8200
8201
8202
8203
8204
8205
8206
8207
8208
8209
8210
8211
8212
8213
8214
8215
8216
8217
8218
8219
8220
8221
8222
8223
8224
8225
8226
8227
8228
8229
8230
8231
8232
8233
8234
8235
8236
8237
8238
8239
8240
8241
8242
8243
8244
8245
8246
8247
8248
8249
8250
8251
8252
8253
8254
8255
8256
8257
8258
8259
8260
8261
8262
8263
8264
8265
8266
8267
8268
8269
8270
8271
8272
8273
8274
8275
8276
8277
8278
8279
8280
8281
8282
8283
8284
8285
8286
8287
8288
8289
8290
8291
8292
8293
8294
8295
8296
8297
8298
8299
8300
8301
8302
8303
8304
8305
8306
8307
8308
8309
8310
8311
8312
8313
8314
8315
8316
8317
8318
8319
8320
8321
8322
8323
8324
8325
8326
8327
8328
8329
8330
8331
8332
8333
8334
8335
8336
8337
8338
8339
8340
8341
8342
8343
8344
8345
8346
8347
8348
8349
8350
8351
8352
8353
8354
8355
8356
8357
8358
8359
8360
8361
8362
8363
8364
8365
8366
8367
8368
8369
8370
8371
8372
8373
8374
8375
8376
8377
8378
8379
8380
8381
8382
8383
8384
8385
8386
8387
8388
8389
8390
8391
8392
8393
8394
8395
8396
8397
8398
8399
8400
8401
8402
8403
8404
8405
8406
8407
8408
8409
8410
8411
8412
8413
8414
8415
8416
8417
8418
8419
8420
8421
8422
8423
8424
8425
8426
8427
8428
8429
8430
8431
8432
8433
8434
8435
8436
8437
8438
8439
8440
8441
8442
8443
8444
8445
8446
8447
8448
8449
8450
8451
8452
8453
8454
8455
8456
8457
8458
8459
8460
8461
8462
8463
8464
8465
8466
8467
8468
8469
8470
8471
8472
8473
8474
8475
8476
8477
8478
8479
8480
8481
8482
8483
8484
8485
8486
8487
8488
8489
8490
8491
8492
8493
8494
8495
8496
8497
8498
8499
8500
8501
8502
8503
8504
8505
8506
8507
8508
8509
8510
8511
8512
8513
8514
8515
8516
8517
8518
8519
8520
8521
8522
8523
8524
8525
8526
8527
8528
8529
8530
8531
8532
8533
8534
8535
8536
8537
8538
8539
8540
8541
8542
8543
8544
8545
8546
8547
8548
8549
8550
8551
8552
8553
8554
8555
8556
8557
8558
8559
8560
8561
8562
8563
8564
8565
8566
8567
8568
8569
8570
8571
8572
8573
8574
8575
8576
8577
8578
8579
8580
8581
8582
8583
8584
8585
8586
8587
8588
8589
8590
8591
8592
8593
8594
8595
8596
8597
8598
8599
8600
8603
8604
8605
8606
8607
8608
8609
8610
8611
8612
8613
8614
8615
8616
8617
8618
8619
8620
8621
8622
8623
8624
8625
8626
8627
8628
8629
8630
8631
8632
8633
8634
8635
8636
8637
8638
8639
8640
8641
8642
8643
8644
8645
8646
8647
8648
8649
8650
8651
8652
8653
8654
8655
8656
8657
8658
8659
8660
8661
8662
8663
8664
8665
8666
8667
8668
8669
8670
8671
8672
8673
8674
8675
8676
8677
8678
8679
8680
8681
8682
8683
8684
8685
8686
8687
8688
8689
8690
8691
8692
8693
8694
8695
8696
8697
8698
8699
8700
8701
8702
8703
8704
8705
8706
8707
8708
8709
8710
8711
8712
8713
8714
8715
8716
8717
8718
8719
8720
8721
8722
8723
8724
8725
8726
8727
8728
8729
8730
8731
8732
8733
8734
8735
8736
8737
8738
8739
8740
8741
8742
8743
8744
8745
8746
8747
8748
8749
8750
8751
8752
8753
8754
8755
8756
8757
8758
8759
8760
8761
8762
8763
8764
8765
8766
8767
8768
8769
8770
8771
8772
8773
8774
8775
8776
8777
8778
8779
8780
8781
8782
8783
8784
8785
8786
8787
8788
8789
8790
8791
8792
8793
8794
8795
8796
8797
8798
8799
8800
8801
8802
8803
8804
8805
8806
8807
8808
8809
8810
8811
8812
8813
8814
8815
8816
8817
8818
8819
8820
8821
8822
8823
8824
8825
8826
8827
8828
8829
8830
8831
8832
8833
8834
8835
8836
8837
8838
8839
8840
8841
8842
8843
8844
8845
8846
8847
8848
8849
8850
8851
8852
8853
8854
8855
8856
8857
8858
8859
8860
8861
8862
8863
8864
8865
8866
8867
8868
8869
8870
8871
8872
8873
8874
8875
8876
8877
8878
8879
8880
8881
8882
8883
8884
8885
8886
8887
8888
8889
8890
8891
8892
8893
8894
8895
8896
8897
8898
8899
8900
8901
8902
8903
8904
8905
8906
8907
8908
8909
8910
8911
8912
8913
8914
8915
8916
8917
8918
8919
8920
8921
8922
8923
8924
8925
8926
8927
8928
8929
8930
8931
8932
8933
8934
8935
8936
8937
8938
8939
8940
8941
8942
8943
8944
8945
8946
8947
8948
8949
8950
8951
8952
8953
8954
8955
8956
8957
8958
8959
8960
8961
8962
8963
8964
8965
8966
8967
8968
8969
8970
8971
8972
8973
8974
8975
8976
8977
8978
8979
8980
8981
8982
8983
8984
8985
8986
8987
8988
8989
8990
8991
8992
8993
8994
8995
8996
8997
8998
8999
9000
9001
9002
9003
9004
9005
9006
9007
9008
9009
9010
9011
9012
9013
9014
9015
9016
9017
9018
9019
9020
9021
9022
9023
9024
9025
9026
9027
9028
9029
9030
9031
9032
9033
9034
9035
9036
9037
9038
9039
9040
9041
9042
9043
9044
9045
9046
9047
9048
9049
9050
9051
9052
9053
9054
9055
9056
9057
9058
9059
9060
9061
9062
9063
9064
9065
9066
9067
9068
9069
9070
9071
9072
9073
9074
9075
9076
9077
9078
9079
9080
9081
9082
9083
9084
9085
9086
9087
9088
9089
9090
9091
9092
9093
9094
9095
9096
9097
9098
9099
9100
9101
9102
9103
9104
9105
9106
9107
9108
9109
9110
9111
9112
9113
9114
9115
9116
9117
9118
9119
9120
9121
9122
9123
9124
9125
9126
9127
9128
9129
9130
9131
9132
9133
9134
9135
9136
9137
9138
9139
9140
9141
9142
9143
9144
9145
9146
9147
9148
9149
9150
9151
9152
9153
9154
9155
9156
9157
9158
9159
9160
9161
9162
9163
9164
9165
9166
9167
9168
9169
9170
9171
9172
9173
9174
9175
9176
9177
9178
9179
9180
9181
9182
9183
9184
9185
9186
9187
9188
9189
9190
9191
9192
9193
9194
9195
9196
9197
9198
9199
9200
9201
9202
9203
9204
9205
9206
9207
9208
9209
9210
9211
9212
9213
9214
9215
9216
9217
9218
9219
9220
9221
9222
9223
9224
9225
9226
9227
9228
9229
9230
9231
9232
9233
9234
9235
9236
9237
9238
9239
9240
9241
9242
9243
9244
9245
9246
9247
9248
9249
9250
9251
9252
9253
9254
9255
9256
9257
9258
9259
9260
9261
9262
9263
9264
9265
9266
9267
9268
9269
9270
9271
9272
9273
9274
9275
9276
9277
9278
9279
9280
9281
9282
9283
9284
9285
9286
9287
9288
9289
9290
9291
9292
9293
9294
9295
9296
9297
9298
9299
9300
9301
9302
9303
9304
9305
9306
9307
9308
9309
9310
9311
9312
9313
9314
9315
9316
9317
9318
9319
9320
9321
9322
9323
9324
9325
9326
9327
9328
9329
9330
9331
9332
9333
9334
9335
9336
9337
9338
9339
9340
9341
9342
9343
9344
9345
9346
9347
9348
9349
9350
9351
9352
9353
9354
9355
9356
9357
9358
9359
9360
9361
9362
9363
9364
9365
9366
9367
9368
9369
9370
9371
9372
9373
9374
9375
9376
9377
9378
9379
9380
9381
9382
9383
9384
9385
9386
9387
9388
9389
9390
9391
9392
9393
9394
9395
9396
9397
9398
9399
9400
9401
9402
9403
9404
9405
9406
9407
9408
9409
9410
9411
9412
9413
9414
9415
9416
9417
9418
9419
9420
9421
9422
9423
9424
9425
9426
9427
9428
9429
9430
9431
9432
9433
9434
9435
9436
9437
9438
9439
9440
9441
9442
9443
9444
9445
9446
9447
9448
9449
9450
9451
9452
9453
9454
9455
9456
9457
9458
9459
9460
9461
9462
9463
9464
9465
9466
9467
9468
9469
9470
9471
9472
9473
9474
9475
9476
9477
9478
9479
9480
9481
9482
9483
9484
9485
9486
9487
9488
9489
9490
9491
9492
9493
9494
9495
9496
9497
9498
9499
9500
9501
9502
9503
9504
9505
9506
9507
9508
9509
9510
9511
9512
9513
9514
9515
9516
9517
9518
9519
9520
9521
9522
9523
9524
9525
9526
9527
9528
9529
9530
9531
9532
9533
9534
9535
9536
9537
9538
9539
9540
9541
9542
9543
9544
9545
9546
9547
9548
9549
9550
9551
9552
9553
9554
9555
9556
9557
9558
9559
9560
9561
9562
9563
9564
9565
9566
9567
9568
9569
9570
9571
9572
9573
9574
9575
9576
9577
9578
9579
9580
9581
9582
9583
9584
9585
9586
9587
9588
9589
9590
9591
9592
9593
9594
9595
9596
9597
9598
9599
9600
9601
9602
9603
9604
9605
9606
9607
9608
9609
9610
9611
9612
9613
9614
9615
9616
9617
9618
9619
9620
9621
9622
9623
9624
9625
9626
9627
9628
9629
9630
9631
9632
9633
9634
9635
9636
9637
9638
9639
9640
9641
9642
9643
9644
9645
9646
9647
9648
9649
9650
9651
9652
9653
9654
9655
9656
9657
9658
9659
9660
9661
9662
9663
9664
9665
9666
9667
9668
9669
9670
9671
9672
9673
9674
9675
9676
9677
9678
9679
9680
9681
9682
9683
9684
9685
9686
9687
9688
9689
9690
9691
9692
9693
9694
9695
9696
9697
9698
9699
9700
9701
9702
9703
9704
9705
9706
9707
9708
9709
9740
9741
9742
9743
9744
9745
9746
9747
9748
9749
9750
9751
9752
9753
9754
9755
9756
9757
9758
9759
9760
9761
9762
9763
9764
9765
9766
9767
9768
9769
9770
9771
9772
9773
9774
9775
9776
9777
9778
9779
9780
9781
9782
9783
9784
9785
9786
9787
9788
9789
9790
9791
9792
9793
9794
9795
9796
9797
9798
9799
9800
9801
9802
9803
9804
9805
9806
9807
9808
9809
9810
9811
9812
9813
9814
9815
9816
9817
9818
9819
9820
9821
9822
9823
9824
9825
9826
9827
9828
9829
9830
9831
9832
9833
9834
9835
9836
9837
9838
9839
9840
9841
9842
9843
9844
9845
9846
9847
9848
9849
9850
9851
9852
9853
9854
9855
9856
9857
9858
9859
9860
9861
9862
9863
9864
9865
9866
9867
9868
9869
9870
9871
9872
9873
9874
9875
9876
9877
9878
9879
9880
9881
9882
9883
9884
9885
9886
9887
9888
9889
9890
9891
9892
9893
9894
9895
9896
9897
9898
9899
9900
9901
9902
9903
9904
9905
9906
9907
9908
9909
9910
9911
9912
9913
9914
9915
9916
9917
9918
9919
9920
9921
9922
9923
9924
9925
9926
9927
9928
9929
9930
9931
9932
9933
9934
9935
9936
9937
9938
9939
9940
9941
9942
9943
9944
9945
9946
9947
9948
9949
9950
9951
9952
9953
9954
9955
9956
9957
9958
9959
9960
9961
9962
9963
9964
9965
9966
9967
9968
9969
9970
9971
9972
9973
9974
9975
9976
9977
9978
9979
9980
9981
9982
9983
9984
9985
9986
9987
9988
9989
9990
9991
9992
9993
9994
9995
9996
9997
9998
9999
10000
10001
10002
10003
10004
10005
10006
10007
10008
10009
10010
10011
10012
10013
10014
10015
10016
10017
10018
10019
10020
10021
10022
10023
10024
10025
10026
10027
10028
10029
10030
10031
10032
10033
10034
10035
10036
10037
10038
10039
10040
10041
10042
10043
10044
10045
10046
10047
10048
10049
10050
10051
10052
10053
10054
10055
10056
10057
10058
10059
10060
10061
10062
10063
10064
10065
10066
10067
10068
10069
10070
10071
10072
10073
10074
10075
10076
10077
10078
10079
10080
10081
10082
10083
10084
10085
10086
10087
10088
10089
10090
10091
10092
10093
10094
10095
10096
10097
10098
10099
10100
10101
10102
10103
10104
10105
10106
10107
10108
10109
10110
10111
10112
10113
10114
10115
10116
10117
10118
10119
10120
10121
10122
10123
10124
10125
10126
10127
10128
10129
10130
10131
10132
10133
10134
10135
10136
10137
10138
10139
10140
10141
10142
10143
10144
10145
10146
10147
10148
10149
10150
10151
10152
10153
10154
10155
10156
10157
10158
10159
10160
10161
10162
10163
10164
10165
10166
10167
10168
10169
10170
10171
10172
10173
10174
10175
10176
10177
10178
10179
10180
10181
10182
10183
10184
10185
10186
10187
10188
10189
10190
10191
10192
10193
10194
10195
10196
10197
10198
10199
10200
10201
10202
10203
10204
10205
10206
10207
10208
10209
10210
10211
10212
10213
10214
10215
10216
10217
10218
10219
10220
10221
10222
10223
10224
10225
10226
10227
10228
10229
10230
10231
10232
10233
10234
10235
10236
10237
10238
10239
10240
10241
10242
10243
10244
10245
10246
10247
10248
10249
10250
10251
10252
10253
10254
10255
10256
10257
10258
10259
10260
10261
10262
10263
10264
10265
10266
10267
10268
10269
10270
10271
10272
10273
10274
10275
10276
10277
10278
10279
10280
10281
10282
10283
10284
10285
10286
10287
10288
10289
10290
10291
10292
10293
10294
10295
10296
10297
10298
10299
10300
10301
10302
10303
10304
10305
10306
10307
10308
10309
10310
10311
10312
10313
10314
10315
10316
10317
10318
10319
10320
10321
10322
10323
10324
10325
10326
10327
10328
10329
10330
10331
10332
10333
10334
10335
10336
10337
10338
10339
10340
10341
10342
10343
10344
10345
10346
10347
10348
10349
10350
10351
10352
10353
10354
10355
10356
10357
10358
10359
10360
10361
10362
10363
10364
10365
10366
10367
10368
10369
10370
10371
10372
10373
10374
10375
10376
10377
10378
10379
10380
10381
10382
10383
10384
10385
10386
10387
10388
10389
10390
10391
10392
10393
10394
10395
10396
10397
10398
10399
10400
10401
10402
10403
10404
10405
10406
10407
10408
10409
10410
10411
10412
10413
10414
10415
10416
10417
10418
10419
10420
10421
10422
10423
10424
10425
10426
10427
10428
10429
10430
10431
10432
10433
10434
10435
10436
10437
10438
10439
10440
10441
10442
10443
10444
10445
10446
10447
10448
10449
10450
10451
10452
10453
10454
10455
10456
10457
10458
10459
10460
10461
10462
10463
10464
10465
10466
10467
10468
10469
10470
10471
10472
10473
10474
10475
10476
10477
10478
10479
10480
10481
10482
10483


                                                          


                                 
                             

                              
                            
                          
                             
 
                

                 








                   
                  


                   
                       
                      
                      
                    
 




                   
                 
 
                      




                   
  
 




                                                  


                                                     
                                                                   
      


                                                          


                                                                              

                               
                                                                                         
                                              
 
                                                     
                                       
 



                                                                                                                     
 




                                                                                                                                                      

                                                                      
 




                                                     
                                  
 





                                                                       

 





                                                                                                     
                               
 



                                                                            
 
                                      

 






                                                                             



                                                                               
 
                                     








                                                                                                             



                                                                                
 
                                       

 
                                                           

                                                                                                                                                      
 
                                                                      
 

















                                                                   

 


















































































































                                                                                                                          
              

                                           
      






















                                                                                                                 
              
                                                                                       
      














































































































































































































































































                                                                                                                                                                 
                                                                                      









































































































































































































































































































































































































                                                                                                                                                                                                                         
 
                  

                                              
      
 




























































                                                                                        
 

 

                               
















                                                             

 

                                                                                        
                                                                                 
 
                                                                                                                   

 
                                                                        
                                                                            


                                                                                  










                                                           


                                                                        
                                                                            


                                                                   
                               
 


                                        
 




                                                           

 
                                                        
 


                                                                                  

 



                                                                               
                                                             

                                                                                                           








































































































































































































                                                                                                                                          

                                           
                                                    





                                                                                                                                                         
                                                                                                                                                                        
                                                             






















                                                                             





                                                                                                  









































































                                                                             





                                                                       

                                                                              

                                                                                                                              


























































                                                                               



                                                                                    





































                                                                    
 
 



                                                                     


                                                                                            
                                                                                          
                                                               
                                                              
                                              

                                                                                                     















































                                                                                               
                                                                                                                                                                                                   























































































































































































                                                                                                                                                                             




                                                                              



































                                                                                                                                                                                     

 
                   
                                                                                   
 
                
                   






















                                                                                                    

     



                                                                                                                                                               
 

                                                            
      

                                            
 
                   
 
 
                                                                                                    
 
                           
              
             
      


















                                                 
              
              
      


                              
              
              
      








                                                                           
              
                                                                                                  
     
                                    
      
                                        

 
               

                                                                                                                                             
     
                                                                                                                                                               
      



                                                                                             





                                                                                 
 
                                  
                                                                          



                                                                                                                                                                                                                             
     

                                                    



                                                     
      
 

































                                                                                  



                                                                          
                                                     
 










































































































































                                                                                        
              

                                               
     

                                                 
      
















                                                                                        


                                                 
                                                     
 



























































                                                                                                                                        
 
 


                                                                                              













                                                       






                                                                                      
                                                                                                 
 
















                                                                                                                                       

 
                                                                                                 
 
                     
 

                                                                                         
 





                                                                                                                                       
 
               

 

                                                                                           
                                                            
 


































































































































































































                                                                                                                                                          

              



                                                              

      




































































                                                                                                                                      
 













































































































































































































































































































                                                                                                                                                          
               
                             
      



























                                                                                                       

               



                                                                                          
      
 
                                             
 






                                                              

               



                                                                                            
      
 

                                                                                                                                         
 


                                                                                                                          
 
                                             
                    










                                                                                   
                        










                                                                                   
      


































































                                                                                                       
 




















































































































































                                                                                                         
 
































                                                                                   

 





































                                                                        

 












                                                                                         
                                                                                     
                                                                                     
                                                                                      



                                                                                                        
                   
                                                                                           
      
                                                                                        








                                                                                                       



























































































                                                                                 




                                                                                                      









































































                                                                                                                                             
 
 
























































                                                                                                                   
 

                                                                                     
                                                                          
 
















































































































































































































































                                                                                                                                            


                                                                                         
     
















                                                                                                  
      
                                                     
                                                                    

                                                                    
 
                                                                      
                                                                      
 
                                                                                                              
                                                                  
                                                
 






                                                                            
     
 



                                                        
                    
                                                                                   
 

                                                         
     

                                                                                                                                                       
 


                                                                                                                        
 

                                                                                   
      



























































                                                                                                                                        
 



                                                                                                         
                                                                           
 

































































                                                                   
               
                                                                                         
      

                                          
 

                                          
              
                                          
      
         
 
                                                                                          
              
                                                                                         
      

                                          
 

                                            
              
                                          
      




                                              
               



                                                  





                                                                                                   

                                            
              
                                           
      


                                              
              
                                           
      



















































                                                                                         
 
 

                                                        
                                              

                                                                                               


















































                                                                                



                                                                                               
















































                                                                                       



                                                                                               








































                                                                                



                                                                                                


















































                                                                                 



                                                                                               


















































                                                                                       



                                                                                               










































                                                                                



                                                                                                 
































































                                                                                       



                                                                                                 






































































                                                                                               
                  

                                                                
      
 
                                                       



                                                                                                 




































                                                                            

 





















                                                                                                       
              

                                                         
      
 
                                                  



                                                                                             
 
































                                                                     



                                                                                               































































                                                                                                                                 
              

                                                    
      









                                                             



                                                                                                 

                                            
 





                                                           
 
                                               
 













                                                                                        
                                                          

                               
      
 











                                                       
              

                               
      











































                                                                                                                                            



                                                                                               
                          
              
                                                        
     
                                                 
      
 





                                                         
 
                             
                                                                         
                                                                        
     
                                                      
      









                                                            
              

                               
      






















                                                                                   
 
              
                                                    
     
                                             
      

 
 

                                                                                          
 

                                                                
 



                                                         

                                                             

                               
      
 









                                                                                                          
              

                               
      

















                                                                                                                                              



                                                                                                 
                          
              
                                                         
     
                                                  

      
 



                                                         
              

                               
      



                                                                 
 
              
                                                     
     
                                              
      



                                                                                                   






































































































































































                                                                                                                                                                                                 

 
                   



                                                                                          
                                              
 




















































































































                                                                                            






                                                      


                                               
                                                   

                                                             
         

                                                                                 




                                                                          

                                                                         

                                                                                                  


































































































































                                                                         



                                                                                                       












                                                                                                  



                                                                                                          




















































                                                                              



                                                                                                          


















                                                                              



                                                                                                      
















                                                         



                                                                                                    


















                                                     




                                                                                                      











                                                                                   
                        















                                                                                 



                                                                                                 










                                                            

 















                                                                                                                


                                            

                                  

                      
                                              



















                                                                                                             

                                            

                                       

                   
                                              

















                                                     

 













                                                                 

 


















                                                                   

 

















                                                                                                              
 









                                                            



                                                      


                                                                                

 



































                                                                                         

 






































                                                                                     

 







































                                                                                            

 

                                          





                                                 


                                           





                                                  



                                        

                                               



                                          







                                                                                       

 


















                                                              



                                                           





























































































































                                                                                                             

 
                                                                     
                                                            















                                             



                                              


                                                 

 


                                                         
                                                                                             
 



































































































                                                                                                                                         




                                                                                     
                                                                                                     

                                                                        





































                                                                                           


                                                                  














































































                                                                                                                



                                            



                                              



                                                        
                                              
                                                                                                                               
 















































                                                                                                                          
                                                                                







































                                                                    

                               









                                                                          
                         









                                                                                                           

                                                               






                                                                                                          
                  



                                                  
                  
 













































                                                                                           
 



                                     
 









                                                                                                          
                  






                                                                                           
                  































                                                                                                
 

































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































                                                                                                                                                                               

                                                


















































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































                                                                                                                                                                                                                                            
 



























                                                                                                                  
                                







































































































































































































































































































































































































































































































































































































































































































































































                                                                                                                                            
                    


                                            
                                         
                                              
                                                              
 





























































                                                                                                                                          



                                            
                                     
                                                        
                                              
                                                              
 





                                                


                                                             



























































                                                
                                          
                                          










                                              
                                             
                                           
                                             

                                                 
                                              
                             
                                             
                                











                                   


                                  
                              

















                                                         

 
























































































                                                                                                               

 

                                                                  
                                                                   
 















































































































































































                                                                                                          


                          
                                                                                       
 



                                                                    

 





                                                                              

                                                              
 

                                           
 
                                           



                                            





                                                     

















                                                                                     
                   
                                          
     
                                         
      



                                              
 
 
                                                                        
 













                                                                                     

 
                                                                           
 
                   
 



                                              

 
                                                                          
 
                                                                   
 
                              
 

                                                  
 


                                               
 

                                      
 

                                                
 
                      
 
                                                           
 

                                                                                                        
 




                                                                             

 






                

                       





























                                                                      
 
 
                   
                                                                                                                     
     
                                                                                                                         
      


                                                                                                                                          
 
             


                                            
                              
                                              

                        










                                                                                                                               
 

                          
                             
 
// Copyright (c) Athena Dev Teams - Licensed under GNU GPL
// For more information, see LICENCE in the main folder

#include "../common/cbasetypes.h"
#include "../common/timer.h"
#include "../common/nullpo.h"
#include "../common/random.h"
#include "../common/showmsg.h"
#include "../common/malloc.h"
#include "../common/utils.h"
#include "../common/ers.h"
#include "../common/strlib.h"

#include "map.h"
#include "path.h"
#include "pc.h"
#include "pet.h"
#include "npc.h"
#include "mob.h"
#include "clif.h"
#include "guild.h"
#include "skill.h"
#include "itemdb.h"
#include "battle.h"
#include "chrif.h"
#include "skill.h"
#include "status.h"
#include "script.h"
#include "unit.h"
#include "homunculus.h"
#include "mercenary.h"
#include "elemental.h"
#include "vending.h"

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <string.h>
#include <math.h>

//Regen related flags.
enum e_regen {
    RGN_HP  = 0x01,
    RGN_SP  = 0x02,
    RGN_SHP = 0x04,
    RGN_SSP = 0x08,
};

static int max_weight_base[CLASS_COUNT];
static int hp_coefficient[CLASS_COUNT];
static int hp_coefficient2[CLASS_COUNT];
static int hp_sigma_val[CLASS_COUNT][MAX_LEVEL+1];
static int sp_coefficient[CLASS_COUNT];
#ifdef RENEWAL_ASPD
static int aspd_base[CLASS_COUNT][MAX_WEAPON_TYPE+1];
#else
static int aspd_base[CLASS_COUNT][MAX_WEAPON_TYPE]; //[blackhole89]
#endif

// bonus values and upgrade chances for refining equipment
static struct {
    int chance[MAX_REFINE]; // success chance
    int bonus[MAX_REFINE]; // cumulative fixed bonus damage
    int randombonus_max[MAX_REFINE]; // cumulative maximum random bonus damage
} refine_info[REFINE_TYPE_MAX];

static int atkmods[3][MAX_WEAPON_TYPE]; //ATK weapon modification for size (size_fix.txt)
static char job_bonus[CLASS_COUNT][MAX_LEVEL];

static struct eri *sc_data_ers; //For sc_data entries
static struct status_data dummy_status;

int current_equip_item_index; //Contains inventory index of an equipped item. To pass it into the EQUP_SCRIPT [Lupus]
int current_equip_card_id; //To prevent card-stacking (from jA) [Skotlex]
//we need it for new cards 15 Feb 2005, to check if the combo cards are insrerted into the CURRENT weapon only
//to avoid cards exploits

static sc_type SkillStatusChangeTable[MAX_SKILL];  // skill  -> status
static int StatusIconChangeTable[SC_MAX];          // status -> "icon" (icon is a bit of a misnomer, since there exist values with no icon associated)
static unsigned int StatusChangeFlagTable[SC_MAX]; // status -> flags
static int StatusSkillChangeTable[SC_MAX];         // status -> skill
static int StatusRelevantBLTypes[SI_MAX];          // "icon" -> enum bl_type (for clif_status_change to identify for which bl types to send packets)
static unsigned int StatusChangeStateTable[SC_MAX]; // status -> flags


/**
 * Returns the status change associated with a skill.
 * @param skill The skill to look up
 * @return The status registered for this skill
 **/
sc_type status_skill2sc(int skill)
{
    int sk = skill_get_index(skill);
    if (sk == 0) {
        ShowError("status_skill2sc: Unsupported skill id %d\n", skill);
        return SC_NONE;
    }
    return SkillStatusChangeTable[sk];
}

/**
 * Returns the FIRST skill (in order of definition in initChangeTables) to use a given status change.
 * Utilized for various duration lookups. Use with caution!
 * @param sc The status to look up
 * @return A skill associated with the status
 **/
int status_sc2skill(sc_type sc)
{
    if (sc < 0 || sc >= SC_MAX) {
        ShowError("status_sc2skill: Unsupported status change id %d\n", sc);
        return 0;
    }

    return StatusSkillChangeTable[sc];
}

/**
 * Returns the status calculation flag associated with a given status change.
 * @param sc The status to look up
 * @return The scb_flag registered for this status (see enum scb_flag)
 **/
unsigned int status_sc2scb_flag(sc_type sc)
{
    if (sc < 0 || sc >= SC_MAX) {
        ShowError("status_sc2scb_flag: Unsupported status change id %d\n", sc);
        return SCB_NONE;
    }

    return StatusChangeFlagTable[sc];
}

/**
 * Returns the bl types which require a status change packet to be sent for a given client status identifier.
 * @param type The client-side status identifier to look up (see enum si_type)
 * @return The bl types relevant to the type (see enum bl_type)
 **/
int status_type2relevant_bl_types(int type)
{
    if (type < 0 || type >= SI_MAX) {
        ShowError("status_type2relevant_bl_types: Unsupported type %d\n", type);
        return SI_BLANK;
    }

    return StatusRelevantBLTypes[type];
}

#define add_sc(skill,sc) set_sc(skill,sc,SI_BLANK,SCB_NONE)
// indicates that the status displays a visual effect for the affected unit, and should be sent to the client for all supported units
#define set_sc_with_vfx(skill, sc, icon, flag) set_sc((skill), (sc), (icon), (flag)); if((icon) < SI_MAX) StatusRelevantBLTypes[(icon)] |= BL_SCEFFECT

static void set_sc(int skill, sc_type sc, int icon, unsigned int flag)
{
    int sk = skill_get_index(skill);
    if (sk == 0) {
        ShowError("set_sc: Unsupported skill id %d\n", skill);
        return;
    }
    if (sc < 0 || sc >= SC_MAX) {
        ShowError("set_sc: Unsupported status change id %d\n", sc);
        return;
    }

    if (StatusSkillChangeTable[sc] == 0)
        StatusSkillChangeTable[sc] = skill;
    if (StatusIconChangeTable[sc] == SI_BLANK)
        StatusIconChangeTable[sc] = icon;
    StatusChangeFlagTable[sc] |= flag;

    if (SkillStatusChangeTable[sk] == SC_NONE)
        SkillStatusChangeTable[sk] = sc;
}

void initChangeTables(void)
{
    int i;

    for (i = 0; i < SC_MAX; i++)
        StatusIconChangeTable[i] = SI_BLANK;

    for (i = 0; i < MAX_SKILL; i++)
        SkillStatusChangeTable[i] = SC_NONE;

    for (i = 0; i < SI_MAX; i++)
        StatusRelevantBLTypes[i] = BL_PC;

    memset(StatusSkillChangeTable, 0, sizeof(StatusSkillChangeTable));
    memset(StatusChangeFlagTable, 0, sizeof(StatusChangeFlagTable));
    memset(StatusChangeStateTable, 0, sizeof(StatusChangeStateTable));


    //First we define the skill for common ailments. These are used in skill_additional_effect through sc cards. [Skotlex]
    set_sc(NPC_PETRIFYATTACK , SC_STONE     , SI_BLANK    , SCB_DEF_ELE|SCB_DEF|SCB_MDEF);
    set_sc(NPC_WIDEFREEZE    , SC_FREEZE    , SI_BLANK    , SCB_DEF_ELE|SCB_DEF|SCB_MDEF);
    set_sc(NPC_STUNATTACK    , SC_STUN      , SI_BLANK    , SCB_NONE);
    set_sc(NPC_SLEEPATTACK   , SC_SLEEP     , SI_BLANK    , SCB_NONE);
    set_sc(NPC_POISON        , SC_POISON    , SI_BLANK    , SCB_DEF2|SCB_REGEN);
    set_sc(NPC_CURSEATTACK   , SC_CURSE     , SI_BLANK    , SCB_LUK|SCB_BATK|SCB_WATK|SCB_SPEED);
    set_sc(NPC_SILENCEATTACK , SC_SILENCE   , SI_BLANK    , SCB_NONE);
    set_sc(NPC_WIDECONFUSE   , SC_CONFUSION , SI_BLANK    , SCB_NONE);
    set_sc(NPC_BLINDATTACK   , SC_BLIND     , SI_BLANK    , SCB_HIT|SCB_FLEE);
    set_sc(NPC_BLEEDING      , SC_BLEEDING  , SI_BLEEDING , SCB_REGEN);
    set_sc(NPC_POISON        , SC_DPOISON   , SI_BLANK    , SCB_DEF2|SCB_REGEN);

    //The main status definitions
    add_sc(SM_BASH              , SC_STUN);
    set_sc(SM_PROVOKE           , SC_PROVOKE         , SI_PROVOKE         , SCB_DEF|SCB_DEF2|SCB_BATK|SCB_WATK);
    add_sc(SM_MAGNUM            , SC_WATK_ELEMENT);
    set_sc(SM_ENDURE            , SC_ENDURE          , SI_ENDURE          , SCB_MDEF|SCB_DSPD);
    add_sc(MG_SIGHT             , SC_SIGHT);
    add_sc(MG_SAFETYWALL        , SC_SAFETYWALL);
    add_sc(MG_FROSTDIVER        , SC_FREEZE);
    add_sc(MG_STONECURSE        , SC_STONE);
    add_sc(AL_RUWACH            , SC_RUWACH);
    add_sc(AL_PNEUMA            , SC_PNEUMA);
    set_sc(AL_INCAGI            , SC_INCREASEAGI     , SI_INCREASEAGI     , SCB_AGI|SCB_SPEED);
    set_sc(AL_DECAGI            , SC_DECREASEAGI     , SI_DECREASEAGI     , SCB_AGI|SCB_SPEED);
    set_sc(AL_CRUCIS            , SC_SIGNUMCRUCIS    , SI_SIGNUMCRUCIS    , SCB_DEF);
    set_sc(AL_ANGELUS           , SC_ANGELUS         , SI_ANGELUS         , SCB_DEF2);
    set_sc(AL_BLESSING          , SC_BLESSING        , SI_BLESSING        , SCB_STR|SCB_INT|SCB_DEX);
    set_sc(AC_CONCENTRATION     , SC_CONCENTRATE     , SI_CONCENTRATE     , SCB_AGI|SCB_DEX);
    set_sc(TF_HIDING            , SC_HIDING          , SI_HIDING          , SCB_SPEED);
    add_sc(TF_POISON            , SC_POISON);
    set_sc(KN_TWOHANDQUICKEN    , SC_TWOHANDQUICKEN  , SI_TWOHANDQUICKEN  , SCB_ASPD);
    add_sc(KN_AUTOCOUNTER       , SC_AUTOCOUNTER);
    set_sc(PR_IMPOSITIO         , SC_IMPOSITIO       , SI_IMPOSITIO       , SCB_WATK);
    set_sc(PR_SUFFRAGIUM        , SC_SUFFRAGIUM      , SI_SUFFRAGIUM      , SCB_NONE);
    set_sc(PR_ASPERSIO          , SC_ASPERSIO        , SI_ASPERSIO        , SCB_ATK_ELE);
    set_sc(PR_BENEDICTIO        , SC_BENEDICTIO      , SI_BENEDICTIO      , SCB_DEF_ELE);
    set_sc(PR_SLOWPOISON        , SC_SLOWPOISON      , SI_SLOWPOISON      , SCB_REGEN);
    set_sc(PR_KYRIE             , SC_KYRIE           , SI_KYRIE           , SCB_NONE);
    set_sc(PR_MAGNIFICAT        , SC_MAGNIFICAT      , SI_MAGNIFICAT      , SCB_REGEN);
    set_sc(PR_GLORIA            , SC_GLORIA          , SI_GLORIA          , SCB_LUK);
    add_sc(PR_LEXDIVINA         , SC_SILENCE);
    set_sc(PR_LEXAETERNA        , SC_AETERNA         , SI_AETERNA         , SCB_NONE);
    add_sc(WZ_METEOR            , SC_STUN);
    add_sc(WZ_VERMILION         , SC_BLIND);
    add_sc(WZ_FROSTNOVA         , SC_FREEZE);
    add_sc(WZ_STORMGUST         , SC_FREEZE);
    set_sc(WZ_QUAGMIRE          , SC_QUAGMIRE        , SI_QUAGMIRE        , SCB_AGI|SCB_DEX|SCB_ASPD|SCB_SPEED);
    set_sc(BS_ADRENALINE        , SC_ADRENALINE      , SI_ADRENALINE      , SCB_ASPD);
    set_sc(BS_WEAPONPERFECT     , SC_WEAPONPERFECTION, SI_WEAPONPERFECTION, SCB_NONE);
    set_sc(BS_OVERTHRUST        , SC_OVERTHRUST      , SI_OVERTHRUST      , SCB_NONE);
    set_sc(BS_MAXIMIZE          , SC_MAXIMIZEPOWER   , SI_MAXIMIZEPOWER   , SCB_REGEN);
    add_sc(HT_LANDMINE          , SC_STUN);
    add_sc(HT_ANKLESNARE        , SC_ANKLE);
    add_sc(HT_SANDMAN           , SC_SLEEP);
    add_sc(HT_FLASHER           , SC_BLIND);
    add_sc(HT_FREEZINGTRAP      , SC_FREEZE);
    set_sc(AS_CLOAKING          , SC_CLOAKING        , SI_CLOAKING        , SCB_CRI|SCB_SPEED);
    add_sc(AS_SONICBLOW         , SC_STUN);
    set_sc(AS_ENCHANTPOISON     , SC_ENCPOISON       , SI_ENCPOISON       , SCB_ATK_ELE);
    set_sc(AS_POISONREACT       , SC_POISONREACT     , SI_POISONREACT     , SCB_NONE);
    add_sc(AS_VENOMDUST         , SC_POISON);
    add_sc(AS_SPLASHER          , SC_SPLASHER);
    set_sc(NV_TRICKDEAD         , SC_TRICKDEAD       , SI_TRICKDEAD       , SCB_REGEN);
    set_sc(SM_AUTOBERSERK       , SC_AUTOBERSERK     , SI_AUTOBERSERK     , SCB_NONE);
    add_sc(TF_SPRINKLESAND      , SC_BLIND);
    add_sc(TF_THROWSTONE        , SC_STUN);
    set_sc(MC_LOUD              , SC_LOUD            , SI_LOUD            , SCB_STR);
    set_sc(MG_ENERGYCOAT        , SC_ENERGYCOAT      , SI_ENERGYCOAT      , SCB_NONE);
    set_sc(NPC_EMOTION          , SC_MODECHANGE      , SI_BLANK           , SCB_MODE);
    add_sc(NPC_EMOTION_ON       , SC_MODECHANGE);
    set_sc(NPC_ATTRICHANGE      , SC_ELEMENTALCHANGE , SI_ARMOR_PROPERTY  , SCB_DEF_ELE);
    add_sc(NPC_CHANGEWATER      , SC_ELEMENTALCHANGE);
    add_sc(NPC_CHANGEGROUND     , SC_ELEMENTALCHANGE);
    add_sc(NPC_CHANGEFIRE       , SC_ELEMENTALCHANGE);
    add_sc(NPC_CHANGEWIND       , SC_ELEMENTALCHANGE);
    add_sc(NPC_CHANGEPOISON     , SC_ELEMENTALCHANGE);
    add_sc(NPC_CHANGEHOLY       , SC_ELEMENTALCHANGE);
    add_sc(NPC_CHANGEDARKNESS   , SC_ELEMENTALCHANGE);
    add_sc(NPC_CHANGETELEKINESIS, SC_ELEMENTALCHANGE);
    add_sc(NPC_POISON           , SC_POISON);
    add_sc(NPC_BLINDATTACK      , SC_BLIND);
    add_sc(NPC_SILENCEATTACK    , SC_SILENCE);
    add_sc(NPC_STUNATTACK       , SC_STUN);
    add_sc(NPC_PETRIFYATTACK    , SC_STONE);
    add_sc(NPC_CURSEATTACK      , SC_CURSE);
    add_sc(NPC_SLEEPATTACK      , SC_SLEEP);
    add_sc(NPC_MAGICALATTACK    , SC_MAGICALATTACK);
    set_sc(NPC_KEEPING          , SC_KEEPING         , SI_BLANK           , SCB_DEF);
    add_sc(NPC_DARKBLESSING     , SC_COMA);
    set_sc(NPC_BARRIER          , SC_BARRIER         , SI_BLANK           , SCB_MDEF|SCB_DEF);
    add_sc(NPC_DEFENDER         , SC_ARMOR);
    add_sc(NPC_LICK             , SC_STUN);
    set_sc(NPC_HALLUCINATION    , SC_HALLUCINATION   , SI_HALLUCINATION   , SCB_NONE);
    add_sc(NPC_REBIRTH          , SC_REBIRTH);
    add_sc(RG_RAID              , SC_STUN);
#ifdef RENEWAL
    add_sc(RG_RAID              , SC_RAID);
    add_sc(RG_BACKSTAP          , SC_STUN);
#endif
    set_sc(RG_STRIPWEAPON       , SC_STRIPWEAPON     , SI_STRIPWEAPON     , SCB_WATK);
    set_sc(RG_STRIPSHIELD       , SC_STRIPSHIELD     , SI_STRIPSHIELD     , SCB_DEF);
    set_sc(RG_STRIPARMOR        , SC_STRIPARMOR      , SI_STRIPARMOR      , SCB_VIT);
    set_sc(RG_STRIPHELM         , SC_STRIPHELM       , SI_STRIPHELM       , SCB_INT);
    add_sc(AM_ACIDTERROR        , SC_BLEEDING);
    set_sc(AM_CP_WEAPON         , SC_CP_WEAPON       , SI_CP_WEAPON       , SCB_NONE);
    set_sc(AM_CP_SHIELD         , SC_CP_SHIELD       , SI_CP_SHIELD       , SCB_NONE);
    set_sc(AM_CP_ARMOR          , SC_CP_ARMOR        , SI_CP_ARMOR        , SCB_NONE);
    set_sc(AM_CP_HELM           , SC_CP_HELM         , SI_CP_HELM         , SCB_NONE);
    set_sc(CR_AUTOGUARD         , SC_AUTOGUARD       , SI_AUTOGUARD       , SCB_NONE);
    add_sc(CR_SHIELDCHARGE      , SC_STUN);
    set_sc(CR_REFLECTSHIELD     , SC_REFLECTSHIELD   , SI_REFLECTSHIELD   , SCB_NONE);
    add_sc(CR_HOLYCROSS         , SC_BLIND);
    add_sc(CR_GRANDCROSS        , SC_BLIND);
    add_sc(CR_DEVOTION          , SC_DEVOTION);
    set_sc(CR_PROVIDENCE        , SC_PROVIDENCE      , SI_PROVIDENCE      , SCB_ALL);
    set_sc(CR_DEFENDER          , SC_DEFENDER        , SI_DEFENDER        , SCB_SPEED|SCB_ASPD);
    set_sc(CR_SPEARQUICKEN      , SC_SPEARQUICKEN    , SI_SPEARQUICKEN    , SCB_ASPD|SCB_CRI|SCB_FLEE);
    set_sc(MO_STEELBODY         , SC_STEELBODY       , SI_STEELBODY       , SCB_DEF|SCB_MDEF|SCB_ASPD|SCB_SPEED);
    add_sc(MO_BLADESTOP         , SC_BLADESTOP_WAIT);
    add_sc(MO_BLADESTOP         , SC_BLADESTOP);
    set_sc(MO_EXPLOSIONSPIRITS  , SC_EXPLOSIONSPIRITS, SI_EXPLOSIONSPIRITS, SCB_CRI|SCB_REGEN);
    set_sc(MO_EXTREMITYFIST     , SC_EXTREMITYFIST   , SI_BLANK           , SCB_REGEN);
#ifdef RENEWAL
    set_sc(MO_EXTREMITYFIST     , SC_EXTREMITYFIST2   , SI_EXTREMITYFIST   , SCB_NONE);
#endif
    add_sc(SA_MAGICROD          , SC_MAGICROD);
    set_sc(SA_AUTOSPELL         , SC_AUTOSPELL       , SI_AUTOSPELL       , SCB_NONE);
    set_sc(SA_FLAMELAUNCHER     , SC_FIREWEAPON      , SI_FIREWEAPON      , SCB_ATK_ELE);
    set_sc(SA_FROSTWEAPON       , SC_WATERWEAPON     , SI_WATERWEAPON     , SCB_ATK_ELE);
    set_sc(SA_LIGHTNINGLOADER   , SC_WINDWEAPON      , SI_WINDWEAPON      , SCB_ATK_ELE);
    set_sc(SA_SEISMICWEAPON     , SC_EARTHWEAPON     , SI_EARTHWEAPON     , SCB_ATK_ELE);
    set_sc(SA_VOLCANO           , SC_VOLCANO         , SI_LANDENDOW       , SCB_WATK);
    set_sc(SA_DELUGE            , SC_DELUGE          , SI_LANDENDOW       , SCB_MAXHP);
    set_sc(SA_VIOLENTGALE       , SC_VIOLENTGALE     , SI_LANDENDOW       , SCB_FLEE);
    add_sc(SA_REVERSEORCISH     , SC_ORCISH);
    add_sc(SA_COMA              , SC_COMA);
    set_sc(BD_ENCORE            , SC_DANCING         , SI_BLANK           , SCB_SPEED|SCB_REGEN);
    add_sc(BD_RICHMANKIM        , SC_RICHMANKIM);
    set_sc(BD_ETERNALCHAOS      , SC_ETERNALCHAOS    , SI_BLANK           , SCB_DEF2);
    set_sc(BD_DRUMBATTLEFIELD   , SC_DRUMBATTLE      , SI_BLANK           , SCB_WATK|SCB_DEF);
    set_sc(BD_RINGNIBELUNGEN    , SC_NIBELUNGEN      , SI_BLANK           , SCB_WATK);
    add_sc(BD_ROKISWEIL         , SC_ROKISWEIL);
    add_sc(BD_INTOABYSS         , SC_INTOABYSS);
    set_sc(BD_SIEGFRIED         , SC_SIEGFRIED       , SI_BLANK           , SCB_ALL);
    add_sc(BA_FROSTJOKER        , SC_FREEZE);
    set_sc(BA_WHISTLE           , SC_WHISTLE         , SI_BLANK           , SCB_FLEE|SCB_FLEE2);
    set_sc(BA_ASSASSINCROSS     , SC_ASSNCROS        , SI_BLANK           , SCB_ASPD);
    add_sc(BA_POEMBRAGI         , SC_POEMBRAGI);
    set_sc(BA_APPLEIDUN         , SC_APPLEIDUN       , SI_BLANK           , SCB_MAXHP);
    add_sc(DC_SCREAM            , SC_STUN);
    set_sc(DC_HUMMING           , SC_HUMMING         , SI_BLANK           , SCB_HIT);
    set_sc(DC_DONTFORGETME      , SC_DONTFORGETME    , SI_BLANK           , SCB_SPEED|SCB_ASPD);
    set_sc(DC_FORTUNEKISS       , SC_FORTUNE         , SI_BLANK           , SCB_CRI);
    set_sc(DC_SERVICEFORYOU     , SC_SERVICE4U       , SI_BLANK           , SCB_ALL);
    add_sc(NPC_DARKCROSS        , SC_BLIND);
    add_sc(NPC_GRANDDARKNESS    , SC_BLIND);
    set_sc(NPC_STOP             , SC_STOP            , SI_STOP            , SCB_NONE);
    set_sc(NPC_WEAPONBRAKER     , SC_BROKENWEAPON    , SI_BROKENWEAPON    , SCB_NONE);
    set_sc(NPC_ARMORBRAKE       , SC_BROKENARMOR     , SI_BROKENARMOR     , SCB_NONE);
    set_sc(NPC_CHANGEUNDEAD     , SC_CHANGEUNDEAD    , SI_UNDEAD          , SCB_DEF_ELE);
    set_sc(NPC_POWERUP          , SC_INCHITRATE      , SI_BLANK           , SCB_HIT);
    set_sc(NPC_AGIUP            , SC_INCFLEERATE     , SI_BLANK           , SCB_FLEE);
    add_sc(NPC_INVISIBLE        , SC_CLOAKING);
    set_sc(LK_AURABLADE         , SC_AURABLADE       , SI_AURABLADE       , SCB_NONE);
    set_sc(LK_PARRYING          , SC_PARRYING        , SI_PARRYING        , SCB_NONE);
    set_sc(LK_CONCENTRATION     , SC_CONCENTRATION   , SI_CONCENTRATION   , SCB_BATK|SCB_WATK|SCB_HIT|SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_DSPD);
    set_sc(LK_TENSIONRELAX      , SC_TENSIONRELAX    , SI_TENSIONRELAX    , SCB_REGEN);
    set_sc(LK_BERSERK           , SC_BERSERK         , SI_BERSERK         , SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_MDEF2|SCB_FLEE|SCB_SPEED|SCB_ASPD|SCB_MAXHP|SCB_REGEN);
    set_sc(HP_ASSUMPTIO         , SC_ASSUMPTIO       , SI_ASSUMPTIO       , SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_MDEF2);
    add_sc(HP_BASILICA          , SC_BASILICA);
    set_sc(HW_MAGICPOWER        , SC_MAGICPOWER      , SI_MAGICPOWER      , SCB_MATK);
    add_sc(PA_SACRIFICE         , SC_SACRIFICE);
    set_sc(PA_GOSPEL            , SC_GOSPEL          , SI_BLANK           , SCB_SPEED|SCB_ASPD);
    add_sc(PA_GOSPEL            , SC_SCRESIST);
    add_sc(CH_TIGERFIST         , SC_STOP);
    set_sc(ASC_EDP              , SC_EDP             , SI_EDP             , SCB_NONE);
    set_sc(SN_SIGHT             , SC_TRUESIGHT       , SI_TRUESIGHT       , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK|SCB_CRI|SCB_HIT);
    set_sc(SN_WINDWALK          , SC_WINDWALK        , SI_WINDWALK        , SCB_FLEE|SCB_SPEED);
    set_sc(WS_MELTDOWN          , SC_MELTDOWN        , SI_MELTDOWN        , SCB_NONE);
    set_sc(WS_CARTBOOST         , SC_CARTBOOST       , SI_CARTBOOST       , SCB_SPEED);
    set_sc(ST_CHASEWALK         , SC_CHASEWALK       , SI_BLANK           , SCB_SPEED);
    set_sc(ST_REJECTSWORD       , SC_REJECTSWORD     , SI_REJECTSWORD     , SCB_NONE);
    add_sc(ST_REJECTSWORD       , SC_AUTOCOUNTER);
    set_sc(CG_MARIONETTE        , SC_MARIONETTE      , SI_MARIONETTE      , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK);
    set_sc(CG_MARIONETTE        , SC_MARIONETTE2     , SI_MARIONETTE2     , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK);
    add_sc(LK_SPIRALPIERCE      , SC_STOP);
    add_sc(LK_HEADCRUSH         , SC_BLEEDING);
    set_sc(LK_JOINTBEAT         , SC_JOINTBEAT       , SI_JOINTBEAT       , SCB_BATK|SCB_DEF2|SCB_SPEED|SCB_ASPD);
    add_sc(HW_NAPALMVULCAN      , SC_CURSE);
    set_sc(PF_MINDBREAKER       , SC_MINDBREAKER     , SI_BLANK           , SCB_MATK|SCB_MDEF2);
    add_sc(PF_MEMORIZE          , SC_MEMORIZE);
    add_sc(PF_FOGWALL           , SC_FOGWALL);
    set_sc(PF_SPIDERWEB         , SC_SPIDERWEB       , SI_BLANK           , SCB_FLEE);
    set_sc(WE_BABY              , SC_BABY            , SI_BABY            , SCB_NONE);
    set_sc(TK_RUN               , SC_RUN             , SI_RUN             , SCB_SPEED|SCB_DSPD);
    set_sc(TK_RUN               , SC_SPURT           , SI_SPURT           , SCB_STR);
    set_sc(TK_READYSTORM        , SC_READYSTORM      , SI_READYSTORM      , SCB_NONE);
    set_sc(TK_READYDOWN         , SC_READYDOWN       , SI_READYDOWN       , SCB_NONE);
    add_sc(TK_DOWNKICK          , SC_STUN);
    set_sc(TK_READYTURN         , SC_READYTURN       , SI_READYTURN       , SCB_NONE);
    set_sc(TK_READYCOUNTER      , SC_READYCOUNTER    , SI_READYCOUNTER    , SCB_NONE);
    set_sc(TK_DODGE             , SC_DODGE           , SI_DODGE           , SCB_NONE);
    set_sc(TK_SPTIME            , SC_EARTHSCROLL     , SI_EARTHSCROLL     , SCB_NONE);
    add_sc(TK_SEVENWIND         , SC_SEVENWIND);
    set_sc(TK_SEVENWIND         , SC_GHOSTWEAPON     , SI_GHOSTWEAPON     , SCB_ATK_ELE);
    set_sc(TK_SEVENWIND         , SC_SHADOWWEAPON    , SI_SHADOWWEAPON    , SCB_ATK_ELE);
    set_sc(SG_SUN_WARM          , SC_WARM            , SI_WARM            , SCB_NONE);
    add_sc(SG_MOON_WARM         , SC_WARM);
    add_sc(SG_STAR_WARM         , SC_WARM);
    set_sc(SG_SUN_COMFORT       , SC_SUN_COMFORT     , SI_SUN_COMFORT     , SCB_DEF2);
    set_sc(SG_MOON_COMFORT      , SC_MOON_COMFORT    , SI_MOON_COMFORT    , SCB_FLEE);
    set_sc(SG_STAR_COMFORT      , SC_STAR_COMFORT    , SI_STAR_COMFORT    , SCB_ASPD);
    add_sc(SG_FRIEND            , SC_SKILLRATE_UP);
    set_sc(SG_KNOWLEDGE         , SC_KNOWLEDGE       , SI_BLANK           , SCB_ALL);
    set_sc(SG_FUSION            , SC_FUSION          , SI_BLANK           , SCB_SPEED);
    set_sc(BS_ADRENALINE2       , SC_ADRENALINE2     , SI_ADRENALINE2     , SCB_ASPD);
    set_sc(SL_KAIZEL            , SC_KAIZEL          , SI_KAIZEL          , SCB_NONE);
    set_sc(SL_KAAHI             , SC_KAAHI           , SI_KAAHI           , SCB_NONE);
    set_sc(SL_KAUPE             , SC_KAUPE           , SI_KAUPE           , SCB_NONE);
    set_sc(SL_KAITE             , SC_KAITE           , SI_KAITE           , SCB_NONE);
    add_sc(SL_STUN              , SC_STUN);
    set_sc(SL_SWOO              , SC_SWOO            , SI_BLANK           , SCB_SPEED);
    set_sc(SL_SKE               , SC_SKE             , SI_BLANK           , SCB_BATK|SCB_WATK|SCB_DEF|SCB_DEF2);
    set_sc(SL_SKA               , SC_SKA             , SI_BLANK           , SCB_DEF|SCB_MDEF|SCB_ASPD);
    set_sc(SL_SMA               , SC_SMA             , SI_SMA             , SCB_NONE);
    set_sc(SM_SELFPROVOKE       , SC_PROVOKE         , SI_PROVOKE         , SCB_DEF|SCB_DEF2|SCB_BATK|SCB_WATK);
    set_sc(ST_PRESERVE          , SC_PRESERVE        , SI_PRESERVE        , SCB_NONE);
    set_sc(PF_DOUBLECASTING     , SC_DOUBLECAST      , SI_DOUBLECAST      , SCB_NONE);
    set_sc(HW_GRAVITATION       , SC_GRAVITATION     , SI_BLANK           , SCB_ASPD);
    add_sc(WS_CARTTERMINATION   , SC_STUN);
    set_sc(WS_OVERTHRUSTMAX     , SC_MAXOVERTHRUST   , SI_MAXOVERTHRUST   , SCB_NONE);
    set_sc(CG_LONGINGFREEDOM    , SC_LONGING         , SI_BLANK           , SCB_SPEED|SCB_ASPD);
    add_sc(CG_HERMODE           , SC_HERMODE);
    set_sc(ITEM_ENCHANTARMS     , SC_ENCHANTARMS     , SI_BLANK           , SCB_ATK_ELE);
    set_sc(SL_HIGH              , SC_SPIRIT          , SI_SPIRIT          , SCB_ALL);
    set_sc(KN_ONEHAND           , SC_ONEHAND         , SI_ONEHAND         , SCB_ASPD);
    set_sc(GS_FLING             , SC_FLING           , SI_BLANK           , SCB_DEF|SCB_DEF2);
    add_sc(GS_CRACKER           , SC_STUN);
    add_sc(GS_DISARM            , SC_STRIPWEAPON);
    add_sc(GS_PIERCINGSHOT      , SC_BLEEDING);
    set_sc(GS_MADNESSCANCEL     , SC_MADNESSCANCEL   , SI_MADNESSCANCEL   , SCB_BATK|SCB_ASPD);
    set_sc(GS_ADJUSTMENT        , SC_ADJUSTMENT      , SI_ADJUSTMENT      , SCB_HIT|SCB_FLEE);
    set_sc(GS_INCREASING        , SC_INCREASING      , SI_ACCURACY        , SCB_AGI|SCB_DEX|SCB_HIT);
    set_sc(GS_GATLINGFEVER      , SC_GATLINGFEVER    , SI_GATLINGFEVER    , SCB_BATK|SCB_FLEE|SCB_SPEED|SCB_ASPD);
    set_sc(NJ_TATAMIGAESHI      , SC_TATAMIGAESHI    , SI_BLANK           , SCB_NONE);
    set_sc(NJ_SUITON            , SC_SUITON          , SI_BLANK           , SCB_AGI|SCB_SPEED);
    add_sc(NJ_HYOUSYOURAKU      , SC_FREEZE);
    set_sc(NJ_NEN               , SC_NEN             , SI_NEN             , SCB_STR|SCB_INT);
    set_sc(NJ_UTSUSEMI          , SC_UTSUSEMI        , SI_UTSUSEMI        , SCB_NONE);
    set_sc(NJ_BUNSINJYUTSU      , SC_BUNSINJYUTSU    , SI_BUNSINJYUTSU    , SCB_DYE);

    add_sc(NPC_ICEBREATH        , SC_FREEZE);
    add_sc(NPC_ACIDBREATH       , SC_POISON);
    add_sc(NPC_HELLJUDGEMENT    , SC_CURSE);
    add_sc(NPC_WIDESILENCE      , SC_SILENCE);
    add_sc(NPC_WIDEFREEZE       , SC_FREEZE);
    add_sc(NPC_WIDEBLEEDING     , SC_BLEEDING);
    add_sc(NPC_WIDESTONE        , SC_STONE);
    add_sc(NPC_WIDECONFUSE      , SC_CONFUSION);
    add_sc(NPC_WIDESLEEP        , SC_SLEEP);
    add_sc(NPC_WIDESIGHT        , SC_SIGHT);
    add_sc(NPC_EVILLAND         , SC_BLIND);
    add_sc(NPC_MAGICMIRROR      , SC_MAGICMIRROR);
    set_sc(NPC_SLOWCAST         , SC_SLOWCAST        , SI_SLOWCAST        , SCB_NONE);
    set_sc(NPC_CRITICALWOUND    , SC_CRITICALWOUND   , SI_CRITICALWOUND   , SCB_NONE);
    set_sc(NPC_STONESKIN        , SC_ARMORCHANGE     , SI_BLANK           , SCB_DEF|SCB_MDEF);
    add_sc(NPC_ANTIMAGIC        , SC_ARMORCHANGE);
    add_sc(NPC_WIDECURSE        , SC_CURSE);
    add_sc(NPC_WIDESTUN         , SC_STUN);

    set_sc(NPC_HELLPOWER        , SC_HELLPOWER       , SI_HELLPOWER       , SCB_NONE);
    set_sc(NPC_WIDEHELLDIGNITY  , SC_HELLPOWER       , SI_HELLPOWER       , SCB_NONE);
    set_sc(NPC_INVINCIBLE       , SC_INVINCIBLE      , SI_INVINCIBLE      , SCB_SPEED);
    set_sc(NPC_INVINCIBLEOFF    , SC_INVINCIBLEOFF   , SI_BLANK           , SCB_SPEED);

    set_sc(CASH_BLESSING        , SC_BLESSING        , SI_BLESSING        , SCB_STR|SCB_INT|SCB_DEX);
    set_sc(CASH_INCAGI          , SC_INCREASEAGI     , SI_INCREASEAGI     , SCB_AGI|SCB_SPEED);
    set_sc(CASH_ASSUMPTIO       , SC_ASSUMPTIO       , SI_ASSUMPTIO       , SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_MDEF2);

    set_sc(ALL_PARTYFLEE        , SC_PARTYFLEE       , SI_PARTYFLEE       , SCB_NONE);
    set_sc(ALL_ODINS_POWER      , SC_ODINS_POWER     , SI_ODINS_POWER     , SCB_MATK|SCB_BATK|SCB_MDEF|SCB_DEF);

    set_sc(CR_SHRINK            , SC_SHRINK          , SI_SHRINK          , SCB_NONE);
    set_sc(RG_CLOSECONFINE      , SC_CLOSECONFINE2   , SI_CLOSECONFINE2   , SCB_NONE);
    set_sc(RG_CLOSECONFINE      , SC_CLOSECONFINE    , SI_CLOSECONFINE    , SCB_FLEE);
    set_sc(WZ_SIGHTBLASTER      , SC_SIGHTBLASTER    , SI_SIGHTBLASTER    , SCB_NONE);
    set_sc(DC_WINKCHARM         , SC_WINKCHARM       , SI_WINKCHARM       , SCB_NONE);
    add_sc(MO_BALKYOUNG         , SC_STUN);
    add_sc(SA_ELEMENTWATER      , SC_ELEMENTALCHANGE);
    add_sc(SA_ELEMENTFIRE       , SC_ELEMENTALCHANGE);
    add_sc(SA_ELEMENTGROUND     , SC_ELEMENTALCHANGE);
    add_sc(SA_ELEMENTWIND       , SC_ELEMENTALCHANGE);

    set_sc(HLIF_AVOID           , SC_AVOID           , SI_BLANK           , SCB_SPEED);
    set_sc(HLIF_CHANGE          , SC_CHANGE          , SI_BLANK           , SCB_VIT|SCB_INT);
    set_sc(HFLI_FLEET           , SC_FLEET           , SI_BLANK           , SCB_ASPD|SCB_BATK|SCB_WATK);
    set_sc(HFLI_SPEED           , SC_SPEED           , SI_BLANK           , SCB_FLEE);
    set_sc(HAMI_DEFENCE         , SC_DEFENCE         , SI_BLANK           , SCB_DEF);
    set_sc(HAMI_BLOODLUST       , SC_BLOODLUST       , SI_BLANK           , SCB_BATK|SCB_WATK);

    // Homunculus S
    add_sc(MH_STAHL_HORN, SC_STUN);
    set_sc(MH_ANGRIFFS_MODUS, SC_ANGRIFFS_MODUS, SI_ANGRIFFS_MODUS, SCB_BATK | SCB_DEF | SCB_FLEE | SCB_MAXHP);
    set_sc(MH_GOLDENE_FERSE, SC_GOLDENE_FERSE, SI_GOLDENE_FERSE,  SCB_ASPD|SCB_MAXHP);
    add_sc(MH_STEINWAND, SC_SAFETYWALL);
    add_sc(MH_ERASER_CUTTER, SC_ERASER_CUTTER);
    set_sc(MH_OVERED_BOOST, SC_OVERED_BOOST, SI_BLANK, SCB_FLEE|SCB_ASPD);
    add_sc(MH_LIGHT_OF_REGENE, SC_LIGHT_OF_REGENE);
    set_sc(MH_VOLCANIC_ASH, SC_ASH, SI_VOLCANIC_ASH, SCB_DEF|SCB_DEF2|SCB_HIT|SCB_BATK|SCB_FLEE);
    set_sc(MH_GRANITIC_ARMOR, SC_GRANITIC_ARMOR, SI_GRANITIC_ARMOR, SCB_NONE);
    set_sc(MH_MAGMA_FLOW, SC_MAGMA_FLOW, SI_MAGMA_FLOW, SCB_NONE);
    set_sc(MH_PYROCLASTIC, SC_PYROCLASTIC, SI_PYROCLASTIC, SCB_BATK|SCB_ATK_ELE);
    add_sc(MH_LAVA_SLIDE, SC_BURNING);
    set_sc(MH_NEEDLE_OF_PARALYZE, SC_PARALYSIS, SI_NEEDLE_OF_PARALYZE, SCB_DEF2);
    add_sc(MH_POISON_MIST, SC_BLIND);
    set_sc(MH_PAIN_KILLER, SC_PAIN_KILLER, SI_PAIN_KILLER, SCB_ASPD);

    add_sc(MH_STYLE_CHANGE, SC_STYLE_CHANGE);


    add_sc(MER_CRASH            , SC_STUN);
    set_sc(MER_PROVOKE          , SC_PROVOKE         , SI_PROVOKE         , SCB_DEF|SCB_DEF2|SCB_BATK|SCB_WATK);
    add_sc(MS_MAGNUM            , SC_WATK_ELEMENT);
    add_sc(MER_SIGHT            , SC_SIGHT);
    set_sc(MER_DECAGI           , SC_DECREASEAGI     , SI_DECREASEAGI     , SCB_AGI|SCB_SPEED);
    set_sc(MER_MAGNIFICAT       , SC_MAGNIFICAT      , SI_MAGNIFICAT      , SCB_REGEN);
    add_sc(MER_LEXDIVINA        , SC_SILENCE);
    add_sc(MA_LANDMINE          , SC_STUN);
    add_sc(MA_SANDMAN           , SC_SLEEP);
    add_sc(MA_FREEZINGTRAP      , SC_FREEZE);
    set_sc(MER_AUTOBERSERK      , SC_AUTOBERSERK     , SI_AUTOBERSERK     , SCB_NONE);
    set_sc(ML_AUTOGUARD         , SC_AUTOGUARD       , SI_AUTOGUARD       , SCB_NONE);
    set_sc(MS_REFLECTSHIELD     , SC_REFLECTSHIELD   , SI_REFLECTSHIELD   , SCB_NONE);
    set_sc(ML_DEFENDER          , SC_DEFENDER        , SI_DEFENDER        , SCB_SPEED|SCB_ASPD);
    set_sc(MS_PARRYING          , SC_PARRYING        , SI_PARRYING        , SCB_NONE);
    set_sc(MS_BERSERK           , SC_BERSERK         , SI_BERSERK         , SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_MDEF2|SCB_FLEE|SCB_SPEED|SCB_ASPD|SCB_MAXHP|SCB_REGEN);
    add_sc(ML_SPIRALPIERCE      , SC_STOP);
    set_sc(MER_QUICKEN          , SC_MERC_QUICKEN    , SI_BLANK           , SCB_ASPD);
    add_sc(ML_DEVOTION          , SC_DEVOTION);
    set_sc(MER_KYRIE            , SC_KYRIE           , SI_KYRIE           , SCB_NONE);
    set_sc(MER_BLESSING         , SC_BLESSING        , SI_BLESSING        , SCB_STR|SCB_INT|SCB_DEX);
    set_sc(MER_INCAGI           , SC_INCREASEAGI     , SI_INCREASEAGI     , SCB_AGI|SCB_SPEED);

    set_sc(GD_LEADERSHIP        , SC_LEADERSHIP      , SI_BLANK           , SCB_STR);
    set_sc(GD_GLORYWOUNDS       , SC_GLORYWOUNDS     , SI_BLANK           , SCB_VIT);
    set_sc(GD_SOULCOLD          , SC_SOULCOLD        , SI_BLANK           , SCB_AGI);
    set_sc(GD_HAWKEYES          , SC_HAWKEYES        , SI_BLANK           , SCB_DEX);

    set_sc(GD_BATTLEORDER       , SC_BATTLEORDERS    , SI_BLANK           , SCB_STR|SCB_INT|SCB_DEX);
    set_sc(GD_REGENERATION      , SC_REGENERATION    , SI_BLANK           , SCB_REGEN);

    /**
     * Rune Knight
     **/
    set_sc(RK_ENCHANTBLADE      , SC_ENCHANTBLADE      , SI_ENCHANTBLADE      , SCB_NONE);
    set_sc(RK_DRAGONHOWLING     , SC_FEAR              , SI_BLANK             , SCB_FLEE|SCB_HIT);
    set_sc(RK_DEATHBOUND        , SC_DEATHBOUND        , SI_DEATHBOUND        , SCB_NONE);
    set_sc(RK_WINDCUTTER        , SC_FEAR              , SI_BLANK             , SCB_FLEE|SCB_HIT);
    add_sc(RK_DRAGONBREATH      , SC_BURNING);
    set_sc(RK_MILLENNIUMSHIELD  , SC_MILLENNIUMSHIELD  , SI_REUSE_MILLENNIUMSHIELD  , SCB_NONE);
    set_sc(RK_REFRESH           , SC_REFRESH           , SI_REFRESH           , SCB_NONE);
    set_sc(RK_GIANTGROWTH       , SC_GIANTGROWTH       , SI_GIANTGROWTH       , SCB_STR);
    set_sc(RK_STONEHARDSKIN     , SC_STONEHARDSKIN     , SI_STONEHARDSKIN     , SCB_NONE);
    set_sc(RK_VITALITYACTIVATION, SC_VITALITYACTIVATION, SI_VITALITYACTIVATION, SCB_REGEN);
    set_sc(RK_FIGHTINGSPIRIT    , SC_FIGHTINGSPIRIT    , SI_FIGHTINGSPIRIT    , SCB_WATK|SCB_ASPD);
    set_sc(RK_ABUNDANCE         , SC_ABUNDANCE         , SI_ABUNDANCE         , SCB_NONE);
    /**
     * GC Guillotine Cross
     **/
    set_sc_with_vfx(GC_VENOMIMPRESS      , SC_VENOMIMPRESS     , SI_VENOMIMPRESS     , SCB_NONE);
    set_sc(GC_POISONINGWEAPON   , SC_POISONINGWEAPON  , SI_POISONINGWEAPON  , SCB_NONE);
    set_sc(GC_WEAPONBLOCKING    , SC_WEAPONBLOCKING   , SI_WEAPONBLOCKING   , SCB_NONE);
    set_sc(GC_CLOAKINGEXCEED    , SC_CLOAKINGEXCEED   , SI_CLOAKINGEXCEED   , SCB_SPEED);
    set_sc(GC_HALLUCINATIONWALK , SC_HALLUCINATIONWALK, SI_HALLUCINATIONWALK, SCB_FLEE);
    set_sc(GC_ROLLINGCUTTER     , SC_ROLLINGCUTTER    , SI_ROLLINGCUTTER    , SCB_NONE);
    /**
     * Arch Bishop
     **/
    set_sc(AB_ADORAMUS          , SC_ADORAMUS        , SI_ADORAMUS        , SCB_AGI|SCB_SPEED);
    add_sc(AB_CLEMENTIA         , SC_BLESSING);
    add_sc(AB_CANTO             , SC_INCREASEAGI);
    set_sc(AB_EPICLESIS         , SC_EPICLESIS       , SI_EPICLESIS       , SCB_MAXHP);
    add_sc(AB_PRAEFATIO         , SC_KYRIE);
    set_sc_with_vfx(AB_ORATIO            , SC_ORATIO          , SI_ORATIO          , SCB_NONE);
    set_sc(AB_LAUDAAGNUS        , SC_LAUDAAGNUS      , SI_LAUDAAGNUS      , SCB_VIT);
    set_sc(AB_LAUDARAMUS        , SC_LAUDARAMUS      , SI_LAUDARAMUS      , SCB_LUK);
    set_sc(AB_RENOVATIO         , SC_RENOVATIO       , SI_RENOVATIO       , SCB_REGEN);
    set_sc(AB_EXPIATIO          , SC_EXPIATIO        , SI_EXPIATIO        , SCB_ATK_ELE);
    set_sc(AB_DUPLELIGHT        , SC_DUPLELIGHT      , SI_DUPLELIGHT      , SCB_NONE);
    set_sc(AB_SECRAMENT         , SC_SECRAMENT       , SI_SECRAMENT       , SCB_NONE);
    /**
     * Warlock
     **/
    add_sc(WL_WHITEIMPRISON     , SC_WHITEIMPRISON);
    set_sc_with_vfx(WL_FROSTMISTY        , SC_FREEZING        , SI_FROSTMISTY      , SCB_ASPD|SCB_SPEED|SCB_DEF|SCB_DEF2);
    set_sc(WL_MARSHOFABYSS      , SC_MARSHOFABYSS    , SI_MARSHOFABYSS    , SCB_SPEED|SCB_FLEE|SCB_DEF|SCB_MDEF);
    set_sc(WL_RECOGNIZEDSPELL   , SC_RECOGNIZEDSPELL , SI_RECOGNIZEDSPELL , SCB_MATK);
    set_sc(WL_STASIS            , SC_STASIS          , SI_STASIS          , SCB_NONE);
    /**
     * Ranger
     **/
    set_sc(RA_FEARBREEZE        , SC_FEARBREEZE      , SI_FEARBREEZE      , SCB_NONE);
    set_sc(RA_ELECTRICSHOCKER   , SC_ELECTRICSHOCKER , SI_ELECTRICSHOCKER , SCB_NONE);
    set_sc(RA_WUGDASH           , SC_WUGDASH         , SI_WUGDASH         , SCB_SPEED);
    set_sc(RA_CAMOUFLAGE        , SC_CAMOUFLAGE      , SI_CAMOUFLAGE      , SCB_SPEED);
    add_sc(RA_MAGENTATRAP       , SC_ELEMENTALCHANGE);
    add_sc(RA_COBALTTRAP        , SC_ELEMENTALCHANGE);
    add_sc(RA_MAIZETRAP         , SC_ELEMENTALCHANGE);
    add_sc(RA_VERDURETRAP       , SC_ELEMENTALCHANGE);
    add_sc(RA_FIRINGTRAP        , SC_BURNING);
    set_sc_with_vfx(RA_ICEBOUNDTRAP      , SC_FREEZING        , SI_FROSTMISTY      , SCB_NONE);
    /**
     * Mechanic
     **/
    set_sc(NC_ACCELERATION      , SC_ACCELERATION    , SI_ACCELERATION    , SCB_SPEED);
    set_sc(NC_HOVERING          , SC_HOVERING        , SI_HOVERING        , SCB_SPEED);
    set_sc(NC_SHAPESHIFT        , SC_SHAPESHIFT      , SI_SHAPESHIFT      , SCB_DEF_ELE);
    set_sc(NC_INFRAREDSCAN      , SC_INFRAREDSCAN    , SI_INFRAREDSCAN    , SCB_FLEE);
    set_sc(NC_ANALYZE           , SC_ANALYZE         , SI_ANALYZE         , SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_MDEF2);
    set_sc(NC_MAGNETICFIELD     , SC_MAGNETICFIELD   , SI_MAGNETICFIELD   , SCB_NONE);
    set_sc(NC_NEUTRALBARRIER    , SC_NEUTRALBARRIER  , SI_NEUTRALBARRIER  , SCB_NONE);
    set_sc(NC_STEALTHFIELD      , SC_STEALTHFIELD    , SI_STEALTHFIELD    , SCB_NONE);
    /**
     * Royal Guard
     **/
    set_sc(LG_REFLECTDAMAGE     , SC_REFLECTDAMAGE   , SI_LG_REFLECTDAMAGE, SCB_NONE);
    set_sc(LG_FORCEOFVANGUARD   , SC_FORCEOFVANGUARD , SI_FORCEOFVANGUARD , SCB_MAXHP|SCB_DEF);
    set_sc(LG_EXEEDBREAK        , SC_EXEEDBREAK      , SI_EXEEDBREAK      , SCB_NONE);
    set_sc(LG_PRESTIGE          , SC_PRESTIGE        , SI_PRESTIGE        , SCB_DEF);
    set_sc(LG_BANDING           , SC_BANDING         , SI_BANDING         , SCB_DEF2|SCB_WATK);  // Renewal: atk2 & def2
    set_sc(LG_PIETY             , SC_BENEDICTIO      , SI_BENEDICTIO      , SCB_DEF_ELE);
    set_sc(LG_EARTHDRIVE        , SC_EARTHDRIVE      , SI_EARTHDRIVE      , SCB_DEF|SCB_ASPD);
    set_sc(LG_INSPIRATION       , SC_INSPIRATION     , SI_INSPIRATION     , SCB_MAXHP|SCB_WATK|SCB_HIT|SCB_VIT|SCB_AGI|SCB_STR|SCB_DEX|SCB_INT|SCB_LUK);
    set_sc(LG_SHIELDSPELL       , SC_SHIELDSPELL_DEF , SI_SHIELDSPELL_DEF , SCB_WATK);
    set_sc(LG_SHIELDSPELL       , SC_SHIELDSPELL_REF , SI_SHIELDSPELL_REF , SCB_DEF);
    /**
     * Shadow Chaser
     **/
    set_sc(SC_REPRODUCE         , SC__REPRODUCE      , SI_REPRODUCE       , SCB_NONE);
    set_sc(SC_AUTOSHADOWSPELL   , SC__AUTOSHADOWSPELL, SI_AUTOSHADOWSPELL , SCB_NONE);
    set_sc(SC_SHADOWFORM        , SC__SHADOWFORM     , SI_SHADOWFORM      , SCB_NONE);
    set_sc(SC_BODYPAINT         , SC__BODYPAINT      , SI_BODYPAINT       , SCB_ASPD);
    set_sc(SC_INVISIBILITY      , SC__INVISIBILITY   , SI_INVISIBILITY    , SCB_ASPD|SCB_CRI|SCB_ATK_ELE);
    set_sc(SC_DEADLYINFECT      , SC__DEADLYINFECT   , SI_DEADLYINFECT    , SCB_NONE);
    set_sc(SC_ENERVATION        , SC__ENERVATION     , SI_ENERVATION      , SCB_BATK);
    set_sc(SC_GROOMY            , SC__GROOMY         , SI_GROOMY          , SCB_ASPD|SCB_HIT|SCB_SPEED);
    set_sc(SC_IGNORANCE         , SC__IGNORANCE      , SI_IGNORANCE       , SCB_NONE);
    set_sc(SC_LAZINESS          , SC__LAZINESS       , SI_LAZINESS        , SCB_FLEE);
    set_sc(SC_UNLUCKY           , SC__UNLUCKY        , SI_UNLUCKY         , SCB_CRI|SCB_FLEE2);
    set_sc(SC_WEAKNESS          , SC__WEAKNESS       , SI_WEAKNESS        , SCB_FLEE2|SCB_MAXHP);
    set_sc(SC_STRIPACCESSARY    , SC__STRIPACCESSORY , SI_STRIPACCESSARY  , SCB_DEX|SCB_INT|SCB_LUK);
    set_sc_with_vfx(SC_MANHOLE           , SC__MANHOLE        , SI_MANHOLE         , SCB_NONE);
    add_sc(SC_CHAOSPANIC        , SC_CONFUSION);
    set_sc_with_vfx(SC_BLOODYLUST        , SC__BLOODYLUST     , SI_BLOODYLUST      , SCB_DEF | SCB_DEF2 | SCB_MDEF | SCB_MDEF2 | SCB_FLEE | SCB_SPEED | SCB_ASPD | SCB_MAXHP | SCB_REGEN);
    /**
     * Sura
     **/
    add_sc(SR_DRAGONCOMBO           , SC_STUN);
    add_sc(SR_EARTHSHAKER           , SC_STUN);
    set_sc(SR_CRESCENTELBOW         , SC_CRESCENTELBOW      , SI_CRESCENTELBOW         , SCB_NONE);
    set_sc_with_vfx(SR_CURSEDCIRCLE          , SC_CURSEDCIRCLE_TARGET, SI_CURSEDCIRCLE_TARGET   , SCB_NONE);
    set_sc(SR_LIGHTNINGWALK         , SC_LIGHTNINGWALK      , SI_LIGHTNINGWALK         , SCB_NONE);
    set_sc(SR_RAISINGDRAGON         , SC_RAISINGDRAGON      , SI_RAISINGDRAGON         , SCB_REGEN|SCB_MAXHP|SCB_MAXSP);
    set_sc(SR_GENTLETOUCH_ENERGYGAIN, SC_GT_ENERGYGAIN      , SI_GENTLETOUCH_ENERGYGAIN, SCB_NONE);
    set_sc(SR_GENTLETOUCH_CHANGE    , SC_GT_CHANGE          , SI_GENTLETOUCH_CHANGE    , SCB_ASPD|SCB_MDEF|SCB_MAXHP);
    set_sc(SR_GENTLETOUCH_REVITALIZE, SC_GT_REVITALIZE      , SI_GENTLETOUCH_REVITALIZE, SCB_MAXHP|SCB_REGEN);
    /**
     * Wanderer / Minstrel
     **/
    set_sc(WA_SWING_DANCE            , SC_SWINGDANCE           , SI_SWINGDANCE           , SCB_SPEED|SCB_ASPD);
    set_sc(WA_SYMPHONY_OF_LOVER      , SC_SYMPHONYOFLOVER      , SI_SYMPHONYOFLOVERS     , SCB_MDEF);
    set_sc(WA_MOONLIT_SERENADE       , SC_MOONLITSERENADE      , SI_MOONLITSERENADE      , SCB_MATK);
    set_sc(MI_RUSH_WINDMILL          , SC_RUSHWINDMILL         , SI_RUSHWINDMILL         , SCB_BATK);
    set_sc(MI_ECHOSONG               , SC_ECHOSONG             , SI_ECHOSONG             , SCB_DEF2);
    set_sc(MI_HARMONIZE              , SC_HARMONIZE            , SI_HARMONIZE            , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK);
    set_sc_with_vfx(WM_POEMOFNETHERWORLD      , SC_NETHERWORLD          , SI_NETHERWORLD          , SCB_NONE);
    set_sc_with_vfx(WM_VOICEOFSIREN           , SC_VOICEOFSIREN         , SI_VOICEOFSIREN         , SCB_NONE);
    set_sc_with_vfx(WM_LULLABY_DEEPSLEEP      , SC_DEEPSLEEP            , SI_DEEPSLEEP            , SCB_NONE);
    set_sc(WM_SIRCLEOFNATURE         , SC_SIRCLEOFNATURE       , SI_SIRCLEOFNATURE       , SCB_NONE);
    set_sc(WM_GLOOMYDAY              , SC_GLOOMYDAY            , SI_GLOOMYDAY            , SCB_FLEE|SCB_ASPD);
    set_sc(WM_SONG_OF_MANA           , SC_SONGOFMANA           , SI_SONGOFMANA           , SCB_NONE);
    set_sc(WM_DANCE_WITH_WUG         , SC_DANCEWITHWUG         , SI_DANCEWITHWUG         , SCB_ASPD);
    set_sc(WM_SATURDAY_NIGHT_FEVER   , SC_SATURDAYNIGHTFEVER   , SI_SATURDAYNIGHTFEVER   , SCB_BATK|SCB_DEF|SCB_FLEE|SCB_REGEN);
    set_sc(WM_LERADS_DEW             , SC_LERADSDEW            , SI_LERADSDEW            , SCB_MAXHP);
    set_sc(WM_MELODYOFSINK           , SC_MELODYOFSINK         , SI_MELODYOFSINK         , SCB_BATK|SCB_MATK);
    set_sc(WM_BEYOND_OF_WARCRY       , SC_BEYONDOFWARCRY       , SI_WARCRYOFBEYOND       , SCB_BATK|SCB_MATK);
    set_sc(WM_UNLIMITED_HUMMING_VOICE, SC_UNLIMITEDHUMMINGVOICE, SI_UNLIMITEDHUMMINGVOICE, SCB_NONE);
    /**
     * Sorcerer
     **/
    set_sc(SO_FIREWALK          , SC_PROPERTYWALK    , SI_PROPERTYWALK    , SCB_NONE);
    set_sc(SO_ELECTRICWALK      , SC_PROPERTYWALK    , SI_PROPERTYWALK    , SCB_NONE);
    set_sc(SO_SPELLFIST         , SC_SPELLFIST       , SI_SPELLFIST       , SCB_NONE);
    set_sc_with_vfx(SO_DIAMONDDUST       , SC_CRYSTALIZE      , SI_COLD   , SCB_NONE);   // it does show the snow icon on mobs but doesn't affect it.
    add_sc(SO_CLOUD_KILL         , SC_POISON);
    set_sc(SO_STRIKING          , SC_STRIKING        , SI_STRIKING        , SCB_WATK|SCB_CRI);
    set_sc(SO_WARMER            , SC_WARMER          , SI_WARMER          , SCB_NONE);
    set_sc(SO_VACUUM_EXTREME    , SC_VACUUM_EXTREME  , SI_VACUUM_EXTREME  , SCB_NONE);
    set_sc(SO_ARRULLO           , SC_DEEPSLEEP       , SI_DEEPSLEEP       , SCB_NONE);
    set_sc(SO_FIRE_INSIGNIA     , SC_FIRE_INSIGNIA   , SI_FIRE_INSIGNIA   , SCB_MATK | SCB_BATK | SCB_WATK | SCB_ATK_ELE | SCB_REGEN);
    set_sc(SO_WATER_INSIGNIA    , SC_WATER_INSIGNIA  , SI_WATER_INSIGNIA  , SCB_WATK | SCB_ATK_ELE | SCB_REGEN);
    set_sc(SO_WIND_INSIGNIA     , SC_WIND_INSIGNIA   , SI_WIND_INSIGNIA   , SCB_WATK | SCB_ATK_ELE | SCB_REGEN);
    set_sc(SO_EARTH_INSIGNIA    , SC_EARTH_INSIGNIA  , SI_EARTH_INSIGNIA  , SCB_MDEF|SCB_DEF|SCB_MAXHP|SCB_MAXSP|SCB_WATK | SCB_ATK_ELE | SCB_REGEN);
    /**
     * Genetic
     **/
    set_sc(GN_CARTBOOST                  , SC_GN_CARTBOOST, SI_CARTSBOOST                 , SCB_SPEED);
    set_sc(GN_THORNS_TRAP                , SC_THORNSTRAP  , SI_THORNTRAP                  , SCB_NONE);
    set_sc_with_vfx(GN_BLOOD_SUCKER      , SC_BLOODSUCKER , SI_BLOODSUCKER                , SCB_NONE);
    set_sc(GN_WALLOFTHORN                , SC_STOP        , SI_BLANK                      , SCB_NONE);
    set_sc(GN_FIRE_EXPANSION_SMOKE_POWDER, SC_SMOKEPOWDER , SI_FIRE_EXPANSION_SMOKE_POWDER, SCB_NONE);
    set_sc(GN_FIRE_EXPANSION_TEAR_GAS    , SC_TEARGAS     , SI_FIRE_EXPANSION_TEAR_GAS    , SCB_NONE);
    set_sc(GN_MANDRAGORA                 , SC_MANDRAGORA  , SI_MANDRAGORA                 , SCB_INT);

    // Elemental Spirit summoner's 'side' status changes.
    set_sc(EL_CIRCLE_OF_FIRE  , SC_CIRCLE_OF_FIRE_OPTION, SI_CIRCLE_OF_FIRE_OPTION, SCB_NONE);
    set_sc(EL_FIRE_CLOAK      , SC_FIRE_CLOAK_OPTION    , SI_FIRE_CLOAK_OPTION    , SCB_ALL);
    set_sc(EL_WATER_SCREEN    , SC_WATER_SCREEN_OPTION  , SI_WATER_SCREEN_OPTION  , SCB_NONE);
    set_sc(EL_WATER_DROP      , SC_WATER_DROP_OPTION    , SI_WATER_DROP_OPTION    , SCB_ALL);
    set_sc(EL_WATER_BARRIER   , SC_WATER_BARRIER        , SI_WATER_BARRIER        , SCB_MDEF|SCB_WATK|SCB_MATK|SCB_FLEE);
    set_sc(EL_WIND_STEP       , SC_WIND_STEP_OPTION     , SI_WIND_STEP_OPTION     , SCB_SPEED|SCB_FLEE);
    set_sc(EL_WIND_CURTAIN    , SC_WIND_CURTAIN_OPTION  , SI_WIND_CURTAIN_OPTION  , SCB_ALL);
    set_sc(EL_ZEPHYR          , SC_ZEPHYR               , SI_ZEPHYR               , SCB_FLEE);
    set_sc(EL_SOLID_SKIN      , SC_SOLID_SKIN_OPTION    , SI_SOLID_SKIN_OPTION    , SCB_DEF|SCB_MAXHP);
    set_sc(EL_STONE_SHIELD    , SC_STONE_SHIELD_OPTION  , SI_STONE_SHIELD_OPTION  , SCB_ALL);
    set_sc(EL_POWER_OF_GAIA   , SC_POWER_OF_GAIA        , SI_POWER_OF_GAIA        , SCB_MAXHP|SCB_DEF|SCB_SPEED);
    set_sc(EL_PYROTECHNIC     , SC_PYROTECHNIC_OPTION   , SI_PYROTECHNIC_OPTION   , SCB_WATK);
    set_sc(EL_HEATER          , SC_HEATER_OPTION        , SI_HEATER_OPTION        , SCB_WATK);
    set_sc(EL_TROPIC          , SC_TROPIC_OPTION        , SI_TROPIC_OPTION        , SCB_WATK);
    set_sc(EL_AQUAPLAY        , SC_AQUAPLAY_OPTION      , SI_AQUAPLAY_OPTION      , SCB_MATK);
    set_sc(EL_COOLER          , SC_COOLER_OPTION        , SI_COOLER_OPTION        , SCB_MATK);
    set_sc(EL_CHILLY_AIR      , SC_CHILLY_AIR_OPTION    , SI_CHILLY_AIR_OPTION    , SCB_MATK);
    set_sc(EL_GUST            , SC_GUST_OPTION          , SI_GUST_OPTION          , SCB_NONE);
    set_sc(EL_BLAST           , SC_BLAST_OPTION         , SI_BLAST_OPTION         , SCB_NONE);
    set_sc(EL_WILD_STORM      , SC_WILD_STORM_OPTION    , SI_WILD_STORM_OPTION    , SCB_NONE);
    set_sc(EL_PETROLOGY       , SC_PETROLOGY_OPTION     , SI_PETROLOGY_OPTION     , SCB_NONE);
    set_sc(EL_CURSED_SOIL     , SC_CURSED_SOIL_OPTION   , SI_CURSED_SOIL_OPTION   , SCB_NONE);
    set_sc(EL_UPHEAVAL        , SC_UPHEAVAL_OPTION      , SI_UPHEAVAL_OPTION      , SCB_NONE);
    set_sc(EL_TIDAL_WEAPON    , SC_TIDAL_WEAPON_OPTION  , SI_TIDAL_WEAPON_OPTION  , SCB_ALL);
    set_sc(EL_ROCK_CRUSHER    , SC_ROCK_CRUSHER         , SI_ROCK_CRUSHER         , SCB_DEF);
    set_sc(EL_ROCK_CRUSHER_ATK, SC_ROCK_CRUSHER_ATK     , SI_ROCK_CRUSHER_ATK     , SCB_SPEED);

    add_sc(KO_YAMIKUMO          , SC_HIDING);
    set_sc_with_vfx(KO_JYUMONJIKIRI     , SC_JYUMONJIKIRI        , SI_KO_JYUMONJIKIRI      , SCB_NONE);
    add_sc(KO_MAKIBISHI     , SC_STUN);
    set_sc(KO_MEIKYOUSISUI      , SC_MEIKYOUSISUI        , SI_MEIKYOUSISUI         , SCB_NONE);
    set_sc(KO_KYOUGAKU          , SC_KYOUGAKU            , SI_KYOUGAKU             , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK);
    add_sc(KO_JYUSATSU          , SC_CURSE);
    set_sc(KO_ZENKAI            , SC_ZENKAI              , SI_ZENKAI               , SCB_NONE);
    set_sc(KO_IZAYOI            , SC_IZAYOI              , SI_IZAYOI               , SCB_MATK);
    set_sc(KG_KYOMU         , SC_KYOMU               , SI_KYOMU                , SCB_NONE);
    set_sc(KG_KAGEMUSYA     , SC_KAGEMUSYA           , SI_KAGEMUSYA            , SCB_NONE);
    set_sc(KG_KAGEHUMI          , SC_KAGEHUMI            , SI_KG_KAGEHUMI          , SCB_NONE);
    set_sc(OB_ZANGETSU          , SC_ZANGETSU            , SI_ZANGETSU             , SCB_MATK|SCB_BATK);
    set_sc_with_vfx(OB_AKAITSUKI        , SC_AKAITSUKI           , SI_AKAITSUKI            , SCB_NONE);
    set_sc(OB_OBOROGENSOU       , SC_GENSOU              , SI_GENSOU               , SCB_NONE);

    // Storing the target job rather than simply SC_SPIRIT simplifies code later on.
    SkillStatusChangeTable[SL_ALCHEMIST]   = (sc_type)MAPID_ALCHEMIST,
                                             SkillStatusChangeTable[SL_MONK]        = (sc_type)MAPID_MONK,
                                                     SkillStatusChangeTable[SL_STAR]        = (sc_type)MAPID_STAR_GLADIATOR,
                                                             SkillStatusChangeTable[SL_SAGE]        = (sc_type)MAPID_SAGE,
                                                                     SkillStatusChangeTable[SL_CRUSADER]    = (sc_type)MAPID_CRUSADER,
                                                                             SkillStatusChangeTable[SL_SUPERNOVICE] = (sc_type)MAPID_SUPER_NOVICE,
                                                                                     SkillStatusChangeTable[SL_KNIGHT]      = (sc_type)MAPID_KNIGHT,
                                                                                             SkillStatusChangeTable[SL_WIZARD]      = (sc_type)MAPID_WIZARD,
                                                                                                     SkillStatusChangeTable[SL_PRIEST]      = (sc_type)MAPID_PRIEST,
                                                                                                             SkillStatusChangeTable[SL_BARDDANCER]  = (sc_type)MAPID_BARDDANCER,
                                                                                                                     SkillStatusChangeTable[SL_ROGUE]       = (sc_type)MAPID_ROGUE,
                                                                                                                             SkillStatusChangeTable[SL_ASSASIN]     = (sc_type)MAPID_ASSASSIN,
                                                                                                                                     SkillStatusChangeTable[SL_BLACKSMITH]  = (sc_type)MAPID_BLACKSMITH,
                                                                                                                                             SkillStatusChangeTable[SL_HUNTER]      = (sc_type)MAPID_HUNTER,
                                                                                                                                                     SkillStatusChangeTable[SL_SOULLINKER]  = (sc_type)MAPID_SOUL_LINKER,

                                                                                                                                                             //Status that don't have a skill associated.
                                                                                                                                                             StatusIconChangeTable[SC_WEIGHT50] = SI_WEIGHT50;
    StatusIconChangeTable[SC_WEIGHT90] = SI_WEIGHT90;
    StatusIconChangeTable[SC_ASPDPOTION0] = SI_ASPDPOTION0;
    StatusIconChangeTable[SC_ASPDPOTION1] = SI_ASPDPOTION1;
    StatusIconChangeTable[SC_ASPDPOTION2] = SI_ASPDPOTION2;
    StatusIconChangeTable[SC_ASPDPOTION3] = SI_ASPDPOTIONINFINITY;
    StatusIconChangeTable[SC_SPEEDUP0] = SI_MOVHASTE_HORSE;
    StatusIconChangeTable[SC_SPEEDUP1] = SI_SPEEDPOTION1;
    StatusIconChangeTable[SC_INCSTR] = SI_INCSTR;
    StatusIconChangeTable[SC_MIRACLE] = SI_SPIRIT;
    StatusIconChangeTable[SC_INTRAVISION] = SI_INTRAVISION;
    StatusIconChangeTable[SC_STRFOOD] = SI_FOODSTR;
    StatusIconChangeTable[SC_AGIFOOD] = SI_FOODAGI;
    StatusIconChangeTable[SC_VITFOOD] = SI_FOODVIT;
    StatusIconChangeTable[SC_INTFOOD] = SI_FOODINT;
    StatusIconChangeTable[SC_DEXFOOD] = SI_FOODDEX;
    StatusIconChangeTable[SC_LUKFOOD] = SI_FOODLUK;
    StatusIconChangeTable[SC_FLEEFOOD]= SI_FOODFLEE;
    StatusIconChangeTable[SC_HITFOOD] = SI_FOODHIT;
    StatusIconChangeTable[SC_MANU_ATK] = SI_MANU_ATK;
    StatusIconChangeTable[SC_MANU_DEF] = SI_MANU_DEF;
    StatusIconChangeTable[SC_SPL_ATK] = SI_SPL_ATK;
    StatusIconChangeTable[SC_SPL_DEF] = SI_SPL_DEF;
    StatusIconChangeTable[SC_MANU_MATK] = SI_MANU_MATK;
    StatusIconChangeTable[SC_SPL_MATK] = SI_SPL_MATK;
    //Cash Items
    StatusIconChangeTable[SC_FOOD_STR_CASH] = SI_FOOD_STR_CASH;
    StatusIconChangeTable[SC_FOOD_AGI_CASH] = SI_FOOD_AGI_CASH;
    StatusIconChangeTable[SC_FOOD_VIT_CASH] = SI_FOOD_VIT_CASH;
    StatusIconChangeTable[SC_FOOD_DEX_CASH] = SI_FOOD_DEX_CASH;
    StatusIconChangeTable[SC_FOOD_INT_CASH] = SI_FOOD_INT_CASH;
    StatusIconChangeTable[SC_FOOD_LUK_CASH] = SI_FOOD_LUK_CASH;
    StatusIconChangeTable[SC_EXPBOOST] = SI_EXPBOOST;
    StatusIconChangeTable[SC_ITEMBOOST] = SI_ITEMBOOST;
    StatusIconChangeTable[SC_JEXPBOOST] = SI_CASH_PLUSONLYJOBEXP;
    StatusIconChangeTable[SC_LIFEINSURANCE] = SI_LIFEINSURANCE;
    StatusIconChangeTable[SC_BOSSMAPINFO] = SI_BOSSMAPINFO;
    StatusIconChangeTable[SC_DEF_RATE] = SI_DEF_RATE;
    StatusIconChangeTable[SC_MDEF_RATE] = SI_MDEF_RATE;
    StatusIconChangeTable[SC_INCCRI] = SI_INCCRI;
    StatusIconChangeTable[SC_INCFLEE2] = SI_PLUSAVOIDVALUE;
    StatusIconChangeTable[SC_INCHEALRATE] = SI_INCHEALRATE;
    StatusIconChangeTable[SC_S_LIFEPOTION] = SI_S_LIFEPOTION;
    StatusIconChangeTable[SC_L_LIFEPOTION] = SI_L_LIFEPOTION;
    StatusIconChangeTable[SC_SPCOST_RATE] = SI_ATKER_BLOOD;
    StatusIconChangeTable[SC_COMMONSC_RESIST] = SI_TARGET_BLOOD;
    // Mercenary Bonus Effects
    StatusIconChangeTable[SC_MERC_FLEEUP] = SI_MERC_FLEEUP;
    StatusIconChangeTable[SC_MERC_ATKUP] = SI_MERC_ATKUP;
    StatusIconChangeTable[SC_MERC_HPUP] = SI_MERC_HPUP;
    StatusIconChangeTable[SC_MERC_SPUP] = SI_MERC_SPUP;
    StatusIconChangeTable[SC_MERC_HITUP] = SI_MERC_HITUP;
    // Warlock Spheres
    StatusIconChangeTable[SC_SPHERE_1] = SI_SPHERE_1;
    StatusIconChangeTable[SC_SPHERE_2] = SI_SPHERE_2;
    StatusIconChangeTable[SC_SPHERE_3] = SI_SPHERE_3;
    StatusIconChangeTable[SC_SPHERE_4] = SI_SPHERE_4;
    StatusIconChangeTable[SC_SPHERE_5] = SI_SPHERE_5;
    // Warlock Preserved spells
    StatusIconChangeTable[SC_SPELLBOOK1] = SI_SPELLBOOK1;
    StatusIconChangeTable[SC_SPELLBOOK2] = SI_SPELLBOOK2;
    StatusIconChangeTable[SC_SPELLBOOK3] = SI_SPELLBOOK3;
    StatusIconChangeTable[SC_SPELLBOOK4] = SI_SPELLBOOK4;
    StatusIconChangeTable[SC_SPELLBOOK5] = SI_SPELLBOOK5;
    StatusIconChangeTable[SC_SPELLBOOK6] = SI_SPELLBOOK6;
    StatusIconChangeTable[SC_MAXSPELLBOOK] = SI_SPELLBOOK7;

    StatusIconChangeTable[SC_NEUTRALBARRIER_MASTER] = SI_NEUTRALBARRIER_MASTER;
    StatusIconChangeTable[SC_STEALTHFIELD_MASTER] = SI_STEALTHFIELD_MASTER;
    StatusIconChangeTable[SC_OVERHEAT] = SI_OVERHEAT;
    StatusIconChangeTable[SC_OVERHEAT_LIMITPOINT] = SI_OVERHEAT_LIMITPOINT;

    StatusIconChangeTable[SC_HALLUCINATIONWALK_POSTDELAY] = SI_HALLUCINATIONWALK_POSTDELAY;
    StatusIconChangeTable[SC_TOXIN] = SI_TOXIN;
    StatusIconChangeTable[SC_PARALYSE] = SI_PARALYSE;
    StatusIconChangeTable[SC_VENOMBLEED] = SI_VENOMBLEED;
    StatusIconChangeTable[SC_MAGICMUSHROOM] = SI_MAGICMUSHROOM;
    StatusIconChangeTable[SC_DEATHHURT] = SI_DEATHHURT;
    StatusIconChangeTable[SC_PYREXIA] = SI_PYREXIA;
    StatusIconChangeTable[SC_OBLIVIONCURSE] = SI_OBLIVIONCURSE;
    StatusIconChangeTable[SC_LEECHESEND] = SI_LEECHESEND;

    StatusIconChangeTable[SC_SHIELDSPELL_DEF] = SI_SHIELDSPELL_DEF;
    StatusIconChangeTable[SC_SHIELDSPELL_MDEF] = SI_SHIELDSPELL_MDEF;
    StatusIconChangeTable[SC_SHIELDSPELL_REF] = SI_SHIELDSPELL_REF;
    StatusIconChangeTable[SC_BANDING_DEFENCE] = SI_BANDING_DEFENCE;

    StatusIconChangeTable[SC_GLOOMYDAY_SK] = SI_GLOOMYDAY;

    StatusIconChangeTable[SC_CURSEDCIRCLE_ATKER] = SI_CURSEDCIRCLE_ATKER;

    StatusIconChangeTable[SC_STOMACHACHE] = SI_STOMACHACHE;
    StatusIconChangeTable[SC_MYSTERIOUS_POWDER] = SI_MYSTERIOUS_POWDER;
    StatusIconChangeTable[SC_MELON_BOMB] = SI_MELON_BOMB;
    StatusIconChangeTable[SC_BANANA_BOMB] = SI_BANANA_BOMB;
    StatusIconChangeTable[SC_BANANA_BOMB_SITDOWN] = SI_BANANA_BOMB_SITDOWN_POSTDELAY;

    //Genetics New Food Items Status Icons
    StatusIconChangeTable[SC_SAVAGE_STEAK] = SI_SAVAGE_STEAK;
    StatusIconChangeTable[SC_COCKTAIL_WARG_BLOOD] = SI_COCKTAIL_WARG_BLOOD;
    StatusIconChangeTable[SC_MINOR_BBQ] = SI_MINOR_BBQ;
    StatusIconChangeTable[SC_SIROMA_ICE_TEA] = SI_SIROMA_ICE_TEA;
    StatusIconChangeTable[SC_DROCERA_HERB_STEAMED] = SI_DROCERA_HERB_STEAMED;
    StatusIconChangeTable[SC_PUTTI_TAILS_NOODLES] = SI_PUTTI_TAILS_NOODLES;

    StatusIconChangeTable[SC_BOOST500] |= SI_BOOST500;
    StatusIconChangeTable[SC_FULL_SWING_K] |= SI_FULL_SWING_K;
    StatusIconChangeTable[SC_MANA_PLUS] |= SI_MANA_PLUS;
    StatusIconChangeTable[SC_MUSTLE_M] |= SI_MUSTLE_M;
    StatusIconChangeTable[SC_LIFE_FORCE_F] |= SI_LIFE_FORCE_F;
    StatusIconChangeTable[SC_EXTRACT_WHITE_POTION_Z] |= SI_EXTRACT_WHITE_POTION_Z;
    StatusIconChangeTable[SC_VITATA_500] |= SI_VITATA_500;
    StatusIconChangeTable[SC_EXTRACT_SALAMINE_JUICE] |= SI_EXTRACT_SALAMINE_JUICE;

    // Elemental Spirit's 'side' status change icons.
    StatusIconChangeTable[SC_CIRCLE_OF_FIRE] = SI_CIRCLE_OF_FIRE;
    StatusIconChangeTable[SC_FIRE_CLOAK] = SI_FIRE_CLOAK;
    StatusIconChangeTable[SC_WATER_SCREEN] = SI_WATER_SCREEN;
    StatusIconChangeTable[SC_WATER_DROP] = SI_WATER_DROP;
    StatusIconChangeTable[SC_WIND_STEP] = SI_WIND_STEP;
    StatusIconChangeTable[SC_WIND_CURTAIN] = SI_WIND_CURTAIN;
    StatusIconChangeTable[SC_SOLID_SKIN] = SI_SOLID_SKIN;
    StatusIconChangeTable[SC_STONE_SHIELD] = SI_STONE_SHIELD;
    StatusIconChangeTable[SC_PYROTECHNIC] = SI_PYROTECHNIC;
    StatusIconChangeTable[SC_HEATER] = SI_HEATER;
    StatusIconChangeTable[SC_TROPIC] = SI_TROPIC;
    StatusIconChangeTable[SC_AQUAPLAY] = SI_AQUAPLAY;
    StatusIconChangeTable[SC_COOLER] = SI_COOLER;
    StatusIconChangeTable[SC_CHILLY_AIR] = SI_CHILLY_AIR;
    StatusIconChangeTable[SC_GUST] = SI_GUST;
    StatusIconChangeTable[SC_BLAST] = SI_BLAST;
    StatusIconChangeTable[SC_WILD_STORM] = SI_WILD_STORM;
    StatusIconChangeTable[SC_PETROLOGY] = SI_PETROLOGY;
    StatusIconChangeTable[SC_CURSED_SOIL] = SI_CURSED_SOIL;
    StatusIconChangeTable[SC_UPHEAVAL] = SI_UPHEAVAL;
    StatusIconChangeTable[SC_PUSH_CART] = SI_ON_PUSH_CART;

    //Other SC which are not necessarily associated to skills.
    StatusChangeFlagTable[SC_ASPDPOTION0] = SCB_ASPD;
    StatusChangeFlagTable[SC_ASPDPOTION1] = SCB_ASPD;
    StatusChangeFlagTable[SC_ASPDPOTION2] = SCB_ASPD;
    StatusChangeFlagTable[SC_ASPDPOTION3] = SCB_ASPD;
    StatusChangeFlagTable[SC_SPEEDUP0] = SCB_SPEED;
    StatusChangeFlagTable[SC_SPEEDUP1] = SCB_SPEED;
    StatusChangeFlagTable[SC_ATKPOTION] = SCB_BATK;
    StatusChangeFlagTable[SC_MATKPOTION] = SCB_MATK;
    StatusChangeFlagTable[SC_INCALLSTATUS] |= SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK;
    StatusChangeFlagTable[SC_INCSTR] |= SCB_STR;
    StatusChangeFlagTable[SC_INCAGI] |= SCB_AGI;
    StatusChangeFlagTable[SC_INCVIT] |= SCB_VIT;
    StatusChangeFlagTable[SC_INCINT] |= SCB_INT;
    StatusChangeFlagTable[SC_INCDEX] |= SCB_DEX;
    StatusChangeFlagTable[SC_INCLUK] |= SCB_LUK;
    StatusChangeFlagTable[SC_INCHIT] |= SCB_HIT;
    StatusChangeFlagTable[SC_INCHITRATE] |= SCB_HIT;
    StatusChangeFlagTable[SC_INCFLEE] |= SCB_FLEE;
    StatusChangeFlagTable[SC_INCFLEERATE] |= SCB_FLEE;
    StatusChangeFlagTable[SC_INCCRI] |= SCB_CRI;
    StatusChangeFlagTable[SC_INCASPDRATE] |= SCB_ASPD;
    StatusChangeFlagTable[SC_INCFLEE2] |= SCB_FLEE2;
    StatusChangeFlagTable[SC_INCMHPRATE] |= SCB_MAXHP;
    StatusChangeFlagTable[SC_INCMSPRATE] |= SCB_MAXSP;
    StatusChangeFlagTable[SC_INCMHP] |= SCB_MAXHP;
    StatusChangeFlagTable[SC_INCMSP] |= SCB_MAXSP;
    StatusChangeFlagTable[SC_INCATKRATE] |= SCB_BATK|SCB_WATK;
    StatusChangeFlagTable[SC_INCMATKRATE] |= SCB_MATK;
    StatusChangeFlagTable[SC_INCDEFRATE] |= SCB_DEF;
    StatusChangeFlagTable[SC_STRFOOD] |= SCB_STR;
    StatusChangeFlagTable[SC_AGIFOOD] |= SCB_AGI;
    StatusChangeFlagTable[SC_VITFOOD] |= SCB_VIT;
    StatusChangeFlagTable[SC_INTFOOD] |= SCB_INT;
    StatusChangeFlagTable[SC_DEXFOOD] |= SCB_DEX;
    StatusChangeFlagTable[SC_LUKFOOD] |= SCB_LUK;
    StatusChangeFlagTable[SC_HITFOOD] |= SCB_HIT;
    StatusChangeFlagTable[SC_FLEEFOOD] |= SCB_FLEE;
    StatusChangeFlagTable[SC_BATKFOOD] |= SCB_BATK;
    StatusChangeFlagTable[SC_WATKFOOD] |= SCB_WATK;
    StatusChangeFlagTable[SC_MATKFOOD] |= SCB_MATK;
    StatusChangeFlagTable[SC_ARMOR_ELEMENT] |= SCB_ALL;
    StatusChangeFlagTable[SC_ARMOR_RESIST] |= SCB_ALL;
    StatusChangeFlagTable[SC_SPCOST_RATE] |= SCB_ALL;
    StatusChangeFlagTable[SC_WALKSPEED] |= SCB_SPEED;
    StatusChangeFlagTable[SC_ITEMSCRIPT] |= SCB_ALL;
    // Cash Items
    StatusChangeFlagTable[SC_FOOD_STR_CASH] = SCB_STR;
    StatusChangeFlagTable[SC_FOOD_AGI_CASH] = SCB_AGI;
    StatusChangeFlagTable[SC_FOOD_VIT_CASH] = SCB_VIT;
    StatusChangeFlagTable[SC_FOOD_DEX_CASH] = SCB_DEX;
    StatusChangeFlagTable[SC_FOOD_INT_CASH] = SCB_INT;
    StatusChangeFlagTable[SC_FOOD_LUK_CASH] = SCB_LUK;
    // Mercenary Bonus Effects
    StatusChangeFlagTable[SC_MERC_FLEEUP] |= SCB_FLEE;
    StatusChangeFlagTable[SC_MERC_ATKUP] |= SCB_WATK;
    StatusChangeFlagTable[SC_MERC_HPUP] |= SCB_MAXHP;
    StatusChangeFlagTable[SC_MERC_SPUP] |= SCB_MAXSP;
    StatusChangeFlagTable[SC_MERC_HITUP] |= SCB_HIT;
    // Guillotine Cross Poison Effects
    StatusChangeFlagTable[SC_PARALYSE] |= SCB_ASPD|SCB_FLEE|SCB_SPEED;
    StatusChangeFlagTable[SC_DEATHHURT] |= SCB_REGEN;
    StatusChangeFlagTable[SC_VENOMBLEED] |= SCB_MAXHP;
    StatusChangeFlagTable[SC_OBLIVIONCURSE] |= SCB_REGEN;

    StatusChangeFlagTable[SC_SAVAGE_STEAK] |= SCB_STR;
    StatusChangeFlagTable[SC_COCKTAIL_WARG_BLOOD] |= SCB_INT;
    StatusChangeFlagTable[SC_MINOR_BBQ] |= SCB_VIT;
    StatusChangeFlagTable[SC_SIROMA_ICE_TEA] |= SCB_DEX;
    StatusChangeFlagTable[SC_DROCERA_HERB_STEAMED] |= SCB_AGI;
    StatusChangeFlagTable[SC_PUTTI_TAILS_NOODLES] |= SCB_LUK;
    StatusChangeFlagTable[SC_BOOST500] |= SCB_ASPD;
    StatusChangeFlagTable[SC_FULL_SWING_K] |= SCB_BATK;
    StatusChangeFlagTable[SC_MANA_PLUS] |= SCB_MATK;
    StatusChangeFlagTable[SC_MUSTLE_M] |= SCB_MAXHP;
    StatusChangeFlagTable[SC_LIFE_FORCE_F] |= SCB_MAXSP;
    StatusChangeFlagTable[SC_EXTRACT_WHITE_POTION_Z] |= SCB_REGEN;
    StatusChangeFlagTable[SC_VITATA_500] |= SCB_REGEN;
    StatusChangeFlagTable[SC_EXTRACT_SALAMINE_JUICE] |= SCB_ASPD;

#ifdef RENEWAL_EDP
    // renewal EDP increases your weapon atk
    StatusChangeFlagTable[SC_EDP] |= SCB_WATK;
#endif

    if (!battle_config.display_hallucination)  //Disable Hallucination.
        StatusIconChangeTable[SC_HALLUCINATION] = SI_BLANK;

    /* StatusChangeState (SCS_) NOMOVE */
    StatusChangeStateTable[SC_ANKLE]               |= SCS_NOMOVE;
    StatusChangeStateTable[SC_AUTOCOUNTER]         |= SCS_NOMOVE;
    StatusChangeStateTable[SC_TRICKDEAD]           |= SCS_NOMOVE;
    StatusChangeStateTable[SC_BLADESTOP]           |= SCS_NOMOVE;
    StatusChangeStateTable[SC_BLADESTOP_WAIT]      |= SCS_NOMOVE;
    StatusChangeStateTable[SC_GOSPEL]              |= SCS_NOMOVE|SCS_NOMOVECOND;
    StatusChangeStateTable[SC_BASILICA]            |= SCS_NOMOVE|SCS_NOMOVECOND;
    StatusChangeStateTable[SC_STOP]                |= SCS_NOMOVE;
    StatusChangeStateTable[SC_CLOSECONFINE]        |= SCS_NOMOVE;
    StatusChangeStateTable[SC_CLOSECONFINE2]       |= SCS_NOMOVE;
    StatusChangeStateTable[SC_MADNESSCANCEL]       |= SCS_NOMOVE;
    StatusChangeStateTable[SC_GRAVITATION]         |= SCS_NOMOVE|SCS_NOMOVECOND;
    StatusChangeStateTable[SC_WHITEIMPRISON]       |= SCS_NOMOVE;
    StatusChangeStateTable[SC_ELECTRICSHOCKER]     |= SCS_NOMOVE;
    StatusChangeStateTable[SC_BITE]                |= SCS_NOMOVE;
    StatusChangeStateTable[SC_THORNSTRAP]          |= SCS_NOMOVE;
    StatusChangeStateTable[SC_MAGNETICFIELD]       |= SCS_NOMOVE;
    StatusChangeStateTable[SC__MANHOLE]            |= SCS_NOMOVE;
    StatusChangeStateTable[SC_CURSEDCIRCLE_ATKER]  |= SCS_NOMOVE;
    StatusChangeStateTable[SC_CURSEDCIRCLE_TARGET] |= SCS_NOMOVE;
    StatusChangeStateTable[SC_CRYSTALIZE]          |= SCS_NOMOVE|SCS_NOMOVECOND;
    StatusChangeStateTable[SC_NETHERWORLD]         |= SCS_NOMOVE;
    StatusChangeStateTable[SC_CAMOUFLAGE]          |= SCS_NOMOVE|SCS_NOMOVECOND;
    StatusChangeStateTable[SC_MEIKYOUSISUI]        |= SCS_NOMOVE;
    StatusChangeStateTable[SC_KAGEHUMI]            |= SCS_NOMOVE;
    StatusChangeStateTable[SC_KYOUGAKU]            |= SCS_NOMOVE;

    /* StatusChangeState (SCS_) NOPICKUPITEMS */
    StatusChangeStateTable[SC_HIDING]              |= SCS_NOPICKITEM;
    StatusChangeStateTable[SC_CLOAKING]            |= SCS_NOPICKITEM;
    StatusChangeStateTable[SC_TRICKDEAD]           |= SCS_NOPICKITEM;
    StatusChangeStateTable[SC_BLADESTOP]           |= SCS_NOPICKITEM;
    StatusChangeStateTable[SC_CLOAKINGEXCEED]      |= SCS_NOPICKITEM;
    StatusChangeStateTable[SC_NOCHAT]              |= SCS_NOPICKITEM|SCS_NOPICKITEMCOND;

    /* StatusChangeState (SCS_) NODROPITEMS */
    StatusChangeStateTable[SC_AUTOCOUNTER]         |= SCS_NODROPITEM;
    StatusChangeStateTable[SC_BLADESTOP]           |= SCS_NODROPITEM;
    StatusChangeStateTable[SC_NOCHAT]              |= SCS_NODROPITEM|SCS_NODROPITEMCOND;

    /* StatusChangeState (SCS_) NOCAST (skills) */
    StatusChangeStateTable[SC_SILENCE]             |= SCS_NOCAST;
    StatusChangeStateTable[SC_STEELBODY]           |= SCS_NOCAST;
    StatusChangeStateTable[SC_BERSERK]             |= SCS_NOCAST;
    StatusChangeStateTable[SC__BLOODYLUST]         |= SCS_NOCAST;
    StatusChangeStateTable[SC_OBLIVIONCURSE]       |= SCS_NOCAST;
    StatusChangeStateTable[SC_WHITEIMPRISON]       |= SCS_NOCAST;
    StatusChangeStateTable[SC__INVISIBILITY]       |= SCS_NOCAST;
    StatusChangeStateTable[SC_CRYSTALIZE]          |= SCS_NOCAST|SCS_NOCASTCOND;
    StatusChangeStateTable[SC__IGNORANCE]          |= SCS_NOCAST;
    StatusChangeStateTable[SC_DEEPSLEEP]           |= SCS_NOCAST;
    StatusChangeStateTable[SC_SATURDAYNIGHTFEVER]  |= SCS_NOCAST;
    StatusChangeStateTable[SC_CURSEDCIRCLE_TARGET] |= SCS_NOCAST;
    StatusChangeStateTable[SC_SILENCE]             |= SCS_NOCAST;

    //Homon S
    StatusChangeStateTable[SC_PARALYSIS]               |= SCS_NOMOVE;

}

static void initDummyData(void)
{
    memset(&dummy_status, 0, sizeof(dummy_status));
    dummy_status.hp =
        dummy_status.max_hp =
            dummy_status.max_sp =
                dummy_status.str =
                    dummy_status.agi =
                        dummy_status.vit =
                            dummy_status.int_ =
                                dummy_status.dex =
                                    dummy_status.luk =
                                        dummy_status.hit = 1;
    dummy_status.speed = 2000;
    dummy_status.adelay = 4000;
    dummy_status.amotion = 2000;
    dummy_status.dmotion = 2000;
    dummy_status.ele_lv = 1; //Min elemental level.
    dummy_status.mode = MD_CANMOVE;
}


//For copying a status_data structure from b to a, without overwriting current Hp and Sp
static inline void status_cpy(struct status_data *a, const struct status_data *b)
{
    memcpy((void *)&a->max_hp, (const void *)&b->max_hp, sizeof(struct status_data)-(sizeof(a->hp)+sizeof(a->sp)));
}

//Sets HP to given value. Flag is the flag passed to status_heal in case
//final value is higher than current (use 2 to make a healing effect display
//on players) It will always succeed (overrides Berserk block), but it can't kill.
int status_set_hp(struct block_list *bl, unsigned int hp, int flag)
{
    struct status_data *status;
    if (hp < 1) return 0;
    status = status_get_status_data(bl);
    if (status == &dummy_status)
        return 0;

    if (hp > status->max_hp) hp = status->max_hp;
    if (hp == status->hp) return 0;
    if (hp > status->hp)
        return status_heal(bl, hp - status->hp, 0, 1|flag);
    return status_zap(bl, status->hp - hp, 0);
}

//Sets SP to given value. Flag is the flag passed to status_heal in case
//final value is higher than current (use 2 to make a healing effect display
//on players)
int status_set_sp(struct block_list *bl, unsigned int sp, int flag)
{
    struct status_data *status;

    status = status_get_status_data(bl);
    if (status == &dummy_status)
        return 0;

    if (sp > status->max_sp) sp = status->max_sp;
    if (sp == status->sp) return 0;
    if (sp > status->sp)
        return status_heal(bl, 0, sp - status->sp, 1|flag);
    return status_zap(bl, 0, status->sp - sp);
}

int status_charge(struct block_list *bl, int hp, int sp)
{
    if (!(bl->type&BL_CONSUME))
        return hp+sp; //Assume all was charged so there are no 'not enough' fails.
    return status_damage(NULL, bl, hp, sp, 0, 3);
}

//Inflicts damage on the target with the according walkdelay.
//If flag&1, damage is passive and does not triggers cancelling status changes.
//If flag&2, fail if target does not has enough to substract.
//If flag&4, if killed, mob must not give exp/loot.
//flag will be set to &8 when damaging sp of a dead character
int status_damage(struct block_list *src,struct block_list *target,int hp, int sp, int walkdelay, int flag)
{
    struct status_data *status;
    struct status_change *sc;

    if (sp && !(target->type&BL_CONSUME))
        sp = 0; //Not a valid SP target.

    if (hp < 0) { //Assume absorbed damage.
        status_heal(target, -hp, 0, 1);
        hp = 0;
    }

    if (sp < 0) {
        status_heal(target, 0, -sp, 1);
        sp = 0;
    }

    if (target->type == BL_SKILL)
        return skill_unit_ondamaged((struct skill_unit *)target, src, hp, gettick());

    status = status_get_status_data(target);
    if (status == &dummy_status)
        return 0;

    if ((unsigned int)hp >= status->hp) {
        if (flag&2) return 0;
        hp = status->hp;
    }

    if ((unsigned int)sp > status->sp) {
        if (flag&2) return 0;
        sp = status->sp;
    }

    if (!hp && !sp)
        return 0;

    if (!status->hp)
        flag |= 8;

    // Let through. battle.c/skill.c have the whole logic of when it's possible or
    // not to hurt someone (and this check breaks pet catching) [Skotlex]
    //  if (!target->prev && !(flag&2))
    //      return 0; //Cannot damage a bl not on a map, except when "charging" hp/sp

    sc = status_get_sc(target);
    if (hp && battle_config.invincible_nodamage && src && sc && sc->data[SC_INVINCIBLE] && !sc->data[SC_INVINCIBLEOFF])
        hp = 1;

    if (hp && !(flag&1)) {
        if (sc) {
            struct status_change_entry *sce;
            if (sc->data[SC_STONE] && sc->opt1 == OPT1_STONE)
                status_change_end(target, SC_STONE, INVALID_TIMER);
            status_change_end(target, SC_FREEZE, INVALID_TIMER);
            status_change_end(target, SC_SLEEP, INVALID_TIMER);
            status_change_end(target, SC_WINKCHARM, INVALID_TIMER);
            status_change_end(target, SC_CONFUSION, INVALID_TIMER);
            status_change_end(target, SC_TRICKDEAD, INVALID_TIMER);
            status_change_end(target, SC_HIDING, INVALID_TIMER);
            status_change_end(target, SC_CLOAKING, INVALID_TIMER);
            status_change_end(target, SC_CHASEWALK, INVALID_TIMER);
            status_change_end(target, SC_CAMOUFLAGE, INVALID_TIMER);
            status_change_end(target, SC__INVISIBILITY, INVALID_TIMER);
            status_change_end(target, SC_DEEPSLEEP, INVALID_TIMER);
            if ((sce=sc->data[SC_ENDURE]) && !sce->val4) {
                //Endure count is only reduced by non-players on non-gvg maps.
                //val4 signals infinite endure. [Skotlex]
                if (src && src->type != BL_PC && !map_flag_gvg(target->m) && !map[target->m].flag.battleground && --(sce->val2) < 0)
                    status_change_end(target, SC_ENDURE, INVALID_TIMER);
            }
            if ((sce=sc->data[SC_GRAVITATION]) && sce->val3 == BCT_SELF) {
                struct skill_unit_group *sg = skill_id2group(sce->val4);
                if (sg) {
                    skill_delunitgroup(sg);
                    sce->val4 = 0;
                    status_change_end(target, SC_GRAVITATION, INVALID_TIMER);
                }
            }
            if (sc->data[SC_DANCING] && (unsigned int)hp > status->max_hp>>2)
                status_change_end(target, SC_DANCING, INVALID_TIMER);
            if (sc->data[SC_CLOAKINGEXCEED] && --(sc->data[SC_CLOAKINGEXCEED]->val2) <= 0)
                status_change_end(target, SC_CLOAKINGEXCEED, INVALID_TIMER);
            if (sc->data[SC_KAGEMUSYA] && --(sc->data[SC_KAGEMUSYA]->val3) <= 0)
                status_change_end(target, SC_KAGEMUSYA, INVALID_TIMER);
        }
        unit_skillcastcancel(target, 2);
    }

    status->hp-= hp;
    status->sp-= sp;

    if (sc && hp && status->hp) {
        if (sc->data[SC_AUTOBERSERK] &&
            (!sc->data[SC_PROVOKE] || !sc->data[SC_PROVOKE]->val2) &&
            status->hp < status->max_hp>>2)
            sc_start4(target,SC_PROVOKE,100,10,1,0,0,0);
        if (sc->data[SC_BERSERK] && status->hp <= 100)
            status_change_end(target, SC_BERSERK, INVALID_TIMER);
        if (sc->data[SC_RAISINGDRAGON] && status->hp <= 1000)
            status_change_end(target, SC_RAISINGDRAGON, INVALID_TIMER);
        if (sc->data[SC_SATURDAYNIGHTFEVER] && status->hp <= 100)
            status_change_end(target, SC_SATURDAYNIGHTFEVER, INVALID_TIMER);
        if (sc->data[SC__BLOODYLUST] && status->hp <= 100)
            status_change_end(target, SC__BLOODYLUST, INVALID_TIMER);
    }

    switch (target->type) {
        case BL_PC:
            pc_damage((TBL_PC *)target,src,hp,sp);
            break;
        case BL_MOB:
            mob_damage((TBL_MOB *)target, src, hp);
            break;
        case BL_HOM:
            merc_damage((TBL_HOM *)target);
            break;
        case BL_MER:
            mercenary_heal((TBL_MER *)target,hp,sp);
            break;
        case BL_ELEM:
            elemental_heal((TBL_ELEM *)target,hp,sp);
            break;
    }

    if (src && target->type == BL_PC && ((TBL_PC *)target)->disguise) {// stop walking when attacked in disguise to prevent walk-delay bug
        unit_stop_walking(target, 1);
    }

    if (status->hp || (flag&8)) {
        //Still lives or has been dead before this damage.
        if (walkdelay)
            unit_set_walkdelay(target, gettick(), walkdelay, 0);
        return hp+sp;
    }

    status->hp = 1; //To let the dead function cast skills and all that.
    //NOTE: These dead functions should return: [Skotlex]
    //0: Death cancelled, auto-revived.
    //Non-zero: Standard death. Clear status, cancel move/attack, etc
    //&2: Also remove object from map.
    //&4: Also delete object from memory.
    switch (target->type) {
        case BL_PC:
            flag = pc_dead((TBL_PC *)target,src);
            break;
        case BL_MOB:
            flag = mob_dead((TBL_MOB *)target, src, flag&4?3:0);
            break;
        case BL_HOM:
            flag = merc_hom_dead((TBL_HOM *)target);
            break;
        case BL_MER:
            flag = mercenary_dead((TBL_MER *)target);
            break;
        case BL_ELEM:
            flag = elemental_dead((TBL_ELEM *)target);
            break;
        default:    //Unhandled case, do nothing to object.
            flag = 0;
            break;
    }

    if (!flag) //Death cancelled.
        return hp+sp;

    //Normal death
    status->hp = 0;
    if (battle_config.clear_unit_ondeath &&
        battle_config.clear_unit_ondeath&target->type)
        skill_clear_unitgroup(target);

    if (target->type&BL_REGEN) {
        //Reset regen ticks.
        struct regen_data *regen = status_get_regen_data(target);
        if (regen) {
            memset(&regen->tick, 0, sizeof(regen->tick));
            if (regen->sregen)
                memset(&regen->sregen->tick, 0, sizeof(regen->sregen->tick));
            if (regen->ssregen)
                memset(&regen->ssregen->tick, 0, sizeof(regen->ssregen->tick));
        }
    }

    if (sc && sc->data[SC_KAIZEL] && !map_flag_gvg(target->m)) {
        //flag&8 = disable Kaizel
        int time = skill_get_time2(SL_KAIZEL,sc->data[SC_KAIZEL]->val1);
        //Look for Osiris Card's bonus effect on the character and revive 100% or revive normally
        if (target->type == BL_PC && BL_CAST(BL_PC,target)->special_state.restart_full_recover)
            status_revive(target, 100, 100);
        else
            status_revive(target, sc->data[SC_KAIZEL]->val2, 0);
        status_change_clear(target,0);
        clif_skill_nodamage(target,target,ALL_RESURRECTION,1,1);
        sc_start(target,status_skill2sc(PR_KYRIE),100,10,time);

        if (target->type == BL_MOB)
            ((TBL_MOB *)target)->state.rebirth = 1;

        return hp+sp;
    }
    if (target->type == BL_PC) {
        TBL_PC *sd = BL_CAST(BL_PC,target);
        TBL_HOM *hd = sd->hd;
        if (hd && hd->sc.data[SC_LIGHT_OF_REGENE]) {
            clif_skillcasting(&hd->bl, hd->bl.id, target->id, 0,0, MH_LIGHT_OF_REGENE, skill_get_ele(MH_LIGHT_OF_REGENE, 1), 10); //just to display usage
            clif_skill_nodamage(&sd->bl, target, ALL_RESURRECTION, 1, status_revive(&sd->bl,10*hd->sc.data[SC_LIGHT_OF_REGENE]->val1,0));
            status_change_end(&sd->hd->bl,SC_LIGHT_OF_REGENE,INVALID_TIMER);
            return hp + sp;
        }
    }
    if (target->type == BL_MOB && sc && sc->data[SC_REBIRTH] && !((TBL_MOB *) target)->state.rebirth) { // Ensure the monster has not already rebirthed before doing so.
        status_revive(target, sc->data[SC_REBIRTH]->val2, 0);
        status_change_clear(target,0);
        ((TBL_MOB *)target)->state.rebirth = 1;

        return hp+sp;
    }

    status_change_clear(target,0);

    if (flag&4) //Delete from memory. (also invokes map removal code)
        unit_free(target,CLR_DEAD);
    else if (flag&2) //remove from map
        unit_remove_map(target,CLR_DEAD);
    else {
        //Some death states that would normally be handled by unit_remove_map
        unit_stop_attack(target);
        unit_stop_walking(target,1);
        unit_skillcastcancel(target,0);
        clif_clearunit_area(target,CLR_DEAD);
        skill_unit_move(target,gettick(),4);
        skill_cleartimerskill(target);
    }

    return hp+sp;
}

//Heals a character. If flag&1, this is forced healing (otherwise stuff like Berserk can block it)
//If flag&2, when the player is healed, show the HP/SP heal effect.
int status_heal(struct block_list *bl,int hp,int sp, int flag)
{
    struct status_data *status;
    struct status_change *sc;

    status = status_get_status_data(bl);

    if (status == &dummy_status || !status->hp)
        return 0;

    sc = status_get_sc(bl);
    if (sc && !sc->count)
        sc = NULL;

    if (hp < 0) {
        if (hp == INT_MIN) hp++; //-INT_MIN == INT_MIN in some architectures!
        status_damage(NULL, bl, -hp, 0, 0, 1);
        hp = 0;
    }

    if (hp) {
        if (sc && (sc->data[SC_BERSERK] || sc->data[SC__BLOODYLUST])) {
            if (flag&1)
                flag &= ~2;
            else
                hp = 0;
        }

        if ((unsigned int)hp > status->max_hp - status->hp)
            hp = status->max_hp - status->hp;
    }

    if (sp < 0) {
        if (sp==INT_MIN) sp++;
        status_damage(NULL, bl, 0, -sp, 0, 1);
        sp = 0;
    }

    if (sp) {
        if ((unsigned int)sp > status->max_sp - status->sp)
            sp = status->max_sp - status->sp;
    }

    if (!sp && !hp) return 0;

    status->hp+= hp;
    status->sp+= sp;

    if (hp && sc &&
        sc->data[SC_AUTOBERSERK] &&
        sc->data[SC_PROVOKE] &&
        sc->data[SC_PROVOKE]->val2==1 &&
        status->hp>=status->max_hp>>2
       )   //End auto berserk.
        status_change_end(bl, SC_PROVOKE, INVALID_TIMER);

    // send hp update to client
    switch (bl->type) {
        case BL_PC:
            pc_heal((TBL_PC *)bl,hp,sp,flag&2?1:0);
            break;
        case BL_MOB:
            mob_heal((TBL_MOB *)bl,hp);
            break;
        case BL_HOM:
            merc_hom_heal((TBL_HOM *)bl);
            break;
        case BL_MER:
            mercenary_heal((TBL_MER *)bl,hp,sp);
            break;
        case BL_ELEM:
            elemental_heal((TBL_ELEM *)bl,hp,sp);
            break;
    }

    return hp+sp;
}

//Does percentual non-flinching damage/heal. If mob is killed this way,
//no exp/drops will be awarded if there is no src (or src is target)
//If rates are > 0, percent is of current HP/SP
//If rates are < 0, percent is of max HP/SP
//If !flag, this is heal, otherwise it is damage.
//Furthermore, if flag==2, then the target must not die from the substraction.
int status_percent_change(struct block_list *src,struct block_list *target,signed char hp_rate, signed char sp_rate, int flag)
{
    struct status_data *status;
    unsigned int hp  =0, sp = 0;

    status = status_get_status_data(target);

    //Change the equation when the values are high enough to discard the
    //imprecision in exchange of overflow protection [Skotlex]
    //Also add 100% checks since those are the most used cases where we don't
    //want aproximation errors.
    if (hp_rate > 99)
        hp = status->hp;
    else if (hp_rate > 0)
        hp = status->hp>10000?
             hp_rate*(status->hp/100):
             (hp_rate*status->hp)/100;
    else if (hp_rate < -99)
        hp = status->max_hp;
    else if (hp_rate < 0)
        hp = status->max_hp>10000?
             (-hp_rate)*(status->max_hp/100):
             (-hp_rate*status->max_hp)/100;
    if (hp_rate && !hp)
        hp = 1;

    if (flag == 2 && hp >= status->hp)
        hp = status->hp-1; //Must not kill target.

    //Should be safe to not do overflow protection here, noone should have
    //millions upon millions of SP
    if (sp_rate > 99)
        sp = status->sp;
    else if (sp_rate > 0)
        sp = (sp_rate*status->sp)/100;
    else if (sp_rate < -99)
        sp = status->max_sp;
    else if (sp_rate < 0)
        sp = (-sp_rate)*status->max_sp/100;
    if (sp_rate && !sp)
        sp = 1;

    //Ugly check in case damage dealt is too much for the received args of
    //status_heal / status_damage. [Skotlex]
    if (hp > INT_MAX) {
        hp -= INT_MAX;
        if (flag)
            status_damage(src, target, INT_MAX, 0, 0, (!src||src==target?5:1));
        else
            status_heal(target, INT_MAX, 0, 0);
    }
    if (sp > INT_MAX) {
        sp -= INT_MAX;
        if (flag)
            status_damage(src, target, 0, INT_MAX, 0, (!src||src==target?5:1));
        else
            status_heal(target, 0, INT_MAX, 0);
    }
    if (flag)
        return status_damage(src, target, hp, sp, 0, (!src||src==target?5:1));
    return status_heal(target, hp, sp, 0);
}

int status_revive(struct block_list *bl, unsigned char per_hp, unsigned char per_sp)
{
    struct status_data *status;
    unsigned int hp, sp;
    if (!status_isdead(bl)) return 0;

    status = status_get_status_data(bl);
    if (status == &dummy_status)
        return 0; //Invalid target.

    hp = status->max_hp * per_hp/100;
    sp = status->max_sp * per_sp/100;

    if (hp > status->max_hp - status->hp)
        hp = status->max_hp - status->hp;
    else if (per_hp && !hp)
        hp = 1;

    if (sp > status->max_sp - status->sp)
        sp = status->max_sp - status->sp;
    else if (per_sp && !sp)
        sp = 1;

    status->hp += hp;
    status->sp += sp;

    if (bl->prev) //Animation only if character is already on a map.
        clif_resurrection(bl, 1);
    switch (bl->type) {
        case BL_PC:
            pc_revive((TBL_PC *)bl, hp, sp);
            break;
        case BL_MOB:
            mob_revive((TBL_MOB *)bl, hp);
            break;
        case BL_HOM:
            merc_hom_revive((TBL_HOM *)bl, hp, sp);
            break;
    }
    return 1;
}

/*==========================================
 * Checks whether the src can use the skill on the target,
 * taking into account status/option of both source/target. [Skotlex]
 * flag:
 *  0 - Trying to use skill on target.
 *  1 - Cast bar is done.
 *  2 - Skill already pulled off, check is due to ground-based skills or splash-damage ones.
 * src MAY be null to indicate we shouldn't check it, this is a ground-based skill attack.
 * target MAY Be null, in which case the checks are only to see
 * whether the source can cast or not the skill on the ground.
 *------------------------------------------*/
int status_check_skilluse(struct block_list *src, struct block_list *target, int skill_num, int flag)
{
    struct status_data *status;
    struct status_change *sc=NULL, *tsc;
    int hide_flag;

    status = src?status_get_status_data(src):&dummy_status;

    if (src && src->type != BL_PC && status_isdead(src))
        return 0;

    if (!skill_num) { //Normal attack checks.
        if (!(status->mode&MD_CANATTACK))
            return 0; //This mode is only needed for melee attacking.
        //Dead state is not checked for skills as some skills can be used
        //on dead characters, said checks are left to skill.c [Skotlex]
        if (target && status_isdead(target))
            return 0;
        if (src && (sc = status_get_sc(src)) && sc->data[SC_CRYSTALIZE] && src->type != BL_MOB)
            return 0;
    }

    switch (skill_num) {
        case PA_PRESSURE:
            if (flag && target) {
                //Gloria Avoids pretty much everything....
                tsc = status_get_sc(target);
                if (tsc && tsc->option&OPTION_HIDE)
                    return 0;
            }
            break;
        case GN_WALLOFTHORN:
            if (target && status_isdead(target))
                return 0;
            break;
        case AL_TELEPORT:
            //Should fail when used on top of Land Protector [Skotlex]
            if (src && map_getcell(src->m, src->x, src->y, CELL_CHKLANDPROTECTOR)
                && !(status->mode&MD_BOSS)
                && (src->type != BL_PC || ((TBL_PC *)src)->skillitem != skill_num))
                return 0;
            break;
        default:
            break;
    }

    if (src) sc = status_get_sc(src);

    if (sc && sc->count) {

        if (skill_num != RK_REFRESH && sc->opt1 >0 && (sc->opt1 != OPT1_CRYSTALIZE && src->type != BL_MOB) && sc->opt1 != OPT1_BURNING && skill_num != SR_GENTLETOUCH_CURE) {   //Stuned/Frozen/etc
            if (flag != 1) //Can't cast, casted stuff can't damage.
                return 0;
            if (!(skill_get_inf(skill_num)&INF_GROUND_SKILL))
                return 0; //Targetted spells can't come off.
        }

        if (
            (sc->data[SC_TRICKDEAD] && skill_num != NV_TRICKDEAD)
            || (sc->data[SC_AUTOCOUNTER] && !flag)
            || (sc->data[SC_GOSPEL] && sc->data[SC_GOSPEL]->val4 == BCT_SELF && skill_num != PA_GOSPEL)
            || (sc->data[SC_GRAVITATION] && sc->data[SC_GRAVITATION]->val3 == BCT_SELF && flag != 2)
        )
            return 0;

        if (sc->data[SC_WINKCHARM] && target && !flag) { //Prevents skill usage
            if (unit_bl2ud(src) && (unit_bl2ud(src))->walktimer == INVALID_TIMER)
                unit_walktobl(src, map_id2bl(sc->data[SC_WINKCHARM]->val2), 3, 1);
            clif_emotion(src, E_LV);
            return 0;
        }

        if (sc->data[SC_BLADESTOP]) {
            switch (sc->data[SC_BLADESTOP]->val1) {
                case 5:
                    if (skill_num == MO_EXTREMITYFIST) break;
                case 4:
                    if (skill_num == MO_CHAINCOMBO) break;
                case 3:
                    if (skill_num == MO_INVESTIGATE) break;
                case 2:
                    if (skill_num == MO_FINGEROFFENSIVE) break;
                default:
                    return 0;
            }
        }

        if (sc->data[SC_DANCING] && flag!=2) {
            if (src->type == BL_PC && skill_num >= WA_SWING_DANCE && skill_num <= WM_UNLIMITED_HUMMING_VOICE) {
                // Lvl 5 Lesson or higher allow you use 3rd job skills while dancing.v
                if (pc_checkskill((TBL_PC *)src,WM_LESSON) < 5)
                    return 0;
            } else if (sc->data[SC_LONGING]) { //Allow everything except dancing/re-dancing. [Skotlex]
                if (skill_num == BD_ENCORE ||
                    skill_get_inf2(skill_num)&(INF2_SONG_DANCE|INF2_ENSEMBLE_SKILL)
                   )
                    return 0;
            } else {
                switch (skill_num) {
                    case BD_ADAPTATION:
                    case CG_LONGINGFREEDOM:
                    case BA_MUSICALSTRIKE:
                    case DC_THROWARROW:
                        break;
                    default:
                        return 0;
                }
            }
            if ((sc->data[SC_DANCING]->val1&0xFFFF) == CG_HERMODE && skill_num == BD_ADAPTATION)
                return 0;   //Can't amp out of Wand of Hermode :/ [Skotlex]
        }

        if (skill_num && //Do not block item-casted skills.
            (src->type != BL_PC || ((TBL_PC *)src)->skillitem != skill_num)
           ) { //Skills blocked through status changes...
            if (!flag && ( //Blocked only from using the skill (stuff like autospell may still go through
                    sc->cant.cast ||
                    (sc->data[SC_MARIONETTE] && skill_num != CG_MARIONETTE) || //Only skill you can use is marionette again to cancel it
                    (sc->data[SC_MARIONETTE2] && skill_num == CG_MARIONETTE) || //Cannot use marionette if you are being buffed by another
                    (sc->data[SC_STASIS] && skill_block_check(src, SC_STASIS, skill_num)) ||
                    (sc->data[SC_KAGEHUMI] && skill_block_check(src, SC_KAGEHUMI, skill_num))
                ))
                return 0;

            //Skill blocking.
            if (
                (sc->data[SC_VOLCANO] && skill_num == WZ_ICEWALL) ||
                (sc->data[SC_ROKISWEIL] && skill_num != BD_ADAPTATION) ||
                (sc->data[SC_HERMODE] && skill_get_inf(skill_num) & INF_SUPPORT_SKILL) ||
                (sc->data[SC_NOCHAT] && sc->data[SC_NOCHAT]->val1&MANNER_NOSKILL)
            )
                return 0;

            if (sc->data[SC__MANHOLE] || ((tsc = status_get_sc(target)) && tsc->data[SC__MANHOLE])) {
                switch (skill_num) { //##TODO## make this a flag in skill_db?
                        // Skills that can be used even under Man Hole effects.
                    case SC_SHADOWFORM:
                    case SC_STRIPACCESSARY:
                        break;
                    default:
                        return 0;
                }
            }

        }
    }

    if (sc && sc->option) {
        if (sc->option&OPTION_HIDE)
            switch (skill_num) { //Usable skills while hiding.
                case TF_HIDING:
                case AS_GRIMTOOTH:
                case RG_BACKSTAP:
                case RG_RAID:
                case NJ_SHADOWJUMP:
                case NJ_KIRIKAGE:
                case KO_YAMIKUMO:
                    break;
                default:
                    //Non players can use all skills while hidden.
                    if (!skill_num || src->type == BL_PC)
                        return 0;
            }
        if (sc->option&OPTION_CHASEWALK && skill_num != ST_CHASEWALK)
            return 0;
        if (sc->option&OPTION_MOUNTING)
            return 0;//New mounts can't attack nor use skills in the client; this check makes it cheat-safe [Ind]
    }

    if (target == NULL || target == src) //No further checking needed.
        return 1;

    tsc = status_get_sc(target);

    if (tsc && tsc->count) {
        /* attacks in invincible are capped to 1 damage and handled in batte.c; allow spell break and eske for sealed shrine GDB when in INVINCIBLE state. */
        if (tsc->data[SC_INVINCIBLE] && !tsc->data[SC_INVINCIBLEOFF] && skill_num && !(skill_num&(SA_SPELLBREAKER|SL_SKE)))
            return 0;
        if (!skill_num && tsc->data[SC_TRICKDEAD])
            return 0;
        if ((skill_num == WZ_STORMGUST || skill_num == WZ_FROSTNOVA || skill_num == NJ_HYOUSYOURAKU)
            && tsc->data[SC_FREEZE])
            return 0;
        if (skill_num == PR_LEXAETERNA && (tsc->data[SC_FREEZE] || (tsc->data[SC_STONE] && tsc->opt1 == OPT1_STONE)))
            return 0;
    }

    //If targetting, cloak+hide protect you, otherwise only hiding does.
    hide_flag = flag?OPTION_HIDE:(OPTION_HIDE|OPTION_CLOAK|OPTION_CHASEWALK);

    //You cannot hide from ground skills.
    if (skill_get_ele(skill_num,1) == ELE_EARTH)  //TODO: Need Skill Lv here :/
        hide_flag &= ~OPTION_HIDE;

    switch (target->type) {
        case BL_PC: {
                struct map_session_data *sd = (TBL_PC *) target;
                bool is_boss = (status->mode&MD_BOSS);
                bool is_detect = ((status->mode&MD_DETECTOR)?true:false);//god-knows-why gcc doesn't shut up until this happens
                if (pc_isinvisible(sd))
                    return 0;
                if (tsc->option&hide_flag && !is_boss &&
                    ((sd->special_state.perfect_hiding || !is_detect) ||
                     (tsc->data[SC_CLOAKINGEXCEED] && is_detect)))
                    return 0;
                if (tsc->data[SC_CAMOUFLAGE] && !(is_boss || is_detect) && !skill_num)
                    return 0;
                if (tsc->data[SC_STEALTHFIELD] && !is_boss)
                    return 0;
            }
            break;
        case BL_ITEM:   //Allow targetting of items to pick'em up (or in the case of mobs, to loot them).
            //TODO: Would be nice if this could be used to judge whether the player can or not pick up the item it targets. [Skotlex]
            if (status->mode&MD_LOOTER)
                return 1;
            return 0;
        case BL_HOM:
        case BL_MER:
        case BL_ELEM:
            if (target->type == BL_HOM && skill_num && battle_config.hom_setting&0x1 && skill_get_inf(skill_num)&INF_SUPPORT_SKILL && battle_get_master(target) != src)
                return 0; // Can't use support skills on Homunculus (only Master/Self)
            if (target->type == BL_MER && (skill_num == PR_ASPERSIO || (skill_num >= SA_FLAMELAUNCHER && skill_num <= SA_SEISMICWEAPON)) && battle_get_master(target) != src)
                return 0; // Can't use Weapon endow skills on Mercenary (only Master)
            if (skill_num == AM_POTIONPITCHER && (target->type == BL_MER || target->type == BL_ELEM))
                return 0; // Can't use Potion Pitcher on Mercenaries
        default:
            //Check for chase-walk/hiding/cloaking opponents.
            if (tsc) {
                if (tsc->option&hide_flag && !(status->mode&(MD_BOSS|MD_DETECTOR)))
                    return 0;
                if (tsc->data[SC_STEALTHFIELD] && !(status->mode&MD_BOSS))
                    return 0;
            }
    }
    return 1;
}

//Checks whether the source can see and chase target.
int status_check_visibility(struct block_list *src, struct block_list *target)
{
    int view_range;
    struct status_data *status = status_get_status_data(src);
    struct status_change *tsc = status_get_sc(target);
    switch (src->type) {
        case BL_MOB:
            view_range = ((TBL_MOB *)src)->min_chase;
            break;
        case BL_PET:
            view_range = ((TBL_PET *)src)->db->range2;
            break;
        default:
            view_range = AREA_SIZE;
    }

    if (src->m != target->m || !check_distance_bl(src, target, view_range))
        return 0;

    if (tsc && tsc->data[SC_STEALTHFIELD])
        return 0;

    switch (target->type) {
            //Check for chase-walk/hiding/cloaking opponents.
        case BL_PC:
            if (tsc->data[SC_CLOAKINGEXCEED] && !(status->mode&MD_BOSS))
                return 0;
            if ((tsc->option&(OPTION_HIDE|OPTION_CLOAK|OPTION_CHASEWALK) || tsc->data[SC__INVISIBILITY] || tsc->data[SC_CAMOUFLAGE]) && !(status->mode&MD_BOSS) &&
                (((TBL_PC *)target)->special_state.perfect_hiding || !(status->mode&MD_DETECTOR)))
                return 0;
            break;
        default:
            if (tsc && (tsc->option&(OPTION_HIDE|OPTION_CLOAK|OPTION_CHASEWALK) || tsc->data[SC__INVISIBILITY] || tsc->data[SC_CAMOUFLAGE]) && !(status->mode&(MD_BOSS|MD_DETECTOR)))
                return 0;

    }

    return 1;
}

// Basic ASPD value
int status_base_amotion_pc(struct map_session_data *sd, struct status_data *status)
{
    int amotion;
#ifdef RENEWAL_ASPD
    short mod = -1;

    switch (sd->weapontype2) { // adjustment for dual weilding
        case W_DAGGER:
            mod = 0;
            break; // 0, 1, 1
        case W_1HSWORD:
        case W_1HAXE:
            mod = 1;
            if ((sd->class_&MAPID_THIRDMASK) == MAPID_GUILLOTINE_CROSS)  // 0, 2, 3
                mod = sd->weapontype2 / W_1HSWORD + W_1HSWORD / sd->weapontype2 ;
    }

    amotion = (sd->status.weapon < MAX_WEAPON_TYPE && mod < 0)
              ? (aspd_base[pc_class2idx(sd->status.class_)][sd->status.weapon]) // single weapon
              : ((aspd_base[pc_class2idx(sd->status.class_)][sd->weapontype2] // dual-wield
                  + aspd_base[pc_class2idx(sd->status.class_)][sd->weapontype2]) * 6 / 10 + 10 * mod
                 - aspd_base[pc_class2idx(sd->status.class_)][sd->weapontype2]
                 + aspd_base[pc_class2idx(sd->status.class_)][sd->weapontype1]);

    if (sd->status.shield)
        amotion += (2000 - aspd_base[pc_class2idx(sd->status.class_)][W_FIST]) +
                   (aspd_base[pc_class2idx(sd->status.class_)][MAX_WEAPON_TYPE] - 2000);

#else
    // base weapon delay
    amotion = (sd->status.weapon < MAX_WEAPON_TYPE)
              ? (aspd_base[pc_class2idx(sd->status.class_)][sd->status.weapon]) // single weapon
              : (aspd_base[pc_class2idx(sd->status.class_)][sd->weapontype1] + aspd_base[pc_class2idx(sd->status.class_)][sd->weapontype2])*7/10; // dual-wield

    // percentual delay reduction from stats
    amotion -= amotion * (4*status->agi + status->dex)/1000;
#endif
    // raw delay adjustment from bAspd bonus
    amotion += sd->bonus.aspd_add;

    return amotion;
}

static unsigned short status_base_atk(const struct block_list *bl, const struct status_data *status)
{
    int flag = 0, str, dex,
#ifdef RENEWAL
        rstr,
#endif
        dstr;


    if (!(bl->type&battle_config.enable_baseatk))
        return 0;

    if (bl->type == BL_PC)
        switch (((TBL_PC *)bl)->status.weapon) {
            case W_BOW:
            case W_MUSICAL:
            case W_WHIP:
            case W_REVOLVER:
            case W_RIFLE:
            case W_GATLING:
            case W_SHOTGUN:
            case W_GRENADE:
                flag = 1;
        }
    if (flag) {
#ifdef RENEWAL
        rstr =
#endif
            str = status->dex;
        dex = status->str;
    } else {
#ifdef RENEWAL
        rstr =
#endif
            str = status->str;
        dex = status->dex;
    }
    //Normally only players have base-atk, but homunc have a different batk
    // equation, hinting that perhaps non-players should use this for batk.
    // [Skotlex]
    dstr = str/10;
    str += dstr*dstr;
    if (bl->type == BL_PC)
#ifdef RENEWAL
        str = (rstr*10 + dex*10/5 + status->luk*10/3 + ((TBL_PC *)bl)->status.base_level*10/4)/10;
#else
        str+= dex/5 + status->luk/5;
#endif
    return cap_value(str, 0, USHRT_MAX);
}

#ifndef RENEWAL
static inline unsigned short status_base_matk_min(const struct status_data* status){ return status->int_+(status->int_/7)*(status->int_/7); }
static inline unsigned short status_base_matk_max(const struct status_data* status){ return status->int_+(status->int_/5)*(status->int_/5); }
#else
unsigned short status_base_matk(const struct status_data* status, int level){ return status->int_+(status->int_/2)+(status->dex/5)+(status->luk/3)+(level/4); }
#endif

//Fills in the misc data that can be calculated from the other status info (except for level)
void status_calc_misc(struct block_list *bl, struct status_data *status, int level)
{
    //Non players get the value set, players need to stack with previous bonuses.
    if (bl->type != BL_PC)
        status->batk =
            status->hit = status->flee =
                              status->def2 = status->mdef2 =
                                                 status->cri = status->flee2 = 0;

#ifdef RENEWAL // renewal formulas
    status->matk_min = status->matk_max = status_base_matk(status, level);
    status->hit += level + status->dex + status->luk/3 + 175; //base level + ( every 1 dex = +1 hit ) + (every 3 luk = +1 hit) + 175
    status->flee += level + status->agi + status->luk/5 + 100; //base level + ( every 1 agi = +1 flee ) + (every 5 luk = +1 flee) + 100
    status->def2 += (int)(((float)level + status->vit)/2 + ((float)status->agi/5)); //base level + (every 2 vit = +1 def) + (every 5 agi = +1 def)
    status->mdef2 += (int)(status->int_ + ((float)level/4) + ((float)status->dex/5) + ((float)status->vit/5)); //(every 4 base level = +1 mdef) + (every 1 int = +1 mdef) + (every 5 dex = +1 mdef) + (every 5 vit = +1 mdef)
#else
    status->matk_min = status_base_matk_min(status);
    status->matk_max = status_base_matk_max(status);
    status->hit += level + status->dex;
    status->flee += level + status->agi;
    status->def2 += status->vit;
    status->mdef2 += status->int_ + (status->vit>>1);
#endif

    if (bl->type&battle_config.enable_critical)
        status->cri += 10 + (status->luk*10/3); //(every 1 luk = +0.3 critical)
    else
        status->cri = 0;

    if (bl->type&battle_config.enable_perfect_flee)
        status->flee2 += status->luk + 10; //(every 10 luk = +1 perfect flee)
    else
        status->flee2 = 0;

    if (status->batk) {
        int temp = status->batk + status_base_atk(bl, status);
        status->batk = cap_value(temp, 0, USHRT_MAX);
    } else
        status->batk = status_base_atk(bl, status);
    if (status->cri)
        switch (bl->type) {
            case BL_MOB:
                if (battle_config.mob_critical_rate != 100)
                    status->cri = status->cri*battle_config.mob_critical_rate/100;
                if (!status->cri && battle_config.mob_critical_rate)
                    status->cri = 10;
                break;
            case BL_PC:
                //Players don't have a critical adjustment setting as of yet.
                break;
            default:
                if (battle_config.critical_rate != 100)
                    status->cri = status->cri*battle_config.critical_rate/100;
                if (!status->cri && battle_config.critical_rate)
                    status->cri = 10;
        }
    if (bl->type&BL_REGEN)
        status_calc_regen(bl, status, status_get_regen_data(bl));
}

//Skotlex: Calculates the initial status for the given mob
//first will only be false when the mob leveled up or got a GuardUp level.
int status_calc_mob_(struct mob_data *md, bool first)
{
    struct status_data *status;
    struct block_list *mbl = NULL;
    int flag=0;

    if (first) {
        //Set basic level on respawn.
        if (md->level > 0 && md->level <= MAX_LEVEL && md->level != md->db->lv)
            ;
        else
            md->level = md->db->lv;
    }

    //Check if we need custom base-status
    if (battle_config.mobs_level_up && md->level > md->db->lv)
        flag|=1;

    if (md->special_state.size)
        flag|=2;

    if (md->guardian_data && md->guardian_data->guardup_lv)
        flag|=4;
    if (md->class_ == MOBID_EMPERIUM)
        flag|=4;

    if (battle_config.slaves_inherit_speed && md->master_id)
        flag|=8;

    if (md->master_id && md->special_state.ai>1)
        flag|=16;

    if (!flag) {
        //No special status required.
        if (md->base_status) {
            aFree(md->base_status);
            md->base_status = NULL;
        }
        if (first)
            memcpy(&md->status, &md->db->status, sizeof(struct status_data));
        return 0;
    }
    if (!md->base_status)
        md->base_status = (struct status_data *)aCalloc(1, sizeof(struct status_data));

    status = md->base_status;
    memcpy(status, &md->db->status, sizeof(struct status_data));

    if (flag&(8|16))
        mbl = map_id2bl(md->master_id);

    if (flag&8 && mbl) {
        struct status_data *mstatus = status_get_base_status(mbl);
        if (mstatus &&
            battle_config.slaves_inherit_speed&(mstatus->mode&MD_CANMOVE?1:2))
            status->speed = mstatus->speed;
        if (status->speed < 2)  /* minimum for the unit to function properly */
            status->speed = 2;
    }

    if (flag&16 && mbl) {
        //Max HP setting from Summon Flora/marine Sphere
        struct unit_data *ud = unit_bl2ud(mbl);
        //Remove special AI when this is used by regular mobs.
        if (mbl->type == BL_MOB && !((TBL_MOB *)mbl)->special_state.ai)
            md->special_state.ai = 0;
        if (ud) {
            // different levels of HP according to skill level
            if (ud->skillid == AM_SPHEREMINE) {
                status->max_hp = 2000 + 400*ud->skilllv;
            } else if (ud->skillid == KO_ZANZOU) {
                status->max_hp = 3000 + 3000 * ud->skilllv;
            } else { //AM_CANNIBALIZE
                status->max_hp = 1500 + 200*ud->skilllv + 10*status_get_lv(mbl);
                status->mode|= MD_CANATTACK|MD_AGGRESSIVE;
            }
            status->hp = status->max_hp;
        }
    }

    if (flag&1) {
        // increase from mobs leveling up [Valaris]
        int diff = md->level - md->db->lv;
        status->str+= diff;
        status->agi+= diff;
        status->vit+= diff;
        status->int_+= diff;
        status->dex+= diff;
        status->luk+= diff;
        status->max_hp += diff*status->vit;
        status->max_sp += diff*status->int_;
        status->hp = status->max_hp;
        status->sp = status->max_sp;
        status->speed -= cap_value(diff, 0, status->speed - 10);
    }


    if (flag&2 && battle_config.mob_size_influence) {
        // change for sized monsters [Valaris]
        if (md->special_state.size==SZ_MEDIUM) {
            status->max_hp>>=1;
            status->max_sp>>=1;
            if (!status->max_hp) status->max_hp = 1;
            if (!status->max_sp) status->max_sp = 1;
            status->hp=status->max_hp;
            status->sp=status->max_sp;
            status->str>>=1;
            status->agi>>=1;
            status->vit>>=1;
            status->int_>>=1;
            status->dex>>=1;
            status->luk>>=1;
            if (!status->str) status->str = 1;
            if (!status->agi) status->agi = 1;
            if (!status->vit) status->vit = 1;
            if (!status->int_) status->int_ = 1;
            if (!status->dex) status->dex = 1;
            if (!status->luk) status->luk = 1;
        } else if (md->special_state.size==SZ_BIG) {
            status->max_hp<<=1;
            status->max_sp<<=1;
            status->hp=status->max_hp;
            status->sp=status->max_sp;
            status->str<<=1;
            status->agi<<=1;
            status->vit<<=1;
            status->int_<<=1;
            status->dex<<=1;
            status->luk<<=1;
        }
    }

    status_calc_misc(&md->bl, status, md->level);

    if (flag&4) {
        // Strengthen Guardians - custom value +10% / lv
        struct guild_castle *gc;
        gc=guild_mapname2gc(map[md->bl.m].name);
        if (!gc)
            ShowError("status_calc_mob: No castle set at map %s\n", map[md->bl.m].name);
        else if (gc->castle_id < 24 || md->class_ == MOBID_EMPERIUM) {
#ifdef RENEWAL
            status->max_hp += 50 * gc->defense;
            status->max_sp += 70 * gc->defense;
#else
            status->max_hp += 1000 * gc->defense;
            status->max_sp += 200 * gc->defense;
#endif
            status->hp = status->max_hp;
            status->sp = status->max_sp;
            status->def += (gc->defense+2)/3;
            status->mdef += (gc->defense+2)/3;
        }
        if (md->class_ != MOBID_EMPERIUM) {
            status->batk += status->batk * 10*md->guardian_data->guardup_lv/100;
            status->rhw.atk += status->rhw.atk * 10*md->guardian_data->guardup_lv/100;
            status->rhw.atk2 += status->rhw.atk2 * 10*md->guardian_data->guardup_lv/100;
            status->aspd_rate -= 100*md->guardian_data->guardup_lv;
        }
    }

    if (first)  //Initial battle status
        memcpy(&md->status, status, sizeof(struct status_data));

    return 1;
}

//Skotlex: Calculates the stats of the given pet.
int status_calc_pet_(struct pet_data *pd, bool first)
{
    nullpo_ret(pd);

    if (first) {
        memcpy(&pd->status, &pd->db->status, sizeof(struct status_data));
        pd->status.mode = MD_CANMOVE; // pets discard all modes, except walking
        pd->status.speed = pd->petDB->speed;

        if (battle_config.pet_attack_support || battle_config.pet_damage_support) {
            // attack support requires the pet to be able to attack
            pd->status.mode|= MD_CANATTACK;
        }
    }

    if (battle_config.pet_lv_rate && pd->msd) {
        struct map_session_data *sd = pd->msd;
        int lv;

        lv =sd->status.base_level*battle_config.pet_lv_rate/100;
        if (lv < 0)
            lv = 1;
        if (lv != pd->pet.level || first) {
            struct status_data *bstat = &pd->db->status, *status = &pd->status;
            pd->pet.level = lv;
            if (!first) //Lv Up animation
                clif_misceffect(&pd->bl, 0);
            status->rhw.atk = (bstat->rhw.atk*lv)/pd->db->lv;
            status->rhw.atk2 = (bstat->rhw.atk2*lv)/pd->db->lv;
            status->str = (bstat->str*lv)/pd->db->lv;
            status->agi = (bstat->agi*lv)/pd->db->lv;
            status->vit = (bstat->vit*lv)/pd->db->lv;
            status->int_ = (bstat->int_*lv)/pd->db->lv;
            status->dex = (bstat->dex*lv)/pd->db->lv;
            status->luk = (bstat->luk*lv)/pd->db->lv;

            status->rhw.atk = cap_value(status->rhw.atk, 1, battle_config.pet_max_atk1);
            status->rhw.atk2 = cap_value(status->rhw.atk2, 2, battle_config.pet_max_atk2);
            status->str = cap_value(status->str,1,battle_config.pet_max_stats);
            status->agi = cap_value(status->agi,1,battle_config.pet_max_stats);
            status->vit = cap_value(status->vit,1,battle_config.pet_max_stats);
            status->int_= cap_value(status->int_,1,battle_config.pet_max_stats);
            status->dex = cap_value(status->dex,1,battle_config.pet_max_stats);
            status->luk = cap_value(status->luk,1,battle_config.pet_max_stats);

            status_calc_misc(&pd->bl, &pd->status, lv);

            if (!first) //Not done the first time because the pet is not visible yet
                clif_send_petstatus(sd);
        }
    } else if (first) {
        status_calc_misc(&pd->bl, &pd->status, pd->db->lv);
        if (!battle_config.pet_lv_rate && pd->pet.level != pd->db->lv)
            pd->pet.level = pd->db->lv;
    }

    //Support rate modifier (1000 = 100%)
    pd->rate_fix = 1000*(pd->pet.intimate - battle_config.pet_support_min_friendly)/(1000- battle_config.pet_support_min_friendly) +500;
    if (battle_config.pet_support_rate != 100)
        pd->rate_fix = pd->rate_fix*battle_config.pet_support_rate/100;

    return 1;
}

/// Helper function for status_base_pc_maxhp(), used to pre-calculate the hp_sigma_val[] array
static void status_calc_sigma(void)
{
    int i,j;

    for (i = 0; i < CLASS_COUNT; i++) {
        unsigned int k = 0;
        hp_sigma_val[i][0] = hp_sigma_val[i][1] = 0;
        for (j = 2; j <= MAX_LEVEL; j++) {
            k += (hp_coefficient[i]*j + 50) / 100;
            hp_sigma_val[i][j] = k;
            if (k >= INT_MAX)
                break; //Overflow protection. [Skotlex]
        }
        for (; j <= MAX_LEVEL; j++)
            hp_sigma_val[i][j] = INT_MAX;
    }
}

/// Calculates base MaxHP value according to class and base level
/// The recursive equation used to calculate level bonus is (using integer operations)
///    f(0) = 35 | f(x+1) = f(x) + A + (x + B)*C/D
/// which reduces to something close to
///    f(x) = 35 + x*(A + B*C/D) + sum(i=2..x){ i*C/D }
static unsigned int status_base_pc_maxhp(struct map_session_data *sd, struct status_data *status)
{
    unsigned int val = pc_class2idx(sd->status.class_);
    val = 35 + sd->status.base_level*hp_coefficient2[val]/100 + hp_sigma_val[val][sd->status.base_level];

    if ((sd->class_&MAPID_UPPERMASK) == MAPID_NINJA || (sd->class_&MAPID_UPPERMASK) == MAPID_GUNSLINGER)
        val += 100; //Since their HP can't be approximated well enough without this.
    if ((sd->class_&MAPID_UPPERMASK) == MAPID_TAEKWON && sd->status.base_level >= 90 && pc_famerank(sd->status.char_id, MAPID_TAEKWON))
        val *= 3; //Triple max HP for top ranking Taekwons over level 90.
    if ((sd->class_&MAPID_UPPERMASK) == MAPID_SUPER_NOVICE && sd->status.base_level >= 99)
        val += 2000; //Supernovice lvl99 hp bonus.

    val += val * status->vit/100; // +1% per each point of VIT

    if (sd->class_&JOBL_UPPER)
        val += val * 25/100; //Trans classes get a 25% hp bonus
    else if (sd->class_&JOBL_BABY)
        val -= val * 30/100; //Baby classes get a 30% hp penalty
    return val;
}

static unsigned int status_base_pc_maxsp(struct map_session_data *sd, struct status_data *status)
{
    unsigned int val;

    val = 10 + sd->status.base_level*sp_coefficient[pc_class2idx(sd->status.class_)]/100;
    val += val * status->int_/100;

    if (sd->class_&JOBL_UPPER)
        val += val * 25/100;
    else if (sd->class_&JOBL_BABY)
        val -= val * 30/100;
    if ((sd->class_&MAPID_UPPERMASK) == MAPID_TAEKWON && sd->status.base_level >= 90 && pc_famerank(sd->status.char_id, MAPID_TAEKWON))
        val *= 3; //Triple max SP for top ranking Taekwons over level 90.

    return val;
}

//Calculates player data from scratch without counting SC adjustments.
//Should be invoked whenever players raise stats, learn passive skills or change equipment.
int status_calc_pc_(struct map_session_data *sd, bool first)
{
    static int calculating = 0; //Check for recursive call preemption. [Skotlex]
    struct status_data *status; // pointer to the player's base status
    const struct status_change *sc = &sd->sc;
    struct s_skill b_skill[MAX_SKILL]; // previous skill tree
    int b_weight, b_max_weight, b_cart_weight_max; // previous weight
    int i,index;
    int skill,refinedef=0;

    if (++calculating > 10) //Too many recursive calls!
        return -1;

    // remember player-specific values that are currently being shown to the client (for refresh purposes)
    memcpy(b_skill, &sd->status.skill, sizeof(b_skill));
    b_weight = sd->weight;
    b_max_weight = sd->max_weight;
    b_cart_weight_max = sd->cart_weight_max;

    pc_calc_skilltree(sd);  // SkillTree calculation

    sd->max_weight = max_weight_base[pc_class2idx(sd->status.class_)]+sd->status.str*300;

    if (first) {
        //Load Hp/SP from char-received data.
        sd->battle_status.hp = sd->status.hp;
        sd->battle_status.sp = sd->status.sp;
        sd->regen.sregen = &sd->sregen;
        sd->regen.ssregen = &sd->ssregen;
        sd->weight=0;
        for (i=0; i<MAX_INVENTORY; i++) {
            if (sd->status.inventory[i].nameid==0 || sd->inventory_data[i] == NULL)
                continue;
            sd->weight += sd->inventory_data[i]->weight*sd->status.inventory[i].amount;
        }
        sd->cart_weight=0;
        sd->cart_num=0;
        for (i=0; i<MAX_CART; i++) {
            if (sd->status.cart[i].nameid==0)
                continue;
            sd->cart_weight+=itemdb_weight(sd->status.cart[i].nameid)*sd->status.cart[i].amount;
            sd->cart_num++;
        }
    }

    status = &sd->base_status;
    // these are not zeroed. [zzo]
    sd->hprate=100;
    sd->sprate=100;
    sd->castrate=100;
    sd->delayrate=100;
    sd->dsprate=100;
    sd->hprecov_rate = 100;
    sd->sprecov_rate = 100;
    sd->matk_rate = 100;
    sd->critical_rate = sd->hit_rate = sd->flee_rate = sd->flee2_rate = 100;
    sd->def_rate = sd->def2_rate = sd->mdef_rate = sd->mdef2_rate = 100;
    sd->regen.state.block = 0;

    // zeroed arrays, order follows the order in pc.h.
    // add new arrays to the end of zeroed area in pc.h (see comments) and size here. [zzo]
    memset(sd->param_bonus, 0, sizeof(sd->param_bonus)
           + sizeof(sd->param_equip)
           + sizeof(sd->subele)
           + sizeof(sd->subrace)
           + sizeof(sd->subrace2)
           + sizeof(sd->subsize)
           + sizeof(sd->reseff)
           + sizeof(sd->weapon_coma_ele)
           + sizeof(sd->weapon_coma_race)
           + sizeof(sd->weapon_atk)
           + sizeof(sd->weapon_atk_rate)
           + sizeof(sd->arrow_addele)
           + sizeof(sd->arrow_addrace)
           + sizeof(sd->arrow_addsize)
           + sizeof(sd->magic_addele)
           + sizeof(sd->magic_addrace)
           + sizeof(sd->magic_addsize)
           + sizeof(sd->critaddrace)
           + sizeof(sd->expaddrace)
           + sizeof(sd->ignore_mdef)
           + sizeof(sd->ignore_def)
           + sizeof(sd->itemgrouphealrate)
           + sizeof(sd->sp_gain_race)
           + sizeof(sd->sp_gain_race_attack)
           + sizeof(sd->hp_gain_race_attack)
          );

    memset(&sd->right_weapon.overrefine, 0, sizeof(sd->right_weapon) - sizeof(sd->right_weapon.atkmods));
    memset(&sd->left_weapon.overrefine, 0, sizeof(sd->left_weapon) - sizeof(sd->left_weapon.atkmods));

    if (sd->special_state.intravision && !sd->sc.data[SC_INTRAVISION]) //Clear intravision as long as nothing else is using it
        clif_status_load(&sd->bl, SI_INTRAVISION, 0);

    memset(&sd->special_state,0,sizeof(sd->special_state));
    memset(&status->max_hp, 0, sizeof(struct status_data)-(sizeof(status->hp)+sizeof(status->sp)));

    //FIXME: Most of these stuff should be calculated once, but how do I fix the memset above to do that? [Skotlex]
    status->speed = DEFAULT_WALK_SPEED;
    //Give them all modes except these (useful for clones)
    status->mode = MD_MASK&~(MD_BOSS|MD_PLANT|MD_DETECTOR|MD_ANGRY|MD_TARGETWEAK);

    status->size = (sd->class_&JOBL_BABY)?SZ_SMALL:SZ_MEDIUM;
    if (battle_config.character_size && pc_isriding(sd)) { //[Lupus]
        if (sd->class_&JOBL_BABY) {
            if (battle_config.character_size&SZ_BIG)
                status->size++;
        } else if (battle_config.character_size&SZ_MEDIUM)
            status->size++;
    }
    status->aspd_rate = 1000;
    status->ele_lv = 1;
    status->race = RC_DEMIHUMAN;

    //zero up structures...
    memset(&sd->autospell,0,sizeof(sd->autospell)
           + sizeof(sd->autospell2)
           + sizeof(sd->autospell3)
           + sizeof(sd->addeff)
           + sizeof(sd->addeff2)
           + sizeof(sd->addeff3)
           + sizeof(sd->skillatk)
           + sizeof(sd->skillusesprate)
           + sizeof(sd->skillusesp)
           + sizeof(sd->skillheal)
           + sizeof(sd->skillheal2)
           + sizeof(sd->hp_loss)
           + sizeof(sd->sp_loss)
           + sizeof(sd->hp_regen)
           + sizeof(sd->sp_regen)
           + sizeof(sd->skillblown)
           + sizeof(sd->skillcast)
           + sizeof(sd->add_def)
           + sizeof(sd->add_mdef)
           + sizeof(sd->add_mdmg)
           + sizeof(sd->add_drop)
           + sizeof(sd->itemhealrate)
           + sizeof(sd->subele2)
           + sizeof(sd->skillcooldown)
           + sizeof(sd->skillfixcast)
           + sizeof(sd->skillvarcast)
          );

    memset(&sd->bonus, 0,sizeof(sd->bonus));

    // Autobonus
    pc_delautobonus(sd,sd->autobonus,ARRAYLENGTH(sd->autobonus),true);
    pc_delautobonus(sd,sd->autobonus2,ARRAYLENGTH(sd->autobonus2),true);
    pc_delautobonus(sd,sd->autobonus3,ARRAYLENGTH(sd->autobonus3),true);

    // Parse equipment.
    for (i=0; i<EQI_MAX-1; i++) {
        current_equip_item_index = index = sd->equip_index[i]; //We pass INDEX to current_equip_item_index - for EQUIP_SCRIPT (new cards solution) [Lupus]
        if (index < 0)
            continue;
        if (i == EQI_HAND_R && sd->equip_index[EQI_HAND_L] == index)
            continue;
        if (i == EQI_HEAD_MID && sd->equip_index[EQI_HEAD_LOW] == index)
            continue;
        if (i == EQI_HEAD_TOP && (sd->equip_index[EQI_HEAD_MID] == index || sd->equip_index[EQI_HEAD_LOW] == index))
            continue;
        if (i == EQI_COSTUME_MID && sd->equip_index[EQI_COSTUME_LOW] == index)
            continue;
        if (i == EQI_COSTUME_TOP && (sd->equip_index[EQI_COSTUME_MID] == index || sd->equip_index[EQI_COSTUME_LOW] == index))
            continue;
        if (!sd->inventory_data[index])
            continue;

        status->def += sd->inventory_data[index]->def;

        if (first && sd->inventory_data[index]->equip_script) {
            //Execute equip-script on login
            run_script(sd->inventory_data[index]->equip_script,0,sd->bl.id,0);
            if (!calculating)
                return 1;
        }

        // sanitize the refine level in case someone decreased the value inbetween
        if (sd->status.inventory[index].refine > MAX_REFINE)
            sd->status.inventory[index].refine = MAX_REFINE;

        if (sd->inventory_data[index]->type == IT_WEAPON) {
            int r,wlv = sd->inventory_data[index]->wlv;
            struct weapon_data *wd;
            struct weapon_atk *wa;
            if (wlv >= REFINE_TYPE_MAX)
                wlv = REFINE_TYPE_MAX - 1;
            if (i == EQI_HAND_L && sd->status.inventory[index].equip == EQP_HAND_L) {
                wd = &sd->left_weapon; // Left-hand weapon
                wa = &status->lhw;
            } else {
                wd = &sd->right_weapon;
                wa = &status->rhw;
            }
            wa->atk += sd->inventory_data[index]->atk;
            if ((r = sd->status.inventory[index].refine))
                wa->atk2 = refine_info[wlv].bonus[r-1] / 100;

#ifdef RENEWAL
            wa->matk += sd->inventory_data[index]->matk;
            wa->wlv = wlv;
            if( r ) // renewal magic attack refine bonus
                wa->matk += refine_info[wlv].bonus[r-1] / 100;
#endif

            //Overrefine bonus.
            if (r)
                wd->overrefine = refine_info[wlv].randombonus_max[r-1] / 100;

            wa->range += sd->inventory_data[index]->range;
            if (sd->inventory_data[index]->script) {
                if (wd == &sd->left_weapon) {
                    sd->state.lr_flag = 1;
                    run_script(sd->inventory_data[index]->script,0,sd->bl.id,0);
                    sd->state.lr_flag = 0;
                } else
                    run_script(sd->inventory_data[index]->script,0,sd->bl.id,0);
                if (!calculating) //Abort, run_script retriggered this. [Skotlex]
                    return 1;
            }

            if (sd->status.inventory[index].card[0]==CARD0_FORGE) {
                // Forged weapon
                wd->star += (sd->status.inventory[index].card[1]>>8);
                if (wd->star >= 15) wd->star = 40; // 3 Star Crumbs now give +40 dmg
                if (pc_famerank(MakeDWord(sd->status.inventory[index].card[2],sd->status.inventory[index].card[3]) ,MAPID_BLACKSMITH))
                    wd->star += 10;

                if (!wa->ele) //Do not overwrite element from previous bonuses.
                    wa->ele = (sd->status.inventory[index].card[1]&0x0f);
            }
        } else if (sd->inventory_data[index]->type == IT_ARMOR) {
            int r;
            if ((r = sd->status.inventory[index].refine))
                refinedef += refine_info[REFINE_TYPE_ARMOR].bonus[r-1];
            if (sd->inventory_data[index]->script) {
                if (i == EQI_HAND_L)  //Shield
                    sd->state.lr_flag = 3;
                run_script(sd->inventory_data[index]->script,0,sd->bl.id,0);
                if (i == EQI_HAND_L)  //Shield
                    sd->state.lr_flag = 0;
                if (!calculating) //Abort, run_script retriggered this. [Skotlex]
                    return 1;
            }
        }
    }

    if (sd->equip_index[EQI_AMMO] >= 0) {
        index = sd->equip_index[EQI_AMMO];
        if (sd->inventory_data[index]) {    // Arrows
            sd->bonus.arrow_atk += sd->inventory_data[index]->atk;
            sd->state.lr_flag = 2;
            if (!itemdb_is_GNthrowable(sd->inventory_data[index]->nameid))  //don't run scripts on throwable items
                run_script(sd->inventory_data[index]->script,0,sd->bl.id,0);
            sd->state.lr_flag = 0;
            if (!calculating) //Abort, run_script retriggered status_calc_pc. [Skotlex]
                return 1;
        }
    }

    /* we've got combos to process */
    if (sd->combos.count) {
        for (i = 0; i < sd->combos.count; i++) {
            run_script(sd->combos.bonus[i],0,sd->bl.id,0);
            if (!calculating) //Abort, run_script retriggered this.
                return 1;
        }
    }

    //Store equipment script bonuses
    memcpy(sd->param_equip,sd->param_bonus,sizeof(sd->param_equip));
    memset(sd->param_bonus, 0, sizeof(sd->param_bonus));

    status->def += (refinedef+50)/100;

    //Parse Cards
    for (i=0; i<EQI_MAX-1; i++) {
        current_equip_item_index = index = sd->equip_index[i]; //We pass INDEX to current_equip_item_index - for EQUIP_SCRIPT (new cards solution) [Lupus]
        if (index < 0)
            continue;
        if (i == EQI_HAND_R && sd->equip_index[EQI_HAND_L] == index)
            continue;
        if (i == EQI_HEAD_MID && sd->equip_index[EQI_HEAD_LOW] == index)
            continue;
        if (i == EQI_HEAD_TOP && (sd->equip_index[EQI_HEAD_MID] == index || sd->equip_index[EQI_HEAD_LOW] == index))
            continue;

        if (sd->inventory_data[index]) {
            int j,c;
            struct item_data *data;

            //Card script execution.
            if (itemdb_isspecial(sd->status.inventory[index].card[0]))
                continue;
            for (j=0; j<MAX_SLOTS; j++) { // Uses MAX_SLOTS to support Soul Bound system [Inkfish]
                current_equip_card_id= c= sd->status.inventory[index].card[j];
                if (!c)
                    continue;
                data = itemdb_exists(c);
                if (!data)
                    continue;
                if (first && data->equip_script) {
                    //Execute equip-script on login
                    run_script(data->equip_script,0,sd->bl.id,0);
                    if (!calculating)
                        return 1;
                }
                if (!data->script)
                    continue;
                if (data->flag.no_equip) { //Card restriction checks.
                    if (map[sd->bl.m].flag.restricted && data->flag.no_equip&(8*map[sd->bl.m].zone))
                        continue;
                    if (!map_flag_vs(sd->bl.m) && data->flag.no_equip&1)
                        continue;
                    if (map[sd->bl.m].flag.pvp && data->flag.no_equip&2)
                        continue;
                    if (map_flag_gvg(sd->bl.m) && data->flag.no_equip&4)
                        continue;
                    if (map[sd->bl.m].flag.battleground && data->flag.no_equip&8)
                        continue;
                }
                if (i == EQI_HAND_L && sd->status.inventory[index].equip == EQP_HAND_L) {
                    //Left hand status.
                    sd->state.lr_flag = 1;
                    run_script(data->script,0,sd->bl.id,0);
                    sd->state.lr_flag = 0;
                } else
                    run_script(data->script,0,sd->bl.id,0);
                if (!calculating) //Abort, run_script his function. [Skotlex]
                    return 1;
            }
        }
    }

    if (sc->count && sc->data[SC_ITEMSCRIPT]) {
        struct item_data *data = itemdb_exists(sc->data[SC_ITEMSCRIPT]->val1);
        if (data && data->script)
            run_script(data->script,0,sd->bl.id,0);
    }

    if (sd->pd) {
        // Pet Bonus
        struct pet_data *pd = sd->pd;
        if (pd && pd->petDB && pd->petDB->equip_script && pd->pet.intimate >= battle_config.pet_equip_min_friendly)
            run_script(pd->petDB->equip_script,0,sd->bl.id,0);
        if (pd && pd->pet.intimate > 0 && (!battle_config.pet_equip_required || pd->pet.equip > 0) && pd->state.skillbonus == 1 && pd->bonus)
            pc_bonus(sd,pd->bonus->type, pd->bonus->val);
    }

    //param_bonus now holds card bonuses.
    if (status->rhw.range < 1) status->rhw.range = 1;
    if (status->lhw.range < 1) status->lhw.range = 1;
    if (status->rhw.range < status->lhw.range)
        status->rhw.range = status->lhw.range;

    sd->bonus.double_rate += sd->bonus.double_add_rate;
    sd->bonus.perfect_hit += sd->bonus.perfect_hit_add;
    sd->bonus.splash_range += sd->bonus.splash_add_range;

    // Damage modifiers from weapon type
    sd->right_weapon.atkmods[0] = atkmods[0][sd->weapontype1];
    sd->right_weapon.atkmods[1] = atkmods[1][sd->weapontype1];
    sd->right_weapon.atkmods[2] = atkmods[2][sd->weapontype1];
    sd->left_weapon.atkmods[0] = atkmods[0][sd->weapontype2];
    sd->left_weapon.atkmods[1] = atkmods[1][sd->weapontype2];
    sd->left_weapon.atkmods[2] = atkmods[2][sd->weapontype2];

    if (pc_isriding(sd) &&
        (sd->status.weapon==W_1HSPEAR || sd->status.weapon==W_2HSPEAR)) {
        //When Riding with spear, damage modifier to mid-class becomes
        //same as versus large size.
        sd->right_weapon.atkmods[1] = sd->right_weapon.atkmods[2];
        sd->left_weapon.atkmods[1] = sd->left_weapon.atkmods[2];
    }

    // ----- STATS CALCULATION -----

    // Job bonuses
    index = pc_class2idx(sd->status.class_);
    for (i=0; i<(int)sd->status.job_level && i<MAX_LEVEL; i++) {
        if (!job_bonus[index][i])
            continue;
        switch (job_bonus[index][i]) {
            case 1:
                status->str++;
                break;
            case 2:
                status->agi++;
                break;
            case 3:
                status->vit++;
                break;
            case 4:
                status->int_++;
                break;
            case 5:
                status->dex++;
                break;
            case 6:
                status->luk++;
                break;
        }
    }

    // If a Super Novice has never died and is at least joblv 70, he gets all stats +10
    if ((sd->class_&MAPID_UPPERMASK) == MAPID_SUPER_NOVICE && sd->die_counter == 0 && sd->status.job_level >= 70) {
        status->str += 10;
        status->agi += 10;
        status->vit += 10;
        status->int_+= 10;
        status->dex += 10;
        status->luk += 10;
    }

    // Absolute modifiers from passive skills
    if (pc_checkskill(sd,BS_HILTBINDING)>0)
        status->str++;
    if ((skill=pc_checkskill(sd,SA_DRAGONOLOGY))>0)
        status->int_ += (skill+1)/2; // +1 INT / 2 lv
    if ((skill=pc_checkskill(sd,AC_OWL))>0)
        status->dex += skill;
    if ((skill = pc_checkskill(sd,RA_RESEARCHTRAP))>0)
        status->int_ += skill;

    // Bonuses from cards and equipment as well as base stat, remember to avoid overflows.
    i = status->str + sd->status.str + sd->param_bonus[0] + sd->param_equip[0];
    status->str = cap_value(i,0,USHRT_MAX);
    i = status->agi + sd->status.agi + sd->param_bonus[1] + sd->param_equip[1];
    status->agi = cap_value(i,0,USHRT_MAX);
    i = status->vit + sd->status.vit + sd->param_bonus[2] + sd->param_equip[2];
    status->vit = cap_value(i,0,USHRT_MAX);
    i = status->int_+ sd->status.int_+ sd->param_bonus[3] + sd->param_equip[3];
    status->int_ = cap_value(i,0,USHRT_MAX);
    i = status->dex + sd->status.dex + sd->param_bonus[4] + sd->param_equip[4];
    status->dex = cap_value(i,0,USHRT_MAX);
    i = status->luk + sd->status.luk + sd->param_bonus[5] + sd->param_equip[5];
    status->luk = cap_value(i,0,USHRT_MAX);

    // ------ BASE ATTACK CALCULATION ------

    // Base batk value is set on status_calc_misc
    // weapon-type bonus (FIXME: Why is the weapon_atk bonus applied to base attack?)
    if (sd->status.weapon < MAX_WEAPON_TYPE && sd->weapon_atk[sd->status.weapon])
        status->batk += sd->weapon_atk[sd->status.weapon];
    // Absolute modifiers from passive skills
    if ((skill=pc_checkskill(sd,BS_HILTBINDING))>0)
        status->batk += 4;

    // ----- HP MAX CALCULATION -----

    // Basic MaxHP value
    //We hold the standard Max HP here to make it faster to recalculate on vit changes.
    sd->status.max_hp = status_base_pc_maxhp(sd,status);
    //This is done to handle underflows from negative Max HP bonuses
    i = sd->status.max_hp + (int)status->max_hp;
    status->max_hp = cap_value(i, 0, INT_MAX);

    // Absolute modifiers from passive skills
    if ((skill=pc_checkskill(sd,CR_TRUST))>0)
        status->max_hp += skill*200;

    // Apply relative modifiers from equipment
    if (sd->hprate < 0)
        sd->hprate = 0;
    if (sd->hprate!=100)
        status->max_hp = status->max_hp * sd->hprate/100;
    if (battle_config.hp_rate != 100)
        status->max_hp = status->max_hp * battle_config.hp_rate/100;

    if (status->max_hp > (unsigned int)battle_config.max_hp)
        status->max_hp = battle_config.max_hp;
    else if (!status->max_hp)
        status->max_hp = 1;

    // ----- SP MAX CALCULATION -----

    // Basic MaxSP value
    sd->status.max_sp = status_base_pc_maxsp(sd,status);
    //This is done to handle underflows from negative Max SP bonuses
    i = sd->status.max_sp + (int)status->max_sp;
    status->max_sp = cap_value(i, 0, INT_MAX);

    // Absolute modifiers from passive skills
    if ((skill=pc_checkskill(sd,SL_KAINA))>0)
        status->max_sp += 30*skill;
    if ((skill=pc_checkskill(sd,HP_MEDITATIO))>0)
        status->max_sp += status->max_sp * skill/100;
    if ((skill=pc_checkskill(sd,HW_SOULDRAIN))>0)
        status->max_sp += status->max_sp * 2*skill/100;
    if ((skill = pc_checkskill(sd,RA_RESEARCHTRAP)) > 0)
        status->max_sp += 200 + 20 * skill;
    if ((skill = pc_checkskill(sd,WM_LESSON)) > 0)
        status->max_sp += 30 * skill;


    // Apply relative modifiers from equipment
    if (sd->sprate < 0)
        sd->sprate = 0;
    if (sd->sprate!=100)
        status->max_sp = status->max_sp * sd->sprate/100;
    if (battle_config.sp_rate != 100)
        status->max_sp = status->max_sp * battle_config.sp_rate/100;

    if (status->max_sp > (unsigned int)battle_config.max_sp)
        status->max_sp = battle_config.max_sp;
    else if (!status->max_sp)
        status->max_sp = 1;

    // ----- RESPAWN HP/SP -----
    //
    //Calc respawn hp and store it on base_status
    if (sd->special_state.restart_full_recover) {
        status->hp = status->max_hp;
        status->sp = status->max_sp;
    } else {
        if ((sd->class_&MAPID_BASEMASK) == MAPID_NOVICE && !(sd->class_&JOBL_2)
            && battle_config.restart_hp_rate < 50)
            status->hp=status->max_hp>>1;
        else
            status->hp=status->max_hp * battle_config.restart_hp_rate/100;
        if (!status->hp)
            status->hp = 1;

        status->sp = status->max_sp * battle_config.restart_sp_rate /100;

        if (!status->sp)  /* the minimum for the respawn setting is SP:1 */
            status->sp = 1;
    }

    // ----- MISC CALCULATION -----
    status_calc_misc(&sd->bl, status, sd->status.base_level);

    //Equipment modifiers for misc settings
    if (sd->matk_rate < 0)
        sd->matk_rate = 0;

    if (sd->matk_rate != 100) {
        status->matk_max = status->matk_max * sd->matk_rate/100;
        status->matk_min = status->matk_min * sd->matk_rate/100;
    }

    if (sd->hit_rate < 0)
        sd->hit_rate = 0;
    if (sd->hit_rate != 100)
        status->hit = status->hit * sd->hit_rate/100;

    if (sd->flee_rate < 0)
        sd->flee_rate = 0;
    if (sd->flee_rate != 100)
        status->flee = status->flee * sd->flee_rate/100;

    if (sd->def2_rate < 0)
        sd->def2_rate = 0;
    if (sd->def2_rate != 100)
        status->def2 = status->def2 * sd->def2_rate/100;

    if (sd->mdef2_rate < 0)
        sd->mdef2_rate = 0;
    if (sd->mdef2_rate != 100)
        status->mdef2 = status->mdef2 * sd->mdef2_rate/100;

    if (sd->critical_rate < 0)
        sd->critical_rate = 0;
    if (sd->critical_rate != 100)
        status->cri = status->cri * sd->critical_rate/100;

    if (sd->flee2_rate < 0)
        sd->flee2_rate = 0;
    if (sd->flee2_rate != 100)
        status->flee2 = status->flee2 * sd->flee2_rate/100;

    // ----- HIT CALCULATION -----

    // Absolute modifiers from passive skills
    if ((skill=pc_checkskill(sd,BS_WEAPONRESEARCH))>0)
        status->hit += skill*2;
    if ((skill=pc_checkskill(sd,AC_VULTURE))>0) {
#ifndef RENEWAL
        status->hit += skill;
#endif
        if (sd->status.weapon == W_BOW)
            status->rhw.range += skill;
    }
    if (sd->status.weapon >= W_REVOLVER && sd->status.weapon <= W_GRENADE) {
        if ((skill=pc_checkskill(sd,GS_SINGLEACTION))>0)
            status->hit += 2*skill;
        if ((skill=pc_checkskill(sd,GS_SNAKEEYE))>0) {
            status->hit += skill;
            status->rhw.range += skill;
        }
    }

    // ----- FLEE CALCULATION -----

    // Absolute modifiers from passive skills
    if ((skill=pc_checkskill(sd,TF_MISS))>0)
        status->flee += skill*(sd->class_&JOBL_2 && (sd->class_&MAPID_BASEMASK) == MAPID_THIEF? 4 : 3);
    if ((skill=pc_checkskill(sd,MO_DODGE))>0)
        status->flee += (skill*3)>>1;
    // ----- EQUIPMENT-DEF CALCULATION -----

    // Apply relative modifiers from equipment
    if (sd->def_rate < 0)
        sd->def_rate = 0;
    if (sd->def_rate != 100) {
        i =  status->def * sd->def_rate/100;
        status->def = cap_value(i, DEFTYPE_MIN, DEFTYPE_MAX);
    }

#ifndef RENEWAL
    if (!battle_config.weapon_defense_type && status->def > battle_config.max_def) {
        status->def2 += battle_config.over_def_bonus*(status->def -battle_config.max_def);
        status->def = (unsigned char)battle_config.max_def;
    }
#endif

    // ----- EQUIPMENT-MDEF CALCULATION -----

    // Apply relative modifiers from equipment
    if (sd->mdef_rate < 0)
        sd->mdef_rate = 0;
    if (sd->mdef_rate != 100) {
        i =  status->mdef * sd->mdef_rate/100;
        status->mdef = cap_value(i, DEFTYPE_MIN, DEFTYPE_MAX);
    }

#ifndef RENEWAL
    if (!battle_config.magic_defense_type && status->mdef > battle_config.max_def) {
        status->mdef2 += battle_config.over_def_bonus*(status->mdef -battle_config.max_def);
        status->mdef = (signed char)battle_config.max_def;
    }
#endif

    // ----- ASPD CALCULATION -----
    // Unlike other stats, ASPD rate modifiers from skills/SCs/items/etc are first all added together, then the final modifier is applied

    // Basic ASPD value
    i = status_base_amotion_pc(sd,status);
    status->amotion = cap_value(i,((sd->class_&JOBL_THIRD) ? battle_config.max_third_aspd : battle_config.max_aspd),2000);

    // Relative modifiers from passive skills
#ifndef RENEWAL_ASPD
    if ((skill=pc_checkskill(sd,SA_ADVANCEDBOOK))>0 && sd->status.weapon == W_BOOK)
        status->aspd_rate -= 5*skill;
    if ((skill = pc_checkskill(sd,SG_DEVIL)) > 0 && !pc_nextjobexp(sd))
        status->aspd_rate -= 30*skill;
    if ((skill=pc_checkskill(sd,GS_SINGLEACTION))>0 &&
        (sd->status.weapon >= W_REVOLVER && sd->status.weapon <= W_GRENADE))
        status->aspd_rate -= ((skill+1)/2) * 10;
    if (pc_isriding(sd))
        status->aspd_rate += 500-100*pc_checkskill(sd,KN_CAVALIERMASTERY);
    else if (pc_isridingdragon(sd))
        status->aspd_rate += 250-50*pc_checkskill(sd,RK_DRAGONTRAINING);
#else // needs more info
    if ((skill=pc_checkskill(sd,SA_ADVANCEDBOOK))>0 && sd->status.weapon == W_BOOK)
        status->aspd_rate += 5*skill;
    if ((skill = pc_checkskill(sd,SG_DEVIL)) > 0 && !pc_nextjobexp(sd))
        status->aspd_rate += 30*skill;
    if ((skill=pc_checkskill(sd,GS_SINGLEACTION))>0 &&
        (sd->status.weapon >= W_REVOLVER && sd->status.weapon <= W_GRENADE))
        status->aspd_rate += ((skill+1)/2) * 10;
    if (pc_isriding(sd))
        status->aspd_rate -= 500-100*pc_checkskill(sd,KN_CAVALIERMASTERY);
    else if (pc_isridingdragon(sd))
        status->aspd_rate -= 250-50*pc_checkskill(sd,RK_DRAGONTRAINING);
#endif
    status->adelay = 2*status->amotion;


    // ----- DMOTION -----
    //
    i =  800-status->agi*4;
    status->dmotion = cap_value(i, 400, 800);
    if (battle_config.pc_damage_delay_rate != 100)
        status->dmotion = status->dmotion*battle_config.pc_damage_delay_rate/100;

    // ----- MISC CALCULATIONS -----

    // Weight
    if ((skill=pc_checkskill(sd,MC_INCCARRY))>0)
        sd->max_weight += 2000*skill;
    if (pc_isriding(sd) && pc_checkskill(sd,KN_RIDING)>0)
        sd->max_weight += 10000;
    else if (pc_isridingdragon(sd))
        sd->max_weight += 5000+2000*pc_checkskill(sd,RK_DRAGONTRAINING);
    if (sc->data[SC_KNOWLEDGE])
        sd->max_weight += sd->max_weight*sc->data[SC_KNOWLEDGE]->val1/10;
    if ((skill=pc_checkskill(sd,ALL_INCCARRY))>0)
        sd->max_weight += 2000*skill;

    sd->cart_weight_max = battle_config.max_cart_weight + (pc_checkskill(sd, GN_REMODELING_CART)*5000);

    if (pc_checkskill(sd,SM_MOVINGRECOVERY)>0)
        sd->regen.state.walk = 1;
    else
        sd->regen.state.walk = 0;

    // Skill SP cost
    if ((skill=pc_checkskill(sd,HP_MANARECHARGE))>0)
        sd->dsprate -= 4*skill;

    if (sc->data[SC_SERVICE4U])
        sd->dsprate -= sc->data[SC_SERVICE4U]->val3;

    if (sc->data[SC_SPCOST_RATE])
        sd->dsprate -= sc->data[SC_SPCOST_RATE]->val1;

    //Underflow protections.
    if (sd->dsprate < 0)
        sd->dsprate = 0;
    if (sd->castrate < 0)
        sd->castrate = 0;
    if (sd->delayrate < 0)
        sd->delayrate = 0;
    if (sd->hprecov_rate < 0)
        sd->hprecov_rate = 0;
    if (sd->sprecov_rate < 0)
        sd->sprecov_rate = 0;

    // Anti-element and anti-race
    if ((skill=pc_checkskill(sd,CR_TRUST))>0)
        sd->subele[ELE_HOLY] += skill*5;
    if ((skill=pc_checkskill(sd,BS_SKINTEMPER))>0) {
        sd->subele[ELE_NEUTRAL] += skill;
        sd->subele[ELE_FIRE] += skill*4;
    }
    if ((skill=pc_checkskill(sd,SA_DRAGONOLOGY))>0) {
        skill = skill*4;
        sd->right_weapon.addrace[RC_DRAGON]+=skill;
        sd->left_weapon.addrace[RC_DRAGON]+=skill;
        sd->magic_addrace[RC_DRAGON]+=skill;
        sd->subrace[RC_DRAGON]+=skill;
    }

    if (sc->count) {
        if (sc->data[SC_CONCENTRATE]) { //Update the card-bonus data
            sc->data[SC_CONCENTRATE]->val3 = sd->param_bonus[1]; //Agi
            sc->data[SC_CONCENTRATE]->val4 = sd->param_bonus[4]; //Dex
        }
        if (sc->data[SC_SIEGFRIED]) {
            i = sc->data[SC_SIEGFRIED]->val2;
            sd->subele[ELE_WATER] += i;
            sd->subele[ELE_EARTH] += i;
            sd->subele[ELE_FIRE] += i;
            sd->subele[ELE_WIND] += i;
            sd->subele[ELE_POISON] += i;
            sd->subele[ELE_HOLY] += i;
            sd->subele[ELE_DARK] += i;
            sd->subele[ELE_GHOST] += i;
            sd->subele[ELE_UNDEAD] += i;
        }
        if (sc->data[SC_PROVIDENCE]) {
            sd->subele[ELE_HOLY] += sc->data[SC_PROVIDENCE]->val2;
            sd->subrace[RC_DEMON] += sc->data[SC_PROVIDENCE]->val2;
        }
        if (sc->data[SC_ARMOR_ELEMENT]) {   //This status change should grant card-type elemental resist.
            sd->subele[ELE_WATER] += sc->data[SC_ARMOR_ELEMENT]->val1;
            sd->subele[ELE_EARTH] += sc->data[SC_ARMOR_ELEMENT]->val2;
            sd->subele[ELE_FIRE] += sc->data[SC_ARMOR_ELEMENT]->val3;
            sd->subele[ELE_WIND] += sc->data[SC_ARMOR_ELEMENT]->val4;
        }
        if (sc->data[SC_ARMOR_RESIST]) { // Undead Scroll
            sd->subele[ELE_WATER] += sc->data[SC_ARMOR_RESIST]->val1;
            sd->subele[ELE_EARTH] += sc->data[SC_ARMOR_RESIST]->val2;
            sd->subele[ELE_FIRE] += sc->data[SC_ARMOR_RESIST]->val3;
            sd->subele[ELE_WIND] += sc->data[SC_ARMOR_RESIST]->val4;
        }
        if (sc->data[SC_FIRE_CLOAK_OPTION]) {
            i = sc->data[SC_FIRE_CLOAK_OPTION]->val2;
            sd->subele[ELE_FIRE] += i;
            sd->subele[ELE_EARTH] -= i;
        }
        if (sc->data[SC_WATER_DROP_OPTION]) {
            i = sc->data[SC_WATER_DROP_OPTION]->val2;
            sd->subele[ELE_WATER] += i;
            sd->subele[ELE_WIND] -= i;
        }
        if (sc->data[SC_WIND_CURTAIN_OPTION]) {
            i = sc->data[SC_WIND_CURTAIN_OPTION]->val2;
            sd->subele[ELE_WIND] += i;
            sd->subele[ELE_WATER] -= i;
        }
        if (sc->data[SC_STONE_SHIELD_OPTION]) {
            i = sc->data[SC_STONE_SHIELD_OPTION]->val2;
            sd->subele[ELE_EARTH] += i;
            sd->subele[ELE_FIRE] -= i;
        }
        if (sc->data[SC_FIRE_INSIGNIA] && sc->data[SC_FIRE_INSIGNIA]->val1 == 3)
            sd->magic_addele[ELE_FIRE] += 25;
        if (sc->data[SC_WATER_INSIGNIA] && sc->data[SC_WATER_INSIGNIA]->val1 == 3)
            sd->magic_addele[ELE_WATER] += 25;
        if (sc->data[SC_WIND_INSIGNIA] && sc->data[SC_WIND_INSIGNIA]->val1 == 3)
            sd->magic_addele[ELE_WIND] += 25;
        if (sc->data[SC_EARTH_INSIGNIA] && sc->data[SC_EARTH_INSIGNIA]->val1 == 3)
            sd->magic_addele[ELE_EARTH] += 25;
    }
    status_cpy(&sd->battle_status, status);

    // ----- CLIENT-SIDE REFRESH -----
    if (!sd->bl.prev) {
        //Will update on LoadEndAck
        calculating = 0;
        return 0;
    }
    if (memcmp(b_skill,sd->status.skill,sizeof(sd->status.skill)))
        clif_skillinfoblock(sd);
    if (b_weight != sd->weight)
        clif_updatestatus(sd,SP_WEIGHT);
    if (b_max_weight != sd->max_weight) {
        clif_updatestatus(sd,SP_MAXWEIGHT);
        pc_updateweightstatus(sd);
    }
    if (b_cart_weight_max != sd->cart_weight_max) {
        clif_updatestatus(sd,SP_CARTINFO);
    }

    calculating = 0;

    return 0;
}

int status_calc_mercenary_(struct mercenary_data *md, bool first)
{
    struct status_data *status = &md->base_status;
    struct s_mercenary *merc = &md->mercenary;

    if (first) {
        memcpy(status, &md->db->status, sizeof(struct status_data));
        status->mode = MD_CANMOVE|MD_CANATTACK;
        status->hp = status->max_hp;
        status->sp = status->max_sp;
        md->battle_status.hp = merc->hp;
        md->battle_status.sp = merc->sp;
    }

    status_calc_misc(&md->bl, status, md->db->lv);
    status_cpy(&md->battle_status, status);

    return 0;
}

int status_calc_homunculus_(struct homun_data *hd, bool first)
{
    struct status_data *status = &hd->base_status;
    struct s_homunculus *hom = &hd->homunculus;
    int skill;
    int amotion;

    status->str = hom->str / 10;
    status->agi = hom->agi / 10;
    status->vit = hom->vit / 10;
    status->dex = hom->dex / 10;
    status->int_ = hom->int_ / 10;
    status->luk = hom->luk / 10;

    if (first) {    //[orn]
        const struct s_homunculus_db *db = hd->homunculusDB;
        status->def_ele =  db->element;
        status->ele_lv = 1;
        status->race = db->race;
        status->size = (hom->class_ == db->evo_class)?db->evo_size:db->base_size;
        status->rhw.range = 1 + status->size;
        status->mode = MD_CANMOVE|MD_CANATTACK;
        status->speed = DEFAULT_WALK_SPEED;
        if (battle_config.hom_setting&0x8 && hd->master)
            status->speed = status_get_speed(&hd->master->bl);

        status->hp = 1;
        status->sp = 1;
    }
    skill = hom->level/10 + status->vit/5;
    status->def = cap_value(skill, 0, 99);

    skill = hom->level/10 + status->int_/5;
    status->mdef = cap_value(skill, 0, 99);

    status->max_hp = hom->max_hp ;
    status->max_sp = hom->max_sp ;

    merc_hom_calc_skilltree(hd, 0);

    if ((skill=merc_hom_checkskill(hd,HAMI_SKIN)) > 0)
        status->def +=  skill * 4;

    if ((skill = merc_hom_checkskill(hd,HVAN_INSTRUCT)) > 0) {
        status->int_ += 1 +skill/2 +skill/4 +skill/5;
        status->str  += 1 +skill/3 +skill/3 +skill/4;
    }

    if ((skill=merc_hom_checkskill(hd,HAMI_SKIN)) > 0)
        status->max_hp += skill * 2 * status->max_hp / 100;

    if ((skill = merc_hom_checkskill(hd,HLIF_BRAIN)) > 0)
        status->max_sp += (1 +skill/2 -skill/4 +skill/5) * status->max_sp / 100 ;

    if (first) {
        hd->battle_status.hp = hom->hp ;
        hd->battle_status.sp = hom->sp ;
    }

    status->rhw.atk = status->dex;
    status->rhw.atk2 = status->str + hom->level;

    status->aspd_rate = 1000;

    amotion = (1000 -4*status->agi -status->dex) * hd->homunculusDB->baseASPD/1000;
    status->amotion = cap_value(amotion,battle_config.max_aspd,2000);
    status->adelay = status->amotion; //It seems adelay = amotion for Homunculus.

    status_calc_misc(&hd->bl, status, hom->level);

#ifdef RENEWAL
    status->matk_max = status->matk_min;
#endif

    status_cpy(&hd->battle_status, status);
    return 1;
}

int status_calc_elemental_(struct elemental_data *ed, bool first)
{
    struct status_data *status = &ed->base_status;
    struct s_elemental *ele = &ed->elemental;
    struct map_session_data *sd = ed->master;

    if (!sd)
        return 0;

    status->str = ele->str;
    status->agi = ele->agi;
    status->vit = ele->vit;
    status->dex = ele->dex;
    status->int_ = ele->int_;
    status->luk = ele->luk;

    if (first) {
        memcpy(status, &ed->db->status, sizeof(struct status_data));
        status->mode = MD_CANMOVE|MD_CANATTACK;
        status->max_hp += 4000 + 500 * pc_checkskill(sd,SO_EL_SYMPATHY);
        status->max_sp += 300 + 50 * pc_checkskill(sd,SO_EL_SYMPATHY);
        status->hp = status->max_hp;
        status->sp = status->max_sp;
        status->str += sd->base_status.str * 25 / 100;
        status->agi += sd->base_status.agi * 25 / 100;
        status->vit += sd->base_status.vit * 25 / 100;
        status->int_ += sd->base_status.int_ * 25 / 100;
        status->def += sd->base_status.dex * 25 / 100;
        status->luk += sd->base_status.luk * 25 / 100;

        status_calc_misc(&ed->bl, status, ed->db->lv);
        memcpy(&ed->battle_status,status,sizeof(struct status_data));
    } else {
        status_calc_misc(&ed->bl, status, ed->db->lv);
        status_cpy(&ed->battle_status, status);
    }

    return 0;
}

static unsigned short status_calc_str(struct block_list *,struct status_change *,int);
static unsigned short status_calc_agi(struct block_list *,struct status_change *,int);
static unsigned short status_calc_vit(struct block_list *,struct status_change *,int);
static unsigned short status_calc_int(struct block_list *,struct status_change *,int);
static unsigned short status_calc_dex(struct block_list *,struct status_change *,int);
static unsigned short status_calc_luk(struct block_list *,struct status_change *,int);
static unsigned short status_calc_batk(struct block_list *,struct status_change *,int);
static unsigned short status_calc_watk(struct block_list *,struct status_change *,int);
static unsigned short status_calc_matk(struct block_list *,struct status_change *,int);
static signed short status_calc_hit(struct block_list *,struct status_change *,int);
static signed short status_calc_critical(struct block_list *,struct status_change *,int);
static signed short status_calc_flee(struct block_list *,struct status_change *,int);
static signed short status_calc_flee2(struct block_list *,struct status_change *,int);
static defType status_calc_def(struct block_list *bl, struct status_change *sc, int);
static signed short status_calc_def2(struct block_list *,struct status_change *,int);
static defType status_calc_mdef(struct block_list *bl, struct status_change *sc, int);
static signed short status_calc_mdef2(struct block_list *,struct status_change *,int);
static unsigned short status_calc_speed(struct block_list *,struct status_change *,int);
static short status_calc_aspd_rate(struct block_list *,struct status_change *,int);
static unsigned short status_calc_dmotion(struct block_list *bl, struct status_change *sc, int dmotion);
#ifdef RENEWAL_ASPD
static short status_calc_aspd(struct block_list *bl, struct status_change *sc, short flag);
#endif
static short status_calc_fix_aspd(struct block_list *bl, struct status_change *sc, int);
static unsigned int status_calc_maxhp(struct block_list *,struct status_change *,unsigned int);
static unsigned int status_calc_maxsp(struct block_list *,struct status_change *,unsigned int);
static unsigned char status_calc_element(struct block_list *bl, struct status_change *sc, int element);
static unsigned char status_calc_element_lv(struct block_list *bl, struct status_change *sc, int lv);
static unsigned short status_calc_mode(struct block_list *bl, struct status_change *sc, int mode);

//Calculates base regen values.
void status_calc_regen(struct block_list *bl, struct status_data *status, struct regen_data *regen)
{
    struct map_session_data *sd;
    int val, skill;

    if (!(bl->type&BL_REGEN) || !regen)
        return;

    sd = BL_CAST(BL_PC,bl);
    val = 1 + (status->vit/5) + (status->max_hp/200);

    if (sd && sd->hprecov_rate != 100)
        val = val*sd->hprecov_rate/100;

    regen->hp = cap_value(val, 1, SHRT_MAX);

    val = 1 + (status->int_/6) + (status->max_sp/100);
    if (status->int_ >= 120)
        val += ((status->int_-120)>>1) + 4;

    if (sd && sd->sprecov_rate != 100)
        val = val*sd->sprecov_rate/100;

    regen->sp = cap_value(val, 1, SHRT_MAX);

    if (sd) {
        struct regen_data_sub *sregen;
        if ((skill=pc_checkskill(sd,HP_MEDITATIO)) > 0) {
            val = regen->sp*(100+3*skill)/100;
            regen->sp = cap_value(val, 1, SHRT_MAX);
        }
        //Only players have skill/sitting skill regen for now.
        sregen = regen->sregen;

        val = 0;
        if ((skill=pc_checkskill(sd,SM_RECOVERY)) > 0)
            val += skill*5 + skill*status->max_hp/500;
        sregen->hp = cap_value(val, 0, SHRT_MAX);

        val = 0;
        if ((skill=pc_checkskill(sd,MG_SRECOVERY)) > 0)
            val += skill*3 + skill*status->max_sp/500;
        if ((skill=pc_checkskill(sd,NJ_NINPOU)) > 0)
            val += skill*3 + skill*status->max_sp/500;
        if ((skill=pc_checkskill(sd,WM_LESSON)) > 0)
            val += 3 + 3 * skill;

        sregen->sp = cap_value(val, 0, SHRT_MAX);

        // Skill-related recovery (only when sit)
        sregen = regen->ssregen;

        val = 0;
        if ((skill=pc_checkskill(sd,MO_SPIRITSRECOVERY)) > 0)
            val += skill*4 + skill*status->max_hp/500;

        if ((skill=pc_checkskill(sd,TK_HPTIME)) > 0 && sd->state.rest)
            val += skill*30 + skill*status->max_hp/500;
        sregen->hp = cap_value(val, 0, SHRT_MAX);

        val = 0;
        if ((skill=pc_checkskill(sd,TK_SPTIME)) > 0 && sd->state.rest) {
            val += skill*3 + skill*status->max_sp/500;
            if ((skill=pc_checkskill(sd,SL_KAINA)) > 0) //Power up Enjoyable Rest
                val += (30+10*skill)*val/100;
        }
        if ((skill=pc_checkskill(sd,MO_SPIRITSRECOVERY)) > 0)
            val += skill*2 + skill*status->max_sp/500;
        sregen->sp = cap_value(val, 0, SHRT_MAX);
    }

    if (bl->type == BL_HOM) {
        struct homun_data *hd = (TBL_HOM *)bl;
        if ((skill = merc_hom_checkskill(hd,HAMI_SKIN)) > 0) {
            val = regen->hp*(100+5*skill)/100;
            regen->hp = cap_value(val, 1, SHRT_MAX);
        }
        if ((skill = merc_hom_checkskill(hd,HLIF_BRAIN)) > 0) {
            val = regen->sp*(100+3*skill)/100;
            regen->sp = cap_value(val, 1, SHRT_MAX);
        }
    } else if (bl->type == BL_MER) {
        val = (status->max_hp * status->vit / 10000 + 1) * 6;
        regen->hp = cap_value(val, 1, SHRT_MAX);

        val = (status->max_sp * (status->int_ + 10) / 750) + 1;
        regen->sp = cap_value(val, 1, SHRT_MAX);
    } else if (bl->type == BL_ELEM) {
        val = (status->max_hp * status->vit / 10000 + 1) * 6;
        regen->hp = cap_value(val, 1, SHRT_MAX);

        val = (status->max_sp * (status->int_ + 10) / 750) + 1;
        regen->sp = cap_value(val, 1, SHRT_MAX);
    }
}

//Calculates SC related regen rates.
void status_calc_regen_rate(struct block_list *bl, struct regen_data *regen, struct status_change *sc)
{
    if (!(bl->type&BL_REGEN) || !regen)
        return;

    regen->flag = RGN_HP|RGN_SP;
    if (regen->sregen) {
        if (regen->sregen->hp)
            regen->flag|=RGN_SHP;

        if (regen->sregen->sp)
            regen->flag|=RGN_SSP;
        regen->sregen->rate.hp = regen->sregen->rate.sp = 1;
    }
    if (regen->ssregen) {
        if (regen->ssregen->hp)
            regen->flag|=RGN_SHP;

        if (regen->ssregen->sp)
            regen->flag|=RGN_SSP;
        regen->ssregen->rate.hp = regen->ssregen->rate.sp = 1;
    }
    regen->rate.hp = regen->rate.sp = 1;

    if (!sc || !sc->count)
        return;

    if (
        (sc->data[SC_POISON] && !sc->data[SC_SLOWPOISON])
        || (sc->data[SC_DPOISON] && !sc->data[SC_SLOWPOISON])
        || sc->data[SC_BERSERK] || sc->data[SC__BLOODYLUST]
        || sc->data[SC_TRICKDEAD]
        || sc->data[SC_BLEEDING]
        || sc->data[SC_MAGICMUSHROOM]
        || sc->data[SC_RAISINGDRAGON]
        || sc->data[SC_SATURDAYNIGHTFEVER]
    )   //No regen
        regen->flag = 0;

    if (
        sc->data[SC_DANCING] || sc->data[SC_OBLIVIONCURSE] || sc->data[SC_MAXIMIZEPOWER]
        || (
            (bl->type == BL_PC && ((TBL_PC *)bl)->class_&MAPID_UPPERMASK) == MAPID_MONK &&
            (sc->data[SC_EXTREMITYFIST] || (sc->data[SC_EXPLOSIONSPIRITS] && (!sc->data[SC_SPIRIT] || sc->data[SC_SPIRIT]->val2 != SL_MONK)))
        )
    )   //No natural SP regen
        regen->flag &=~RGN_SP;

    if (
        sc->data[SC_TENSIONRELAX]
    ) {
        regen->rate.hp += 2;
        if (regen->sregen)
            regen->sregen->rate.hp += 3;
    }
    if (sc->data[SC_MAGNIFICAT]) {
        regen->rate.hp += 1;
        regen->rate.sp += 1;
    }
    if (sc->data[SC_REGENERATION]) {
        const struct status_change_entry *sce = sc->data[SC_REGENERATION];
        if (!sce->val4) {
            regen->rate.hp += sce->val2;
            regen->rate.sp += sce->val3;
        } else
            regen->flag&=~sce->val4; //Remove regen as specified by val4
    }
    if (sc->data[SC_GT_REVITALIZE]) {
        regen->hp = cap_value(regen->hp*sc->data[SC_GT_REVITALIZE]->val3/100, 1, SHRT_MAX);
        regen->state.walk= 1;
    }
    if ((sc->data[SC_FIRE_INSIGNIA] && sc->data[SC_FIRE_INSIGNIA]->val1 == 1) //if insignia lvl 1
        || (sc->data[SC_WATER_INSIGNIA] && sc->data[SC_WATER_INSIGNIA]->val1 == 1)
        || (sc->data[SC_EARTH_INSIGNIA] && sc->data[SC_EARTH_INSIGNIA]->val1 == 1)
        || (sc->data[SC_WIND_INSIGNIA] && sc->data[SC_WIND_INSIGNIA]->val1 == 1))
        regen->rate.hp *= 2;

}
void status_calc_state(struct block_list *bl, struct status_change *sc, enum scs_flag flag, bool start)
{

    /* no sc at all, we can zero without any extra weight over our conciousness */
    if (!sc->count) {
        memset(&sc->cant, 0, sizeof(sc->cant));
        return;
    }

    /* can move? */
    if (flag&SCS_NOMOVE) {
        if (!(flag&SCS_NOMOVECOND)) {
            sc->cant.move += (start ? 1 : -1);
        } else if (
            (sc->data[SC_GOSPEL] && sc->data[SC_GOSPEL]->val4 == BCT_SELF) // cannot move while gospel is in effect
            || (sc->data[SC_BASILICA] && sc->data[SC_BASILICA]->val4 == bl->id) // Basilica caster cannot move
            || (sc->data[SC_GRAVITATION] && sc->data[SC_GRAVITATION]->val3 == BCT_SELF)
            || (sc->data[SC_CRYSTALIZE] && bl->type != BL_MOB)
            || (sc->data[SC_CAMOUFLAGE] && sc->data[SC_CAMOUFLAGE]->val1 < 3
                && !(sc->data[SC_CAMOUFLAGE]->val3&1))
        ) {
            sc->cant.move += (start ? 1 : -1);
        }
    }

    /* can't use skills */
    if (flag&SCS_NOCAST) {
        if (!(flag&SCS_NOCASTCOND)) {
            sc->cant.cast += (start ? 1 : -1);
        } else if ((sc->data[SC_CRYSTALIZE] && bl->type != BL_MOB)) {
            sc->cant.cast += (start ? 1 : -1);
        }
    }

    /* player-only states */
    if (bl->type == BL_PC) {

        /* can pick items? */
        if (flag&SCS_NOPICKITEM) {
            if (!(flag&SCS_NOPICKITEMCOND)) {
                sc->cant.pickup += (start ? 1 : -1);
            } else if ((sc->data[SC_NOCHAT] && sc->data[SC_NOCHAT]->val1&MANNER_NOITEM)) {
                sc->cant.pickup += (start ? 1 : -1);
            }
        }

        /* can drop items? */
        if (flag&SCS_NODROPITEM) {
            if (!(flag&SCS_NODROPITEMCOND)) {
                sc->cant.drop += (start ? 1 : -1);
            } else if ((sc->data[SC_NOCHAT] && sc->data[SC_NOCHAT]->val1&MANNER_NOITEM)) {
                sc->cant.drop += (start ? 1 : -1);
            }
        }
    }

    return;
}
/// Recalculates parts of an object's battle status according to the specified flags.
/// @param flag bitfield of values from enum scb_flag
void status_calc_bl_main(struct block_list *bl, /*enum scb_flag*/int flag)
{
    const struct status_data *b_status = status_get_base_status(bl);
    struct status_data *status = status_get_status_data(bl);
    struct status_change *sc = status_get_sc(bl);
    TBL_PC *sd = BL_CAST(BL_PC,bl);
    int temp;

    if (!b_status || !status)
        return;

    if ((!(bl->type&BL_REGEN)) && (!sc || !sc->count)) { //No difference.
        status_cpy(status, b_status);
        return;
    }

    if (flag&SCB_STR) {
        status->str = status_calc_str(bl, sc, b_status->str);
        flag|=SCB_BATK;
        if (bl->type&BL_HOM)
            flag |= SCB_WATK;
    }

    if (flag&SCB_AGI) {
        status->agi = status_calc_agi(bl, sc, b_status->agi);
        flag|=SCB_FLEE;
        if (bl->type&(BL_PC|BL_HOM))
            flag |= SCB_ASPD|SCB_DSPD;
    }

    if (flag&SCB_VIT) {
        status->vit = status_calc_vit(bl, sc, b_status->vit);
        flag|=SCB_DEF2|SCB_MDEF2;
        if (bl->type&(BL_PC|BL_HOM|BL_MER|BL_ELEM))
            flag |= SCB_MAXHP;
        if (bl->type&BL_HOM)
            flag |= SCB_DEF;
    }

    if (flag&SCB_INT) {
        status->int_ = status_calc_int(bl, sc, b_status->int_);
        flag|=SCB_MATK|SCB_MDEF2;
        if (bl->type&(BL_PC|BL_HOM|BL_MER|BL_ELEM))
            flag |= SCB_MAXSP;
        if (bl->type&BL_HOM)
            flag |= SCB_MDEF;
    }

    if (flag&SCB_DEX) {
        status->dex = status_calc_dex(bl, sc, b_status->dex);
        flag|=SCB_BATK|SCB_HIT;
        if (bl->type&(BL_PC|BL_HOM))
            flag |= SCB_ASPD;
        if (bl->type&BL_HOM)
            flag |= SCB_WATK;
    }

    if (flag&SCB_LUK) {
        status->luk = status_calc_luk(bl, sc, b_status->luk);
        flag|=SCB_BATK|SCB_CRI|SCB_FLEE2;
    }

    if (flag&SCB_BATK && b_status->batk) {
        status->batk = status_base_atk(bl,status);
        temp = b_status->batk - status_base_atk(bl,b_status);
        if (temp) {
            temp += status->batk;
            status->batk = cap_value(temp, 0, USHRT_MAX);
        }
        status->batk = status_calc_batk(bl, sc, status->batk);
    }

    if (flag&SCB_WATK) {

        status->rhw.atk = status_calc_watk(bl, sc, b_status->rhw.atk);
        if (!sd) //Should not affect weapon refine bonus
            status->rhw.atk2 = status_calc_watk(bl, sc, b_status->rhw.atk2);

        if (b_status->lhw.atk) {
            if (sd) {
                sd->state.lr_flag = 1;
                status->lhw.atk = status_calc_watk(bl, sc, b_status->lhw.atk);
                sd->state.lr_flag = 0;
            } else {
                status->lhw.atk = status_calc_watk(bl, sc, b_status->lhw.atk);
                status->lhw.atk2= status_calc_watk(bl, sc, b_status->lhw.atk2);
            }
        }

        if (bl->type&BL_HOM) {
            status->rhw.atk += (status->dex - b_status->dex);
            status->rhw.atk2 += (status->str - b_status->str);
            if (status->rhw.atk2 < status->rhw.atk)
                status->rhw.atk2 = status->rhw.atk;
        }
    }

    if (flag&SCB_HIT) {
        if (status->dex == b_status->dex)
            status->hit = status_calc_hit(bl, sc, b_status->hit);
        else
            status->hit = status_calc_hit(bl, sc, b_status->hit +(status->dex - b_status->dex));
    }

    if (flag&SCB_FLEE) {
        if (status->agi == b_status->agi)
            status->flee = status_calc_flee(bl, sc, b_status->flee);
        else
            status->flee = status_calc_flee(bl, sc, b_status->flee +(status->agi - b_status->agi));
    }

    if (flag&SCB_DEF) {
        status->def = status_calc_def(bl, sc, b_status->def);

        if (bl->type&BL_HOM)
            status->def += (status->vit/5 - b_status->vit/5);
    }

    if (flag&SCB_DEF2) {
        if (status->vit == b_status->vit)
            status->def2 = status_calc_def2(bl, sc, b_status->def2);
        else
            status->def2 = status_calc_def2(bl, sc, b_status->def2 + (status->vit - b_status->vit));
    }

    if (flag&SCB_MDEF) {
        status->mdef = status_calc_mdef(bl, sc, b_status->mdef);

        if (bl->type&BL_HOM)
            status->mdef += (status->int_/5 - b_status->int_/5);
    }

    if (flag&SCB_MDEF2) {
        if (status->int_ == b_status->int_ && status->vit == b_status->vit)
            status->mdef2 = status_calc_mdef2(bl, sc, b_status->mdef2);
        else
            status->mdef2 = status_calc_mdef2(bl, sc, b_status->mdef2 +(status->int_ - b_status->int_) +((status->vit - b_status->vit)>>1));
    }

    if (flag&SCB_SPEED) {
        struct unit_data *ud = unit_bl2ud(bl);
        status->speed = status_calc_speed(bl, sc, b_status->speed);

        //Re-walk to adjust speed (we do not check if walktimer != INVALID_TIMER
        //because if you step on something while walking, the moment this
        //piece of code triggers the walk-timer is set on INVALID_TIMER) [Skotlex]
        if (ud)
            ud->state.change_walk_target = ud->state.speed_changed = 1;

        if (bl->type&BL_PC && status->speed < battle_config.max_walk_speed)
            status->speed = battle_config.max_walk_speed;

        if (bl->type&BL_HOM && battle_config.hom_setting&0x8 && ((TBL_HOM *)bl)->master)
            status->speed = status_get_speed(&((TBL_HOM *)bl)->master->bl);


    }

    if (flag&SCB_CRI && b_status->cri) {
        if (status->luk == b_status->luk)
            status->cri = status_calc_critical(bl, sc, b_status->cri);
        else
            status->cri = status_calc_critical(bl, sc, b_status->cri + 3*(status->luk - b_status->luk));
        /**
         * after status_calc_critical so the bonus is applied despite if you have or not a sc bugreport:5240
         **/
        if (bl->type == BL_PC && ((TBL_PC *)bl)->status.weapon == W_KATAR)
            status->cri <<= 1;

    }

    if (flag&SCB_FLEE2 && b_status->flee2) {
        if (status->luk == b_status->luk)
            status->flee2 = status_calc_flee2(bl, sc, b_status->flee2);
        else
            status->flee2 = status_calc_flee2(bl, sc, b_status->flee2 +(status->luk - b_status->luk));
    }

    if (flag&SCB_ATK_ELE) {
        status->rhw.ele = status_calc_attack_element(bl, sc, b_status->rhw.ele);
        if (sd) sd->state.lr_flag = 1;
        status->lhw.ele = status_calc_attack_element(bl, sc, b_status->lhw.ele);
        if (sd) sd->state.lr_flag = 0;
    }

    if (flag&SCB_DEF_ELE) {
        status->def_ele = status_calc_element(bl, sc, b_status->def_ele);
        status->ele_lv = status_calc_element_lv(bl, sc, b_status->ele_lv);
    }

    if (flag&SCB_MODE) {
        status->mode = status_calc_mode(bl, sc, b_status->mode);
        //Since mode changed, reset their state.
        if (!(status->mode&MD_CANATTACK))
            unit_stop_attack(bl);
        if (!(status->mode&MD_CANMOVE))
            unit_stop_walking(bl,1);
    }

    // No status changes alter these yet.
    //  if(flag&SCB_SIZE)
    // if(flag&SCB_RACE)
    // if(flag&SCB_RANGE)

    if (flag&SCB_MAXHP) {
        if (bl->type&BL_PC) {
            status->max_hp = status_base_pc_maxhp(sd,status);
            status->max_hp += b_status->max_hp - sd->status.max_hp;

            status->max_hp = status_calc_maxhp(bl, sc, status->max_hp);

            if (status->max_hp > (unsigned int)battle_config.max_hp)
                status->max_hp = (unsigned int)battle_config.max_hp;
        } else {
            status->max_hp = status_calc_maxhp(bl, sc, b_status->max_hp);
        }

        if (status->hp > status->max_hp) { //FIXME: Should perhaps a status_zap should be issued?
            status->hp = status->max_hp;
            if (sd) clif_updatestatus(sd,SP_HP);
        }
    }

    if (flag&SCB_MAXSP) {
        if (bl->type&BL_PC) {
            status->max_sp = status_base_pc_maxsp(sd,status);
            status->max_sp += b_status->max_sp - sd->status.max_sp;

            status->max_sp = status_calc_maxsp(&sd->bl, &sd->sc, status->max_sp);

            if (status->max_sp > (unsigned int)battle_config.max_sp)
                status->max_sp = (unsigned int)battle_config.max_sp;
        } else {
            status->max_sp = status_calc_maxsp(bl, sc, b_status->max_sp);
        }

        if (status->sp > status->max_sp) {
            status->sp = status->max_sp;
            if (sd) clif_updatestatus(sd,SP_SP);
        }
    }

    if (flag&SCB_MATK) {
#ifndef RENEWAL
		status->matk_min = status_base_matk_min(status) + (sd?sd->bonus.ematk:0);
		status->matk_max = status_base_matk_max(status) + (sd?sd->bonus.ematk:0);
#else
		/**
		 * RE MATK Formula (from irowiki:http://irowiki.org/wiki/MATK)
		 * MATK = (sMATK + wMATK + eMATK) * Multiplicative Modifiers
		 **/
		status->matk_min = status->matk_max = status_base_matk(status, status_get_lv(bl));
		if( bl->type&BL_PC ){
			if( sd->bonus.ematk > 0 ){
				status->matk_max += sd->bonus.ematk;
				status->matk_min += sd->bonus.ematk;
			}
			if( status->rhw.matk > 0 ){
				int wMatk = status->rhw.matk;
				int variance = wMatk * status->rhw.wlv / 10;
				status->matk_min += wMatk - variance;
				status->matk_max += wMatk + variance;
			}
		}
#endif
        if (bl->type&BL_PC && sd->matk_rate != 100) {
            status->matk_max = status->matk_max * sd->matk_rate/100;
            status->matk_min = status->matk_min * sd->matk_rate/100;
        }

        status->matk_min = status_calc_matk(bl, sc, status->matk_min);
        status->matk_max = status_calc_matk(bl, sc, status->matk_max);

        if ((bl->type&BL_HOM && battle_config.hom_setting&0x20)  //Hom Min Matk is always the same as Max Matk
			|| ( sc && sc->data[SC_RECOGNIZEDSPELL] ))
            status->matk_min = status->matk_max;

#ifdef RENEWAL
		if( sd && sd->right_weapon.overrefine > 0){
			status->matk_min++;
			status->matk_max += sd->right_weapon.overrefine - 1;
		}
#endif

    }

    if (flag&SCB_ASPD) {
        int amotion;
        if (bl->type&BL_PC) {
            amotion = status_base_amotion_pc(sd,status);
#ifndef RENEWAL_ASPD
            status->aspd_rate = status_calc_aspd_rate(bl, sc, b_status->aspd_rate);

            if (status->aspd_rate != 1000)
                amotion = amotion*status->aspd_rate/1000;
#else
            // aspd = baseaspd + floor(sqrt((agi^2/2) + (dex^2/5))/4 + (potskillbonus*agi/200))
            amotion -= (int)(sqrt((pow(status->agi, 2) / 2) + (pow(status->dex, 2) / 5)) / 4 + (status_calc_aspd(bl, sc, 1) * status->agi / 200)) * 10;

            if ((status_calc_aspd(bl, sc, 2) + status->aspd_rate2) != 0)  // RE ASPD percertage modifier
                amotion -= (amotion - ((sd->class_&JOBL_THIRD) ? battle_config.max_third_aspd : battle_config.max_aspd))
                           * (status_calc_aspd(bl, sc, 2) + status->aspd_rate2) / 100;

            if (status->aspd_rate != 1000) // absolute percentage modifier
                amotion = (200 - (200-amotion/10) * status->aspd_rate / 1000) * 10;
#endif
            //@TODO move FIGHTINGSPIRIT in fix_aspd
            if (sc && sc->data[SC_FIGHTINGSPIRIT] && sc->data[SC_FIGHTINGSPIRIT]->val2)
                amotion -= (sd?pc_checkskill(sd, RK_RUNEMASTERY):10) / 10 * 40;
            amotion = status_calc_fix_aspd(bl, sc, amotion);
            status->amotion = cap_value(amotion,((sd->class_&JOBL_THIRD) ? battle_config.max_third_aspd : battle_config.max_aspd),2000);

            status->adelay = 2*status->amotion;
        } else if (bl->type&BL_HOM) {
            amotion = (1000 -4*status->agi -status->dex) * ((TBL_HOM *)bl)->homunculusDB->baseASPD/1000;
            status->aspd_rate = status_calc_aspd_rate(bl, sc, b_status->aspd_rate);

            if (status->aspd_rate != 1000)
                amotion = amotion*status->aspd_rate/1000;

            amotion = status_calc_fix_aspd(bl, sc, amotion);
            status->amotion = cap_value(amotion,battle_config.max_aspd,2000);

            status->adelay = status->amotion;
        } else { // mercenary and mobs
            amotion = b_status->amotion;
            status->aspd_rate = status_calc_aspd_rate(bl, sc, b_status->aspd_rate);

            if (status->aspd_rate != 1000)
                amotion = amotion*status->aspd_rate/1000;

            amotion = status_calc_fix_aspd(bl, sc, amotion);
            status->amotion = cap_value(amotion, battle_config.monster_max_aspd, 2000);

            temp = b_status->adelay*status->aspd_rate/1000;
            status->adelay = cap_value(temp, battle_config.monster_max_aspd*2, 4000);
        }
    }

    if (flag&SCB_DSPD) {
        int dmotion;
        if (bl->type&BL_PC) {
            if (b_status->agi == status->agi)
                status->dmotion = status_calc_dmotion(bl, sc, b_status->dmotion);
            else {
                dmotion = 800-status->agi*4;
                status->dmotion = cap_value(dmotion, 400, 800);
                if (battle_config.pc_damage_delay_rate != 100)
                    status->dmotion = status->dmotion*battle_config.pc_damage_delay_rate/100;
                //It's safe to ignore b_status->dmotion since no bonus affects it.
                status->dmotion = status_calc_dmotion(bl, sc, status->dmotion);
            }
        } else if (bl->type&BL_HOM) {
            dmotion = 800-status->agi*4;
            status->dmotion = cap_value(dmotion, 400, 800);
            status->dmotion = status_calc_dmotion(bl, sc, b_status->dmotion);
        } else { // mercenary and mobs
            status->dmotion = status_calc_dmotion(bl, sc, b_status->dmotion);
        }
    }

    if (flag&(SCB_VIT|SCB_MAXHP|SCB_INT|SCB_MAXSP) && bl->type&BL_REGEN)
        status_calc_regen(bl, status, status_get_regen_data(bl));

    if (flag&SCB_REGEN && bl->type&BL_REGEN)
        status_calc_regen_rate(bl, status_get_regen_data(bl), sc);
}
/// Recalculates parts of an object's base status and battle status according to the specified flags.
/// Also sends updates to the client wherever applicable.
/// @param flag bitfield of values from enum scb_flag
/// @param first if true, will cause status_calc_* functions to run their base status initialization code
void status_calc_bl_(struct block_list *bl, enum scb_flag flag, bool first)
{
    struct status_data b_status; // previous battle status
    struct status_data *status; // pointer to current battle status

    // remember previous values
    status = status_get_status_data(bl);
    memcpy(&b_status, status, sizeof(struct status_data));

    if (flag&SCB_BASE) { // calculate the object's base status too
        switch (bl->type) {
            case BL_PC:
                status_calc_pc_(BL_CAST(BL_PC,bl), first);
                break;
            case BL_MOB:
                status_calc_mob_(BL_CAST(BL_MOB,bl), first);
                break;
            case BL_PET:
                status_calc_pet_(BL_CAST(BL_PET,bl), first);
                break;
            case BL_HOM:
                status_calc_homunculus_(BL_CAST(BL_HOM,bl), first);
                break;
            case BL_MER:
                status_calc_mercenary_(BL_CAST(BL_MER,bl), first);
                break;
            case BL_ELEM:
                status_calc_elemental_(BL_CAST(BL_ELEM,bl), first);
                break;
        }
    }

    if (bl->type == BL_PET)
        return; // pets are not affected by statuses

    if (first && bl->type == BL_MOB)
        return; // assume there will be no statuses active

    status_calc_bl_main(bl, flag);

    if (first && bl->type == BL_HOM)
        return; // client update handled by caller

    // compare against new values and send client updates
    if (bl->type == BL_PC) {
        TBL_PC *sd = BL_CAST(BL_PC, bl);
        if (b_status.str != status->str)
            clif_updatestatus(sd,SP_STR);
        if (b_status.agi != status->agi)
            clif_updatestatus(sd,SP_AGI);
        if (b_status.vit != status->vit)
            clif_updatestatus(sd,SP_VIT);
        if (b_status.int_ != status->int_)
            clif_updatestatus(sd,SP_INT);
        if (b_status.dex != status->dex)
            clif_updatestatus(sd,SP_DEX);
        if (b_status.luk != status->luk)
            clif_updatestatus(sd,SP_LUK);
        if (b_status.hit != status->hit)
            clif_updatestatus(sd,SP_HIT);
        if (b_status.flee != status->flee)
            clif_updatestatus(sd,SP_FLEE1);
        if (b_status.amotion != status->amotion)
            clif_updatestatus(sd,SP_ASPD);
        if (b_status.speed != status->speed)
            clif_updatestatus(sd,SP_SPEED);

        if (b_status.batk != status->batk
#ifndef RENEWAL
            || b_status.rhw.atk != status->rhw.atk || b_status.lhw.atk != status->lhw.atk
#endif
           )
            clif_updatestatus(sd,SP_ATK1);

        if (b_status.def != status->def) {
            clif_updatestatus(sd,SP_DEF1);
#ifdef RENEWAL
            clif_updatestatus(sd,SP_DEF2);
#endif
        }

        if (b_status.rhw.atk2 != status->rhw.atk2 || b_status.lhw.atk2 != status->lhw.atk2
#ifdef RENEWAL
            || b_status.rhw.atk != status->rhw.atk || b_status.lhw.atk != status->lhw.atk
#endif
           )
            clif_updatestatus(sd,SP_ATK2);

        if (b_status.def2 != status->def2) {
            clif_updatestatus(sd,SP_DEF2);
#ifdef RENEWAL
            clif_updatestatus(sd,SP_DEF1);
#endif
        }
        if (b_status.flee2 != status->flee2)
            clif_updatestatus(sd,SP_FLEE2);
        if (b_status.cri != status->cri)
            clif_updatestatus(sd,SP_CRITICAL);
#ifndef RENEWAL
        if (b_status.matk_max != status->matk_max)
            clif_updatestatus(sd,SP_MATK1);
        if (b_status.matk_min != status->matk_min)
            clif_updatestatus(sd,SP_MATK2);
#else
		if(b_status.matk_max != status->matk_max || b_status.matk_min != status->matk_min){
			clif_updatestatus(sd,SP_MATK2);
			clif_updatestatus(sd,SP_MATK1);
		}
#endif
        if (b_status.mdef != status->mdef) {
            clif_updatestatus(sd,SP_MDEF1);
#ifdef RENEWAL
            clif_updatestatus(sd,SP_MDEF2);
#endif
        }
        if (b_status.mdef2 != status->mdef2) {
            clif_updatestatus(sd,SP_MDEF2);
#ifdef RENEWAL
            clif_updatestatus(sd,SP_MDEF1);
#endif
        }
        if (b_status.rhw.range != status->rhw.range)
            clif_updatestatus(sd,SP_ATTACKRANGE);
        if (b_status.max_hp != status->max_hp)
            clif_updatestatus(sd,SP_MAXHP);
        if (b_status.max_sp != status->max_sp)
            clif_updatestatus(sd,SP_MAXSP);
        if (b_status.hp != status->hp)
            clif_updatestatus(sd,SP_HP);
        if (b_status.sp != status->sp)
            clif_updatestatus(sd,SP_SP);
    } else if (bl->type == BL_HOM) {
        TBL_HOM *hd = BL_CAST(BL_HOM, bl);
        if (hd->master && memcmp(&b_status, status, sizeof(struct status_data)) != 0)
            clif_hominfo(hd->master,hd,0);
    } else if (bl->type == BL_MER) {
        TBL_MER *md = BL_CAST(BL_MER, bl);
        if (b_status.rhw.atk != status->rhw.atk || b_status.rhw.atk2 != status->rhw.atk2)
            clif_mercenary_updatestatus(md->master, SP_ATK1);
        if (b_status.matk_max != status->matk_max)
            clif_mercenary_updatestatus(md->master, SP_MATK1);
        if (b_status.hit != status->hit)
            clif_mercenary_updatestatus(md->master, SP_HIT);
        if (b_status.cri != status->cri)
            clif_mercenary_updatestatus(md->master, SP_CRITICAL);
        if (b_status.def != status->def)
            clif_mercenary_updatestatus(md->master, SP_DEF1);
        if (b_status.mdef != status->mdef)
            clif_mercenary_updatestatus(md->master, SP_MDEF1);
        if (b_status.flee != status->flee)
            clif_mercenary_updatestatus(md->master, SP_MERCFLEE);
        if (b_status.amotion != status->amotion)
            clif_mercenary_updatestatus(md->master, SP_ASPD);
        if (b_status.max_hp != status->max_hp)
            clif_mercenary_updatestatus(md->master, SP_MAXHP);
        if (b_status.max_sp != status->max_sp)
            clif_mercenary_updatestatus(md->master, SP_MAXSP);
        if (b_status.hp != status->hp)
            clif_mercenary_updatestatus(md->master, SP_HP);
        if (b_status.sp != status->sp)
            clif_mercenary_updatestatus(md->master, SP_SP);
    } else if (bl->type == BL_ELEM) {
        TBL_ELEM *ed = BL_CAST(BL_ELEM, bl);
        if (b_status.max_hp != status->max_hp)
            clif_elemental_updatestatus(ed->master, SP_MAXHP);
        if (b_status.max_sp != status->max_sp)
            clif_elemental_updatestatus(ed->master, SP_MAXSP);
        if (b_status.hp != status->hp)
            clif_elemental_updatestatus(ed->master, SP_HP);
        if (b_status.sp != status->sp)
            clif_mercenary_updatestatus(ed->master, SP_SP);
    }
}

/*==========================================
 * Apply shared stat mods from status changes [DracoRPG]
 *------------------------------------------*/
static unsigned short status_calc_str(struct block_list *bl, struct status_change *sc, int str)
{
    if (!sc || !sc->count)
        return cap_value(str,0,USHRT_MAX);

    if (sc->data[SC_HARMONIZE]) {
        str -= sc->data[SC_HARMONIZE]->val2;
        return (unsigned short)cap_value(str,0,USHRT_MAX);
    }
    if (sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_HIGH && str < 50)
        return 50;
    if (sc->data[SC_INCALLSTATUS])
        str += sc->data[SC_INCALLSTATUS]->val1;
    if (sc->data[SC_INCSTR])
        str += sc->data[SC_INCSTR]->val1;
    if (sc->data[SC_STRFOOD])
        str += sc->data[SC_STRFOOD]->val1;
    if (sc->data[SC_FOOD_STR_CASH])
        str += sc->data[SC_FOOD_STR_CASH]->val1;
    if (sc->data[SC_BATTLEORDERS])
        str += 5;
    if (sc->data[SC_LEADERSHIP])
        str += sc->data[SC_LEADERSHIP]->val1;
    if (sc->data[SC_LOUD])
        str += 4;
    if (sc->data[SC_TRUESIGHT])
        str += 5;
    if (sc->data[SC_SPURT])
        str += 10;
    if (sc->data[SC_NEN])
        str += sc->data[SC_NEN]->val1;
    if (sc->data[SC_BLESSING]) {
        if (sc->data[SC_BLESSING]->val2)
            str += sc->data[SC_BLESSING]->val2;
        else
            str >>= 1;
    }
    if (sc->data[SC_MARIONETTE])
        str -= ((sc->data[SC_MARIONETTE]->val3)>>16)&0xFF;
    if (sc->data[SC_MARIONETTE2])
        str += ((sc->data[SC_MARIONETTE2]->val3)>>16)&0xFF;
    if (sc->data[SC_GIANTGROWTH])
        str += 30;
    if (sc->data[SC_SAVAGE_STEAK])
        str += sc->data[SC_SAVAGE_STEAK]->val1;
    if (sc->data[SC_INSPIRATION])
        str += sc->data[SC_INSPIRATION]->val3;
    if (sc->data[SC_STOMACHACHE])
        str -= sc->data[SC_STOMACHACHE]->val1;
    if (sc->data[SC_KYOUGAKU])
        str -= sc->data[SC_KYOUGAKU]->val2;

    return (unsigned short)cap_value(str,0,USHRT_MAX);
}

static unsigned short status_calc_agi(struct block_list *bl, struct status_change *sc, int agi)
{
    if (!sc || !sc->count)
        return cap_value(agi,0,USHRT_MAX);

    if (sc->data[SC_HARMONIZE]) {
        agi -= sc->data[SC_HARMONIZE]->val2;
        return (unsigned short)cap_value(agi,0,USHRT_MAX);
    }
    if (sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_HIGH && agi < 50)
        return 50;
    if (sc->data[SC_CONCENTRATE] && !sc->data[SC_QUAGMIRE])
        agi += (agi-sc->data[SC_CONCENTRATE]->val3)*sc->data[SC_CONCENTRATE]->val2/100;
    if (sc->data[SC_INCALLSTATUS])
        agi += sc->data[SC_INCALLSTATUS]->val1;
    if (sc->data[SC_INCAGI])
        agi += sc->data[SC_INCAGI]->val1;
    if (sc->data[SC_AGIFOOD])
        agi += sc->data[SC_AGIFOOD]->val1;
    if (sc->data[SC_FOOD_AGI_CASH])
        agi += sc->data[SC_FOOD_AGI_CASH]->val1;
    if (sc->data[SC_SOULCOLD])
        agi += sc->data[SC_SOULCOLD]->val1;
    if (sc->data[SC_TRUESIGHT])
        agi += 5;
    if (sc->data[SC_INCREASEAGI])
        agi += sc->data[SC_INCREASEAGI]->val2;
    if (sc->data[SC_INCREASING])
        agi += 4;   // added based on skill updates [Reddozen]
    if (sc->data[SC_DECREASEAGI])
        agi -= sc->data[SC_DECREASEAGI]->val2;
    if (sc->data[SC_QUAGMIRE])
        agi -= sc->data[SC_QUAGMIRE]->val2;
    if (sc->data[SC_SUITON] && sc->data[SC_SUITON]->val3)
        agi -= sc->data[SC_SUITON]->val2;
    if (sc->data[SC_MARIONETTE])
        agi -= ((sc->data[SC_MARIONETTE]->val3)>>8)&0xFF;
    if (sc->data[SC_MARIONETTE2])
        agi += ((sc->data[SC_MARIONETTE2]->val3)>>8)&0xFF;
    if (sc->data[SC_ADORAMUS])
        agi -= sc->data[SC_ADORAMUS]->val2;
    if (sc->data[SC_DROCERA_HERB_STEAMED])
        agi += sc->data[SC_DROCERA_HERB_STEAMED]->val1;
    if (sc->data[SC_INSPIRATION])
        agi += sc->data[SC_INSPIRATION]->val3;
    if (sc->data[SC_STOMACHACHE])
        agi -= sc->data[SC_STOMACHACHE]->val1;
    if (sc->data[SC_KYOUGAKU])
        agi -= sc->data[SC_KYOUGAKU]->val2;

    return (unsigned short)cap_value(agi,0,USHRT_MAX);
}

static unsigned short status_calc_vit(struct block_list *bl, struct status_change *sc, int vit)
{
    if (!sc || !sc->count)
        return cap_value(vit,0,USHRT_MAX);

    if (sc->data[SC_HARMONIZE]) {
        vit -= sc->data[SC_HARMONIZE]->val2;
        return (unsigned short)cap_value(vit,0,USHRT_MAX);
    }
    if (sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_HIGH && vit < 50)
        return 50;
    if (sc->data[SC_INCALLSTATUS])
        vit += sc->data[SC_INCALLSTATUS]->val1;
    if (sc->data[SC_INCVIT])
        vit += sc->data[SC_INCVIT]->val1;
    if (sc->data[SC_VITFOOD])
        vit += sc->data[SC_VITFOOD]->val1;
    if (sc->data[SC_FOOD_VIT_CASH])
        vit += sc->data[SC_FOOD_VIT_CASH]->val1;
    if (sc->data[SC_CHANGE])
        vit += sc->data[SC_CHANGE]->val2;
    if (sc->data[SC_GLORYWOUNDS])
        vit += sc->data[SC_GLORYWOUNDS]->val1;
    if (sc->data[SC_TRUESIGHT])
        vit += 5;
    if (sc->data[SC_STRIPARMOR])
        vit -= vit * sc->data[SC_STRIPARMOR]->val2/100;
    if (sc->data[SC_MARIONETTE])
        vit -= sc->data[SC_MARIONETTE]->val3&0xFF;
    if (sc->data[SC_MARIONETTE2])
        vit += sc->data[SC_MARIONETTE2]->val3&0xFF;
    if (sc->data[SC_LAUDAAGNUS])
        vit += 4 + sc->data[SC_LAUDAAGNUS]->val1;
    if (sc->data[SC_MINOR_BBQ])
        vit += sc->data[SC_MINOR_BBQ]->val1;
    if (sc->data[SC_INSPIRATION])
        vit += sc->data[SC_INSPIRATION]->val3;
    if (sc->data[SC_STOMACHACHE])
        vit -= sc->data[SC_STOMACHACHE]->val1;
    if (sc->data[SC_KYOUGAKU])
        vit -= sc->data[SC_KYOUGAKU]->val2;

    return (unsigned short)cap_value(vit,0,USHRT_MAX);
}

static unsigned short status_calc_int(struct block_list *bl, struct status_change *sc, int int_)
{
    if (!sc || !sc->count)
        return cap_value(int_,0,USHRT_MAX);

    if (sc->data[SC_HARMONIZE]) {
        int_ -= sc->data[SC_HARMONIZE]->val2;
        return (unsigned short)cap_value(int_,0,USHRT_MAX);
    }
    if (sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_HIGH && int_ < 50)
        return 50;
    if (sc->data[SC_INCALLSTATUS])
        int_ += sc->data[SC_INCALLSTATUS]->val1;
    if (sc->data[SC_INCINT])
        int_ += sc->data[SC_INCINT]->val1;
    if (sc->data[SC_INTFOOD])
        int_ += sc->data[SC_INTFOOD]->val1;
    if (sc->data[SC_FOOD_INT_CASH])
        int_ += sc->data[SC_FOOD_INT_CASH]->val1;
    if (sc->data[SC_CHANGE])
        int_ += sc->data[SC_CHANGE]->val3;
    if (sc->data[SC_BATTLEORDERS])
        int_ += 5;
    if (sc->data[SC_TRUESIGHT])
        int_ += 5;
    if (sc->data[SC_BLESSING]) {
        if (sc->data[SC_BLESSING]->val2)
            int_ += sc->data[SC_BLESSING]->val2;
        else
            int_ >>= 1;
    }
    if (sc->data[SC_STRIPHELM])
        int_ -= int_ * sc->data[SC_STRIPHELM]->val2/100;
    if (sc->data[SC_NEN])
        int_ += sc->data[SC_NEN]->val1;
    if (sc->data[SC_MARIONETTE])
        int_ -= ((sc->data[SC_MARIONETTE]->val4)>>16)&0xFF;
    if (sc->data[SC_MARIONETTE2])
        int_ += ((sc->data[SC_MARIONETTE2]->val4)>>16)&0xFF;
    if (sc->data[SC_MANDRAGORA])
        int_ -= 5 + 5 * sc->data[SC_MANDRAGORA]->val1;
    if (sc->data[SC__STRIPACCESSORY])
        int_ -= int_ * sc->data[SC__STRIPACCESSORY]->val2 / 100;
    if (sc->data[SC_COCKTAIL_WARG_BLOOD])
        int_ += sc->data[SC_COCKTAIL_WARG_BLOOD]->val1;
    if (sc->data[SC_INSPIRATION])
        int_ += sc->data[SC_INSPIRATION]->val3;
    if (sc->data[SC_STOMACHACHE])
        int_ -= sc->data[SC_STOMACHACHE]->val1;
    if (sc->data[SC_KYOUGAKU])
        int_ -= sc->data[SC_KYOUGAKU]->val2;

    return (unsigned short)cap_value(int_,0,USHRT_MAX);
}

static unsigned short status_calc_dex(struct block_list *bl, struct status_change *sc, int dex)
{
    if (!sc || !sc->count)
        return cap_value(dex,0,USHRT_MAX);

    if (sc->data[SC_HARMONIZE]) {
        dex -= sc->data[SC_HARMONIZE]->val2;
        return (unsigned short)cap_value(dex,0,USHRT_MAX);
    }
    if (sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_HIGH && dex < 50)
        return 50;
    if (sc->data[SC_CONCENTRATE] && !sc->data[SC_QUAGMIRE])
        dex += (dex-sc->data[SC_CONCENTRATE]->val4)*sc->data[SC_CONCENTRATE]->val2/100;
    if (sc->data[SC_INCALLSTATUS])
        dex += sc->data[SC_INCALLSTATUS]->val1;
    if (sc->data[SC_INCDEX])
        dex += sc->data[SC_INCDEX]->val1;
    if (sc->data[SC_DEXFOOD])
        dex += sc->data[SC_DEXFOOD]->val1;
    if (sc->data[SC_FOOD_DEX_CASH])
        dex += sc->data[SC_FOOD_DEX_CASH]->val1;
    if (sc->data[SC_BATTLEORDERS])
        dex += 5;
    if (sc->data[SC_HAWKEYES])
        dex += sc->data[SC_HAWKEYES]->val1;
    if (sc->data[SC_TRUESIGHT])
        dex += 5;
    if (sc->data[SC_QUAGMIRE])
        dex -= sc->data[SC_QUAGMIRE]->val2;
    if (sc->data[SC_BLESSING]) {
        if (sc->data[SC_BLESSING]->val2)
            dex += sc->data[SC_BLESSING]->val2;
        else
            dex >>= 1;
    }
    if (sc->data[SC_INCREASING])
        dex += 4;   // added based on skill updates [Reddozen]
    if (sc->data[SC_MARIONETTE])
        dex -= ((sc->data[SC_MARIONETTE]->val4)>>8)&0xFF;
    if (sc->data[SC_MARIONETTE2])
        dex += ((sc->data[SC_MARIONETTE2]->val4)>>8)&0xFF;
    if (sc->data[SC__STRIPACCESSORY])
        dex -= dex * sc->data[SC__STRIPACCESSORY]->val2 / 100;
    if (sc->data[SC_SIROMA_ICE_TEA])
        dex += sc->data[SC_SIROMA_ICE_TEA]->val1;
    if (sc->data[SC_INSPIRATION])
        dex += sc->data[SC_INSPIRATION]->val3;
    if (sc->data[SC_STOMACHACHE])
        dex -= sc->data[SC_STOMACHACHE]->val1;
    if (sc->data[SC_KYOUGAKU])
        dex -= sc->data[SC_KYOUGAKU]->val2;

    return (unsigned short)cap_value(dex,0,USHRT_MAX);
}

static unsigned short status_calc_luk(struct block_list *bl, struct status_change *sc, int luk)
{
    if (!sc || !sc->count)
        return cap_value(luk,0,USHRT_MAX);

    if (sc->data[SC_HARMONIZE]) {
        luk -= sc->data[SC_HARMONIZE]->val2;
        return (unsigned short)cap_value(luk,0,USHRT_MAX);
    }
    if (sc->data[SC_CURSE])
        return 0;
    if (sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_HIGH && luk < 50)
        return 50;
    if (sc->data[SC_INCALLSTATUS])
        luk += sc->data[SC_INCALLSTATUS]->val1;
    if (sc->data[SC_INCLUK])
        luk += sc->data[SC_INCLUK]->val1;
    if (sc->data[SC_LUKFOOD])
        luk += sc->data[SC_LUKFOOD]->val1;
    if (sc->data[SC_FOOD_LUK_CASH])
        luk += sc->data[SC_FOOD_LUK_CASH]->val1;
    if (sc->data[SC_TRUESIGHT])
        luk += 5;
    if (sc->data[SC_GLORIA])
        luk += 30;
    if (sc->data[SC_MARIONETTE])
        luk -= sc->data[SC_MARIONETTE]->val4&0xFF;
    if (sc->data[SC_MARIONETTE2])
        luk += sc->data[SC_MARIONETTE2]->val4&0xFF;
    if (sc->data[SC_LAUDARAMUS])
        luk += 4 + sc->data[SC_LAUDARAMUS]->val1;
    if (sc->data[SC__STRIPACCESSORY])
        luk -= luk * sc->data[SC__STRIPACCESSORY]->val2 / 100;
    if (sc->data[SC_PUTTI_TAILS_NOODLES])
        luk += sc->data[SC_PUTTI_TAILS_NOODLES]->val1;
    if (sc->data[SC_INSPIRATION])
        luk += sc->data[SC_INSPIRATION]->val3;
    if (sc->data[SC_STOMACHACHE])
        luk -= sc->data[SC_STOMACHACHE]->val1;
    if (sc->data[SC_BANANA_BOMB])
        luk -= luk * sc->data[SC_BANANA_BOMB]->val1 / 100;
    if (sc->data[SC_KYOUGAKU])
        luk -= sc->data[SC_KYOUGAKU]->val2;

    return (unsigned short)cap_value(luk,0,USHRT_MAX);
}

static unsigned short status_calc_batk(struct block_list *bl, struct status_change *sc, int batk)
{
    if (!sc || !sc->count)
        return cap_value(batk,0,USHRT_MAX);

    if (sc->data[SC_ATKPOTION])
        batk += sc->data[SC_ATKPOTION]->val1;
    if (sc->data[SC_BATKFOOD])
        batk += sc->data[SC_BATKFOOD]->val1;
    if (sc->data[SC_INCATKRATE])
        batk += batk * sc->data[SC_INCATKRATE]->val1/100;
    if (sc->data[SC_PROVOKE])
        batk += batk * sc->data[SC_PROVOKE]->val3/100;
    if (sc->data[SC_CONCENTRATION])
        batk += batk * sc->data[SC_CONCENTRATION]->val2/100;
    if (sc->data[SC_SKE])
        batk += batk * 3;
    if (sc->data[SC_BLOODLUST])
        batk += batk * sc->data[SC_BLOODLUST]->val2/100;
    if (sc->data[SC_JOINTBEAT] && sc->data[SC_JOINTBEAT]->val2&BREAK_WAIST)
        batk -= batk * 25/100;
    if (sc->data[SC_CURSE])
        batk -= batk * 25/100;
    //Curse shouldn't effect on this?  <- Curse OR Bleeding??
    //  if(sc->data[SC_BLEEDING])
    //      batk -= batk * 25/100;
    if (sc->data[SC_FLEET])
        batk += batk * sc->data[SC_FLEET]->val3/100;
    if (sc->data[SC_GATLINGFEVER])
        batk += sc->data[SC_GATLINGFEVER]->val3;
    if (sc->data[SC_MADNESSCANCEL])
        batk += 100;
    if (sc->data[SC__ENERVATION])
        batk -= batk * sc->data[SC__ENERVATION]->val2 / 100;
    if (sc->data[SC_RUSHWINDMILL])
        batk += batk * sc->data[SC_RUSHWINDMILL]->val2/100;
    if (sc->data[SC_SATURDAYNIGHTFEVER])
        batk += 100 * sc->data[SC_SATURDAYNIGHTFEVER]->val1;
    if (sc->data[SC_MELODYOFSINK])
        batk -= batk * sc->data[SC_MELODYOFSINK]->val3/100;
    if (sc->data[SC_BEYONDOFWARCRY])
        batk += batk * sc->data[SC_BEYONDOFWARCRY]->val3/100;
    if (sc->data[SC_FIRE_INSIGNIA] && sc->data[SC_FIRE_INSIGNIA]->val1 == 2)
        batk += 50;
    if (bl->type == BL_ELEM
        && ((sc->data[SC_FIRE_INSIGNIA] && sc->data[SC_FIRE_INSIGNIA]->val1 == 1)
            || (sc->data[SC_WATER_INSIGNIA] && sc->data[SC_WATER_INSIGNIA]->val1 == 1)
            || (sc->data[SC_WIND_INSIGNIA] && sc->data[SC_WIND_INSIGNIA]->val1 == 1)
            || (sc->data[SC_EARTH_INSIGNIA] && sc->data[SC_EARTH_INSIGNIA]->val1 == 1))
       )
        batk += batk / 5;
    if (sc->data[SC_FULL_SWING_K])
        batk += sc->data[SC_FULL_SWING_K]->val1;
    if (sc->data[SC_ODINS_POWER])
        batk += 70;
    if (sc->data[SC_ZANGETSU])
        batk += batk * sc->data[SC_ZANGETSU]->val2 / 100;
    if (sc->data[SC_ASH] && (bl->type==BL_MOB)) {
        if (status_get_element(bl) == ELE_WATER) //water type
            batk /= 2;
    }
    if (sc->data[SC_PYROCLASTIC])
        batk += sc->data[SC_PYROCLASTIC]->val2;
    if (sc->data[SC_ANGRIFFS_MODUS])
        batk += sc->data[SC_ANGRIFFS_MODUS]->val2;

    return (unsigned short)cap_value(batk,0,USHRT_MAX);
}

static unsigned short status_calc_watk(struct block_list *bl, struct status_change *sc, int watk)
{
    if (!sc || !sc->count)
        return cap_value(watk,0,USHRT_MAX);

    if (sc->data[SC_IMPOSITIO])
        watk += sc->data[SC_IMPOSITIO]->val2;
    if (sc->data[SC_WATKFOOD])
        watk += sc->data[SC_WATKFOOD]->val1;
    if (sc->data[SC_DRUMBATTLE])
        watk += sc->data[SC_DRUMBATTLE]->val2;
    if (sc->data[SC_VOLCANO])
        watk += sc->data[SC_VOLCANO]->val2;
    if (sc->data[SC_INCATKRATE])
        watk += watk * sc->data[SC_INCATKRATE]->val1/100;
    if (sc->data[SC_PROVOKE])
        watk += watk * sc->data[SC_PROVOKE]->val3/100;
    if (sc->data[SC_CONCENTRATION])
        watk += watk * sc->data[SC_CONCENTRATION]->val2/100;
    if (sc->data[SC_SKE])
        watk += watk * 3;
    if (sc->data[SC_NIBELUNGEN]) {
        if (bl->type != BL_PC)
            watk += sc->data[SC_NIBELUNGEN]->val2;
        else {
#ifndef RENEWAL
            TBL_PC *sd = (TBL_PC *)bl;
            int index = sd->equip_index[sd->state.lr_flag?EQI_HAND_L:EQI_HAND_R];
            if (index >= 0 && sd->inventory_data[index] && sd->inventory_data[index]->wlv == 4)
#endif
                watk += sc->data[SC_NIBELUNGEN]->val2;
        }
    }
    if (sc->data[SC__ENERVATION])
        watk -= watk * sc->data[SC__ENERVATION]->val2 / 100;
    if (sc->data[SC_FLEET])
        watk += watk * sc->data[SC_FLEET]->val3/100;
    if (sc->data[SC_CURSE])
        watk -= watk * 25/100;
    if (sc->data[SC_STRIPWEAPON])
        watk -= watk * sc->data[SC_STRIPWEAPON]->val2/100;
    if (sc->data[SC_MERC_ATKUP])
        watk += sc->data[SC_MERC_ATKUP]->val2;
    if (sc->data[SC_FIGHTINGSPIRIT])
        watk += sc->data[SC_FIGHTINGSPIRIT]->val1;
    if (sc->data[SC__ENERVATION])
        watk -= watk * sc->data[SC__ENERVATION]->val2 / 100;
    if (sc->data[SC_STRIKING])
        watk += sc->data[SC_STRIKING]->val2;
    if (sc->data[SC_SHIELDSPELL_DEF] && sc->data[SC_SHIELDSPELL_DEF]->val1 == 3)
        watk += sc->data[SC_SHIELDSPELL_DEF]->val2;
    if (sc->data[SC_INSPIRATION])
        watk += sc->data[SC_INSPIRATION]->val2;
    if (sc->data[SC_BANDING] && sc->data[SC_BANDING]->val2 > 0)
        watk += (10 + 10 * sc->data[SC_BANDING]->val1) * (sc->data[SC_BANDING]->val2);
    if (sc->data[SC_TROPIC_OPTION])
        watk += sc->data[SC_TROPIC_OPTION]->val2;
    if (sc->data[SC_HEATER_OPTION])
        watk += sc->data[SC_HEATER_OPTION]->val2;
    if (sc->data[SC_WATER_BARRIER])
        watk -= sc->data[SC_WATER_BARRIER]->val3;
    if (sc->data[SC_PYROTECHNIC_OPTION])
        watk += sc->data[SC_PYROTECHNIC_OPTION]->val2;
    if ((sc->data[SC_FIRE_INSIGNIA] && sc->data[SC_FIRE_INSIGNIA]->val1 == 2)
        || (sc->data[SC_WATER_INSIGNIA] && sc->data[SC_WATER_INSIGNIA]->val1 == 2)
        || (sc->data[SC_WIND_INSIGNIA] && sc->data[SC_WIND_INSIGNIA]->val1 == 2)
        || (sc->data[SC_EARTH_INSIGNIA] && sc->data[SC_EARTH_INSIGNIA]->val1 == 2)
       )
        watk += watk / 10;
    if (sc && sc->data[SC_TIDAL_WEAPON])
        watk += watk * sc->data[SC_TIDAL_WEAPON]->val2 / 100;
    if (sc->data[SC_ANGRIFFS_MODUS])
        watk += watk * sc->data[SC_ANGRIFFS_MODUS]->val2/100;
#ifdef RENEWAL_EDP
    if (sc->data[SC_EDP])
        watk = watk * (100 + sc->data[SC_EDP]->val1 * 80) / 100;
#endif

    return (unsigned short)cap_value(watk,0,USHRT_MAX);
}

static unsigned short status_calc_matk(struct block_list *bl, struct status_change *sc, int matk)
{
    if (!sc || !sc->count)
        return cap_value(matk,0,USHRT_MAX);

    if (sc->data[SC_MATKPOTION])
        matk += sc->data[SC_MATKPOTION]->val1;
    if (sc->data[SC_MATKFOOD])
        matk += sc->data[SC_MATKFOOD]->val1;
    if (sc->data[SC_MAGICPOWER] && sc->data[SC_MAGICPOWER]->val4)
        matk += matk * sc->data[SC_MAGICPOWER]->val3/100;
    if (sc->data[SC_MINDBREAKER])
        matk += matk * sc->data[SC_MINDBREAKER]->val2/100;
    if (sc->data[SC_INCMATKRATE])
        matk += matk * sc->data[SC_INCMATKRATE]->val1/100;
    if (sc->data[SC_MOONLITSERENADE])
        matk += matk * sc->data[SC_MOONLITSERENADE]->val2/100;
    if (sc->data[SC_MELODYOFSINK])
        matk += matk * sc->data[SC_MELODYOFSINK]->val3/100;
    if (sc->data[SC_BEYONDOFWARCRY])
        matk -= matk * sc->data[SC_BEYONDOFWARCRY]->val3/100;
    if (sc->data[SC_MANA_PLUS])
        matk += sc->data[SC_MANA_PLUS]->val1;
    if (sc->data[SC_AQUAPLAY_OPTION])
        matk += sc->data[SC_AQUAPLAY_OPTION]->val2;
    if (sc->data[SC_CHILLY_AIR_OPTION])
        matk += sc->data[SC_CHILLY_AIR_OPTION]->val2;
    if (sc->data[SC_WATER_BARRIER])
        matk -= sc->data[SC_WATER_BARRIER]->val3;
    if (sc->data[SC_FIRE_INSIGNIA] && sc->data[SC_FIRE_INSIGNIA]->val1 == 3)
        matk += 50;
    if (sc->data[SC_ODINS_POWER])
        matk += 40 + 30 * sc->data[SC_ODINS_POWER]->val1; //70 lvl1, 100lvl2
    if (sc->data[SC_IZAYOI])
        matk += 50 * sc->data[SC_IZAYOI]->val1;
    if (sc->data[SC_ZANGETSU])
        matk += matk * sc->data[SC_ZANGETSU]->val2 / 100;

    return (unsigned short)cap_value(matk,0,USHRT_MAX);
}

static signed short status_calc_critical(struct block_list *bl, struct status_change *sc, int critical)
{

    if (!sc || !sc->count)
        return cap_value(critical,10,SHRT_MAX);

    if (sc->data[SC_INCCRI])
        critical += sc->data[SC_INCCRI]->val2;
    if (sc->data[SC_EXPLOSIONSPIRITS])
        critical += sc->data[SC_EXPLOSIONSPIRITS]->val2;
    if (sc->data[SC_FORTUNE])
        critical += sc->data[SC_FORTUNE]->val2;
    if (sc->data[SC_TRUESIGHT])
        critical += sc->data[SC_TRUESIGHT]->val2;
    if (sc->data[SC_CLOAKING])
        critical += critical;
    if (sc->data[SC_STRIKING])
        critical += sc->data[SC_STRIKING]->val1;
    if (sc->data[SC__INVISIBILITY])
        critical += critical * sc->data[SC__INVISIBILITY]->val3 / 100;
    if (sc->data[SC__UNLUCKY])
        critical -= critical * sc->data[SC__UNLUCKY]->val2 / 100;
#ifdef RENEWAL
    if (sc->data[SC_SPEARQUICKEN])
        critical += 3*sc->data[SC_SPEARQUICKEN]->val1*10;
#endif

    return (short)cap_value(critical,10,SHRT_MAX);
}

static signed short status_calc_hit(struct block_list *bl, struct status_change *sc, int hit)
{

    if (!sc || !sc->count)
        return cap_value(hit,1,SHRT_MAX);

    if (sc->data[SC_INCHIT])
        hit += sc->data[SC_INCHIT]->val1;
    if (sc->data[SC_HITFOOD])
        hit += sc->data[SC_HITFOOD]->val1;
    if (sc->data[SC_TRUESIGHT])
        hit += sc->data[SC_TRUESIGHT]->val3;
    if (sc->data[SC_HUMMING])
        hit += sc->data[SC_HUMMING]->val2;
    if (sc->data[SC_CONCENTRATION])
        hit += sc->data[SC_CONCENTRATION]->val3;
    if (sc->data[SC_INCHITRATE])
        hit += hit * sc->data[SC_INCHITRATE]->val1/100;
    if (sc->data[SC_BLIND])
        hit -= hit * 25/100;
    if (sc->data[SC_ADJUSTMENT])
        hit -= 30;
    if (sc->data[SC_INCREASING])
        hit += 20; // RockmanEXE; changed based on updated [Reddozen]
    if (sc->data[SC_MERC_HITUP])
        hit += sc->data[SC_MERC_HITUP]->val2;
    if (sc->data[SC__GROOMY])
        hit -= hit * sc->data[SC__GROOMY]->val3 / 100;
    if (sc->data[SC_FEAR])
        hit -= hit * 20 / 100;
    if (sc->data[SC_INSPIRATION])
        hit += 5 * sc->data[SC_INSPIRATION]->val1;
    if (sc->data[SC_ASH])
        hit /= 2;

    return (short)cap_value(hit,1,SHRT_MAX);
}

static signed short status_calc_flee(struct block_list *bl, struct status_change *sc, int flee)
{
    if (bl->type == BL_PC) {
        if (map_flag_gvg(bl->m))
            flee -= flee * battle_config.gvg_flee_penalty/100;
        else if (map[bl->m].flag.battleground)
            flee -= flee * battle_config.bg_flee_penalty/100;
    }

    if (!sc || !sc->count)
        return cap_value(flee,1,SHRT_MAX);

    if (sc->data[SC_INCFLEE])
        flee += sc->data[SC_INCFLEE]->val1;
    if (sc->data[SC_FLEEFOOD])
        flee += sc->data[SC_FLEEFOOD]->val1;
    if (sc->data[SC_WHISTLE])
        flee += sc->data[SC_WHISTLE]->val2;
    if (sc->data[SC_WINDWALK])
        flee += sc->data[SC_WINDWALK]->val2;
    if (sc->data[SC_INCFLEERATE])
        flee += flee * sc->data[SC_INCFLEERATE]->val1/100;
    if (sc->data[SC_VIOLENTGALE])
        flee += sc->data[SC_VIOLENTGALE]->val2;
    if (sc->data[SC_MOON_COMFORT]) //SG skill [Komurka]
        flee += sc->data[SC_MOON_COMFORT]->val2;
    if (sc->data[SC_CLOSECONFINE])
        flee += 10;
    if (sc->data[SC_SPIDERWEB] && sc->data[SC_SPIDERWEB]->val1)
        flee -= flee * 50/100;
    if (sc->data[SC_BERSERK] || sc->data[SC__BLOODYLUST])
        flee -= flee * 50/100;
    if (sc->data[SC_BLIND])
        flee -= flee * 25/100;
    if (sc->data[SC_ADJUSTMENT])
        flee += 30;
    if (sc->data[SC_GATLINGFEVER])
        flee -= sc->data[SC_GATLINGFEVER]->val4;
    if (sc->data[SC_SPEED])
        flee += 10 + sc->data[SC_SPEED]->val1 * 10;
    if (sc->data[SC_PARTYFLEE])
        flee += sc->data[SC_PARTYFLEE]->val1 * 10;
    if (sc->data[SC_MERC_FLEEUP])
        flee += sc->data[SC_MERC_FLEEUP]->val2;
    if (sc->data[SC_FEAR])
        flee -= flee * 20 / 100;
    if (sc->data[SC_PARALYSE])
        flee -= flee * 10 / 100; // 10% Flee reduction
    if (sc->data[SC_INFRAREDSCAN])
        flee -= flee * 30 / 100;
    if (sc->data[SC__LAZINESS])
        flee -= flee * sc->data[SC__LAZINESS]->val3 / 100;
    if (sc->data[SC_GLOOMYDAY])
        flee -= flee * sc->data[SC_GLOOMYDAY]->val2 / 100;
    if (sc->data[SC_HALLUCINATIONWALK])
        flee += sc->data[SC_HALLUCINATIONWALK]->val2;
    if (sc->data[SC_SATURDAYNIGHTFEVER])
        flee -= flee * (40 + 10 * sc->data[SC_SATURDAYNIGHTFEVER]->val1) / 100;
    if (sc->data[SC_WATER_BARRIER])
        flee -= sc->data[SC_WATER_BARRIER]->val3;
    if (sc->data[SC_WIND_STEP_OPTION])
        flee += flee * sc->data[SC_WIND_STEP_OPTION]->val2 / 100;
    if (sc->data[SC_ZEPHYR])
        flee += flee * sc->data[SC_ZEPHYR]->val2 / 100;
    if (sc->data[SC_MARSHOFABYSS])
        flee -= (9 * sc->data[SC_MARSHOFABYSS]->val3 / 10 + sc->data[SC_MARSHOFABYSS]->val2 / 10) * (bl->type == BL_MOB ? 2 : 1);
#ifdef RENEWAL
    if (sc->data[SC_SPEARQUICKEN])
        flee += 2 * sc->data[SC_SPEARQUICKEN]->val1;
#endif
    if (sc->data[SC_ANGRIFFS_MODUS])
        flee -= sc->data[SC_ANGRIFFS_MODUS]->val3;
    if (sc->data[SC_OVERED_BOOST])
        flee = max(flee,sc->data[SC_OVERED_BOOST]->val2);
    if (sc->data[SC_ASH] && (bl->type==BL_MOB)) { //mob
        if (status_get_element(bl) == ELE_WATER) //water type
            flee /= 2;
    }

    return (short)cap_value(flee,1,SHRT_MAX);
}

static signed short status_calc_flee2(struct block_list *bl, struct status_change *sc, int flee2)
{
    if (!sc || !sc->count)
        return cap_value(flee2,10,SHRT_MAX);

    if (sc->data[SC_INCFLEE2])
        flee2 += sc->data[SC_INCFLEE2]->val2;
    if (sc->data[SC_WHISTLE])
        flee2 += sc->data[SC_WHISTLE]->val3*10;
    if (sc->data[SC__UNLUCKY])
        flee2 -= flee2 * sc->data[SC__UNLUCKY]->val2 / 100;

    return (short)cap_value(flee2,10,SHRT_MAX);
}
static defType status_calc_def(struct block_list *bl, struct status_change *sc, int def)
{

    if (!sc || !sc->count)
        return (defType)cap_value(def,DEFTYPE_MIN,DEFTYPE_MAX);

    if (sc->data[SC_BERSERK] || sc->data[SC__BLOODYLUST])
        return 0;
    if (sc->data[SC_SKA])
        return sc->data[SC_SKA]->val3;
    if (sc->data[SC_BARRIER])
        return 100;
    if (sc->data[SC_KEEPING])
        return 90;
#ifndef RENEWAL // does not provide 90 DEF in renewal mode
    if (sc->data[SC_STEELBODY])
        return 90;
#endif

    if (sc->data[SC_ARMORCHANGE])
        def += sc->data[SC_ARMORCHANGE]->val2;
    if (sc->data[SC_DRUMBATTLE])
        def += sc->data[SC_DRUMBATTLE]->val3;
    if (sc->data[SC_DEFENCE])   //[orn]
        def += sc->data[SC_DEFENCE]->val2 ;
    if (sc->data[SC_INCDEFRATE])
        def += def * sc->data[SC_INCDEFRATE]->val1/100;
    if (sc->data[SC_STONE] && sc->opt1 == OPT1_STONE)
        def >>=1;
    if (sc->data[SC_FREEZE])
        def >>=1;
#ifdef RENEWAL
    if (sc->data[SC_ASSUMPTIO])
        def *= 2;
#endif
    if (sc->data[SC_SIGNUMCRUCIS])
        def -= def * sc->data[SC_SIGNUMCRUCIS]->val2/100;
    if (sc->data[SC_CONCENTRATION])
        def -= def * sc->data[SC_CONCENTRATION]->val4/100;
    if (sc->data[SC_SKE])
        def >>=1;
    if (sc->data[SC_PROVOKE] && bl->type != BL_PC) // Provoke doesn't alter player defense->
        def -= def * sc->data[SC_PROVOKE]->val4/100;
    if (sc->data[SC_STRIPSHIELD])
        def -= def * sc->data[SC_STRIPSHIELD]->val2/100;
    if (sc->data[SC_FLING])
        def -= def * (sc->data[SC_FLING]->val2)/100;
    if (sc->data[SC_STONEHARDSKIN]) // Final DEF increase divided by 10 since were using classic (pre-renewal) mechanics. [Rytech]
        def += sc->data[SC_STONEHARDSKIN]->val1;
    if (sc->data[SC_FREEZING])
        def -= def * 10 / 100;
    if (sc->data[SC_MARSHOFABYSS])
        def -= def * (6 + 6 * sc->data[SC_MARSHOFABYSS]->val3/10 + (bl->type == BL_MOB ? 5 : 3) * sc->data[SC_MARSHOFABYSS]->val2/36) / 100;
    if (sc->data[SC_ANALYZE])
        def -= def * (14 * sc->data[SC_ANALYZE]->val1) / 100;
    if (sc->data[SC_FORCEOFVANGUARD])
        def += def * 2 * sc->data[SC_FORCEOFVANGUARD]->val1 / 100;
    if (sc->data[SC_SATURDAYNIGHTFEVER])
        def -= def * (10 + 10 * sc->data[SC_SATURDAYNIGHTFEVER]->val1) / 100;
    if (sc->data[SC_EARTHDRIVE])
        def -= def * 25 / 100;
    if (sc->data[SC_ROCK_CRUSHER])
        def -= def * sc->data[SC_ROCK_CRUSHER]->val2 / 100;
    if (sc->data[SC_POWER_OF_GAIA])
        def += def * sc->data[SC_POWER_OF_GAIA]->val2 / 100;
    if (sc->data[SC_PRESTIGE])
        def += def * sc->data[SC_PRESTIGE]->val1 / 100;
    if (sc->data[SC_EARTH_INSIGNIA] && sc->data[SC_EARTH_INSIGNIA]->val1 == 2)
        def += 50;
    if (sc->data[SC_ODINS_POWER])
        def -= 20;
    if (sc->data[SC_ANGRIFFS_MODUS])
        def -= 30 + 20 * sc->data[SC_ANGRIFFS_MODUS]->val1;
    if (sc->data[SC_ASH] && (bl->type==BL_MOB)) {
        if (status_get_race(bl)==RC_PLANT)
            def /= 2;
    }

    return (defType)cap_value(def,DEFTYPE_MIN,DEFTYPE_MAX);;
}

static signed short status_calc_def2(struct block_list *bl, struct status_change *sc, int def2)
{
    if (!sc || !sc->count)
#ifdef RENEWAL
        return (short)cap_value(def2,SHRT_MIN,SHRT_MAX);
#else
        return (short)cap_value(def2,1,SHRT_MAX);
#endif

    if (sc->data[SC_BERSERK] || sc->data[SC__BLOODYLUST])
        return 0;
    if (sc->data[SC_ETERNALCHAOS])
        return 0;
    if (sc->data[SC_SUN_COMFORT])
        def2 += sc->data[SC_SUN_COMFORT]->val2;

    if (sc->data[SC_ANGELUS])
#ifdef RENEWAL //in renewal only the VIT stat bonus is boosted by angelus
        def2 += status_get_vit(bl) / 2 * sc->data[SC_ANGELUS]->val2/100;
#else
        def2 += def2 * sc->data[SC_ANGELUS]->val2/100;
#endif
    if (sc->data[SC_CONCENTRATION])
        def2 -= def2 * sc->data[SC_CONCENTRATION]->val4/100;
    if (sc->data[SC_POISON])
        def2 -= def2 * 25/100;
    if (sc->data[SC_DPOISON])
        def2 -= def2 * 25/100;
    if (sc->data[SC_SKE])
        def2 -= def2 * 50/100;
    if (sc->data[SC_PROVOKE])
        def2 -= def2 * sc->data[SC_PROVOKE]->val4/100;
#ifdef RENEWAL
    if (sc->data[SC_ASSUMPTIO])
        def2 *= 2;
#endif
    if (sc->data[SC_JOINTBEAT])
        def2 -= def2 * (sc->data[SC_JOINTBEAT]->val2&BREAK_SHOULDER ? 50 : 0) / 100
                + def2 * (sc->data[SC_JOINTBEAT]->val2&BREAK_WAIST ? 25 : 0) / 100;
    if (sc->data[SC_FLING])
        def2 -= def2 * (sc->data[SC_FLING]->val3)/100;
    if (sc->data[SC_FREEZING])
        def2 -= def2 * 3 / 10;
    if (sc->data[SC_ANALYZE])
        def2 -= def2 * (14 * sc->data[SC_ANALYZE]->val1) / 100;
    if (sc->data[SC_ECHOSONG])
        def2 += def2 * sc->data[SC_ECHOSONG]->val2/100;
    if (sc->data[SC_SHIELDSPELL_REF] && sc->data[SC_SHIELDSPELL_REF]->val1 == 1)
        def2 += sc->data[SC_SHIELDSPELL_REF]->val2;
    if (sc->data[SC_BANDING] && sc->data[SC_BANDING]->val2 > 0)
        def2 += (5 + sc->data[SC_BANDING]->val1) * (sc->data[SC_BANDING]->val2);
    if (sc->data[SC_GT_REVITALIZE] && sc->data[SC_GT_REVITALIZE]->val4)
        def2 += def2 * sc->data[SC_GT_REVITALIZE]->val4 / 100;
    if (sc->data[SC_ASH] && (bl->type==BL_MOB)) {
        if (status_get_race(bl)==RC_PLANT)
            def2 /= 2;
    }
    if (sc->data[SC_PARALYSIS])
        def2 -= def2 * sc->data[SC_PARALYSIS]->val2 / 100;

#ifdef RENEWAL
    return (short)cap_value(def2,SHRT_MIN,SHRT_MAX);
#else
    return (short)cap_value(def2,1,SHRT_MAX);
#endif
}


static defType status_calc_mdef(struct block_list *bl, struct status_change *sc, int mdef)
{

    if (!sc || !sc->count)
        return (defType)cap_value(mdef,DEFTYPE_MIN,DEFTYPE_MAX);

    if (sc->data[SC_BERSERK] || sc->data[SC__BLOODYLUST])
        return 0;
    if (sc->data[SC_BARRIER])
        return 100;

#ifndef RENEWAL // no longer provides 90 MDEF in renewal mode
    if (sc->data[SC_STEELBODY])
        return 90;
#endif

    if (sc->data[SC_ARMORCHANGE])
        mdef += sc->data[SC_ARMORCHANGE]->val3;
    if (sc->data[SC_STONE] && sc->opt1 == OPT1_STONE)
        mdef += 25*mdef/100;
    if (sc->data[SC_FREEZE])
        mdef += 25*mdef/100;
    if (sc->data[SC_ENDURE]) // It has been confirmed that eddga card grants 1 MDEF, not 0, not 10, but 1.
        mdef += (sc->data[SC_ENDURE]->val4 == 0) ? sc->data[SC_ENDURE]->val1 : 1;
    if (sc->data[SC_CONCENTRATION])
        mdef += 1; //Skill info says it adds a fixed 1 Mdef point.
#ifdef RENEWAL
    if (sc->data[SC_ASSUMPTIO])
        mdef *= 2;
#endif
    if (sc->data[SC_STONEHARDSKIN]) // Final MDEF increase divided by 10 since were using classic (pre-renewal) mechanics. [Rytech]
        mdef += sc->data[SC_STONEHARDSKIN]->val1;
    if (sc->data[SC_MARSHOFABYSS])
        mdef -= mdef * (6 + 6 * sc->data[SC_MARSHOFABYSS]->val3/10 + (bl->type == BL_MOB ? 5 : 3) * sc->data[SC_MARSHOFABYSS]->val2/36) / 100;
    if (sc->data[SC_ANALYZE])
        mdef -= mdef * (14 * sc->data[SC_ANALYZE]->val1) / 100;
    if (sc->data[SC_SYMPHONYOFLOVER])
        mdef += mdef * sc->data[SC_SYMPHONYOFLOVER]->val2 / 100;
    if (sc->data[SC_GT_CHANGE] && sc->data[SC_GT_CHANGE]->val4)
        mdef -= mdef * sc->data[SC_GT_CHANGE]->val4 / 100;
    if (sc->data[SC_WATER_BARRIER])
        mdef += sc->data[SC_WATER_BARRIER]->val2;
    if (sc->data[SC_ODINS_POWER])
        mdef -= 20 * sc->data[SC_ODINS_POWER]->val1;
    if (sc->data[SC_EARTH_INSIGNIA] && sc->data[SC_EARTH_INSIGNIA]->val1 == 3)
        mdef += 50;

    return (defType)cap_value(mdef,DEFTYPE_MIN,DEFTYPE_MAX);
}

static signed short status_calc_mdef2(struct block_list *bl, struct status_change *sc, int mdef2)
{
    if (!sc || !sc->count)
#ifdef RENEWAL
        return (short)cap_value(mdef2,SHRT_MIN,SHRT_MAX);
#else
        return (short)cap_value(mdef2,1,SHRT_MAX);
#endif


    if (sc->data[SC_BERSERK] || sc->data[SC__BLOODYLUST])
        return 0;
    if (sc->data[SC_SKA])
        return 90;
#ifdef RENEWAL
    if (sc->data[SC_ASSUMPTIO])
        mdef2 *= 2;
#endif
    if (sc->data[SC_MINDBREAKER])
        mdef2 -= mdef2 * sc->data[SC_MINDBREAKER]->val3/100;
    if (sc->data[SC_ANALYZE])
        mdef2 -= mdef2 * (14 * sc->data[SC_ANALYZE]->val1) / 100;

#ifdef RENEWAL
    return (short)cap_value(mdef2,SHRT_MIN,SHRT_MAX);
#else
    return (short)cap_value(mdef2,1,SHRT_MAX);
#endif
}

static unsigned short status_calc_speed(struct block_list *bl, struct status_change *sc, int speed)
{
    TBL_PC *sd = BL_CAST(BL_PC, bl);
    int speed_rate;

    if (sc == NULL)
        return cap_value(speed,10,USHRT_MAX);

    if (sd && sd->ud.skilltimer != INVALID_TIMER && (pc_checkskill(sd,SA_FREECAST) > 0 || sd->ud.skillid == LG_EXEEDBREAK)) {
        if (sd->ud.skillid == LG_EXEEDBREAK)
            speed_rate = 100 + 60 - (sd->ud.skilllv * 10);
        else
            speed_rate = 175 - 5 * pc_checkskill(sd,SA_FREECAST);
    } else {
        speed_rate = 100;

        //GetMoveHasteValue2()
        {
            int val = 0;

            if (sc->data[SC_FUSION])
                val = 25;
            else if (sd) {
                if (pc_isriding(sd) || sd->sc.option&(OPTION_DRAGON|OPTION_MOUNTING))
                    val = 25;//Same bonus
                else if (pc_isridingwug(sd))
                    val = 15 + 5 * pc_checkskill(sd, RA_WUGRIDER);
                else if (pc_ismadogear(sd)) {
                    val = (- 10 * (5 - pc_checkskill(sd,NC_MADOLICENCE)));
                    if (sc->data[SC_ACCELERATION])
                        val += 25;
                }
            }

            speed_rate -= val;
        }

        //GetMoveSlowValue()
        {
            int val = 0;

            if (sd && sc->data[SC_HIDING] && pc_checkskill(sd,RG_TUNNELDRIVE) > 0)
                val = 120 - 6 * pc_checkskill(sd,RG_TUNNELDRIVE);
            else if (sd && sc->data[SC_CHASEWALK] && sc->data[SC_CHASEWALK]->val3 < 0)
                val = sc->data[SC_CHASEWALK]->val3;
            else {
                // Longing for Freedom cancels song/dance penalty
                if (sc->data[SC_LONGING])
                    val = max(val, 50 - 10 * sc->data[SC_LONGING]->val1);
                else if (sd && sc->data[SC_DANCING])
                    val = max(val, 500 - (40 + 10 * (sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_BARDDANCER)) * pc_checkskill(sd,(sd->status.sex?BA_MUSICALLESSON:DC_DANCINGLESSON)));

                if (sc->data[SC_DECREASEAGI])
                    val = max(val, 25);
                if (sc->data[SC_QUAGMIRE] || sc->data[SC_HALLUCINATIONWALK_POSTDELAY] || (sc->data[SC_GLOOMYDAY] && sc->data[SC_GLOOMYDAY]->val4))
                    val = max(val, 50);
                if (sc->data[SC_DONTFORGETME])
                    val = max(val, sc->data[SC_DONTFORGETME]->val3);
                if (sc->data[SC_CURSE])
                    val = max(val, 300);
                if (sc->data[SC_CHASEWALK])
                    val = max(val, sc->data[SC_CHASEWALK]->val3);
                if (sc->data[SC_WEDDING])
                    val = max(val, 100);
                if (sc->data[SC_JOINTBEAT] && sc->data[SC_JOINTBEAT]->val2&(BREAK_ANKLE|BREAK_KNEE))
                    val = max(val, (sc->data[SC_JOINTBEAT]->val2&BREAK_ANKLE ? 50 : 0) + (sc->data[SC_JOINTBEAT]->val2&BREAK_KNEE ? 30 : 0));
                if (sc->data[SC_CLOAKING] && (sc->data[SC_CLOAKING]->val4&1) == 0)
                    val = max(val, sc->data[SC_CLOAKING]->val1 < 3 ? 300 : 30 - 3 * sc->data[SC_CLOAKING]->val1);
                if (sc->data[SC_GOSPEL] && sc->data[SC_GOSPEL]->val4 == BCT_ENEMY)
                    val = max(val, 75);
                if (sc->data[SC_SLOWDOWN])  // Slow Potion
                    val = max(val, 100);
                if (sc->data[SC_GATLINGFEVER])
                    val = max(val, 100);
                if (sc->data[SC_SUITON])
                    val = max(val, sc->data[SC_SUITON]->val3);
                if (sc->data[SC_SWOO])
                    val = max(val, 300);
                if (sc->data[SC_FREEZING])
                    val = max(val, 70);
                if (sc->data[SC_MARSHOFABYSS])
                    val = max(val, 40 + 10 * sc->data[SC_MARSHOFABYSS]->val1);
                if (sc->data[SC_CAMOUFLAGE] && (sc->data[SC_CAMOUFLAGE]->val3&1) == 0)
                    val = max(val, sc->data[SC_CAMOUFLAGE]->val1 < 3 ? 0 : 25 * (5 - sc->data[SC_CAMOUFLAGE]->val1));
                if (sc->data[SC__GROOMY])
                    val = max(val, sc->data[SC__GROOMY]->val2);
                if (sc->data[SC_STEALTHFIELD_MASTER])
                    val = max(val, 30);
                if (sc->data[SC_BANDING_DEFENCE])
                    val = max(val, sc->data[SC_BANDING_DEFENCE]->val1);  //+90% walking speed.
                if (sc->data[SC_ROCK_CRUSHER_ATK])
                    val = max(val, sc->data[SC_ROCK_CRUSHER_ATK]->val2);
                if (sc->data[SC_POWER_OF_GAIA])
                    val = max(val, sc->data[SC_POWER_OF_GAIA]->val2);
                if (sc->data[SC_MELON_BOMB])
                    val = max(val, sc->data[SC_MELON_BOMB]->val1);

                if (sd && sd->bonus.speed_rate + sd->bonus.speed_add_rate > 0)  // permanent item-based speedup
                    val = max(val, sd->bonus.speed_rate + sd->bonus.speed_add_rate);
            }

            speed_rate += val;
        }

        //GetMoveHasteValue1()
        {
            int val = 0;

            if (sc->data[SC_SPEEDUP1])  //FIXME: used both by NPC_AGIUP and Speed Potion script
                val = max(val, 50);
            if (sc->data[SC_INCREASEAGI])
                val = max(val, 25);
            if (sc->data[SC_WINDWALK])
                val = max(val, 2 * sc->data[SC_WINDWALK]->val1);
            if (sc->data[SC_CARTBOOST])
                val = max(val, 20);
            if (sd && (sd->class_&MAPID_UPPERMASK) == MAPID_ASSASSIN && pc_checkskill(sd,TF_MISS) > 0)
                val = max(val, 1 * pc_checkskill(sd,TF_MISS));
            if (sc->data[SC_CLOAKING] && (sc->data[SC_CLOAKING]->val4&1) == 1)
                val = max(val, sc->data[SC_CLOAKING]->val1 >= 10 ? 25 : 3 * sc->data[SC_CLOAKING]->val1 - 3);
            if (sc->data[SC_BERSERK] || sc->data[SC__BLOODYLUST])
                val = max(val, 25);
            if (sc->data[SC_RUN])
                val = max(val, 55);
            if (sc->data[SC_AVOID])
                val = max(val, 10 * sc->data[SC_AVOID]->val1);
            if (sc->data[SC_INVINCIBLE] && !sc->data[SC_INVINCIBLEOFF])
                val = max(val, 75);
            if (sc->data[SC_CLOAKINGEXCEED])
                val = max(val, sc->data[SC_CLOAKINGEXCEED]->val3);
            if (sc->data[SC_HOVERING])
                val = max(val, 10);
            if (sc->data[SC_GN_CARTBOOST])
                val = max(val, sc->data[SC_GN_CARTBOOST]->val2);
            if (sc->data[SC_SWINGDANCE])
                val = max(val, sc->data[SC_SWINGDANCE]->val2);
            if (sc->data[SC_WIND_STEP_OPTION])
                val = max(val, sc->data[SC_WIND_STEP_OPTION]->val2);

            //FIXME: official items use a single bonus for this [ultramage]
            if (sc->data[SC_SPEEDUP0])  // temporary item-based speedup
                val = max(val, 25);
            if (sd && sd->bonus.speed_rate + sd->bonus.speed_add_rate < 0)  // permanent item-based speedup
                val = max(val, -(sd->bonus.speed_rate + sd->bonus.speed_add_rate));

            speed_rate -= val;
        }

        if (speed_rate < 40)
            speed_rate = 40;
    }

    //GetSpeed()
    {
        if (sd && pc_iscarton(sd))
            speed += speed * (50 - 5 * pc_checkskill(sd,MC_PUSHCART)) / 100;
        if (sc->data[SC_PARALYSE])
            speed += speed * 50 / 100;
        if (speed_rate != 100)
            speed = speed * speed_rate / 100;
        if (sc->data[SC_STEELBODY])
            speed = 200;
        if (sc->data[SC_DEFENDER])
            speed = max(speed, 200);
        if (sc->data[SC_WALKSPEED] && sc->data[SC_WALKSPEED]->val1 > 0)  // ChangeSpeed
            speed = speed * 100 / sc->data[SC_WALKSPEED]->val1;
    }

    return (short)cap_value(speed,10,USHRT_MAX);
}

#ifdef RENEWAL_ASPD
// flag&1 - fixed value [malufett]
// flag&2 - percentage value
static short status_calc_aspd(struct block_list *bl, struct status_change *sc, short flag)
{
    int i, pots = 0, skills1 = 0, skills2 = 0;

    if (!sc || !sc->count)
        return 0;

    if (sc->data[i=SC_ASPDPOTION3] ||
        sc->data[i=SC_ASPDPOTION2] ||
        sc->data[i=SC_ASPDPOTION1] ||
        sc->data[i=SC_ASPDPOTION0])
        pots += sc->data[i]->val1;

    if (!sc->data[SC_QUAGMIRE]) {
        if (sc->data[SC_STAR_COMFORT])
            skills1 = 5; // needs more info

        if (sc->data[SC_TWOHANDQUICKEN] && skills1 < 7)
            skills1 = 7;

        if (sc->data[SC_ONEHAND] && skills1 < 7) skills1 = 7;

        if (sc->data[SC_MERC_QUICKEN] && skills1 < 7) // needs more info
            skills1 = 7;

        if (sc->data[SC_ADRENALINE2] && skills1 < 6)
            skills1 = 6;

        if (sc->data[SC_ADRENALINE] && skills1 < 7)
            skills1 = 7;

        if (sc->data[SC_SPEARQUICKEN] && skills1 < 7)
            skills1 = 7;

        if (sc->data[SC_GATLINGFEVER] && skills1 < 9) // needs more info
            skills1 = 9;

        if (sc->data[SC_FLEET] && skills1 < 5)
            skills1 = 5;

        if (sc->data[SC_ASSNCROS] &&
            skills1 < 5+1*sc->data[SC_ASSNCROS]->val1) { // needs more info
            if (bl->type!=BL_PC)
                skills1 = 4+1*sc->data[SC_ASSNCROS]->val1;
            else
                switch (((TBL_PC *)bl)->status.weapon) {
                    case W_BOW:
                    case W_REVOLVER:
                    case W_RIFLE:
                    case W_GATLING:
                    case W_SHOTGUN:
                    case W_GRENADE:
                        break;
                    default:
                        skills1 = 5+1*sc->data[SC_ASSNCROS]->val1;
                }
        }
    }

    if ((sc->data[SC_BERSERK] || sc->data[SC__BLOODYLUST]) &&    skills1 < 15)
        skills1 = 15;
    else if (sc->data[SC_MADNESSCANCEL] && skills1 < 15) // needs more info
        skills1 = 15;

    if (sc->data[SC_DONTFORGETME])
        skills2 -= sc->data[SC_DONTFORGETME]->val2; // needs more info
    if (sc->data[SC_LONGING])
        skills2 -= sc->data[SC_LONGING]->val2; // needs more info
    if (sc->data[SC_STEELBODY])
        skills2 -= 25;
    if (sc->data[SC_SKA])
        skills2 -= 25;
    if (sc->data[SC_DEFENDER])
        skills2 -= sc->data[SC_DEFENDER]->val4; // needs more info
    if (sc->data[SC_GOSPEL] && sc->data[SC_GOSPEL]->val4 == BCT_ENEMY) // needs more info
        skills2 -= 25;
    if (sc->data[SC_GRAVITATION])
        skills2 -= sc->data[SC_GRAVITATION]->val2; // needs more info
    if (sc->data[SC_JOINTBEAT]) { // needs more info
        if (sc->data[SC_JOINTBEAT]->val2&BREAK_WRIST)
            skills2 -= 25;
        if (sc->data[SC_JOINTBEAT]->val2&BREAK_KNEE)
            skills2 -= 10;
    }
    if (sc->data[SC_FREEZING])
        skills2 -= 30;
    if (sc->data[SC_HALLUCINATIONWALK_POSTDELAY])
        skills2 -= 50;
    if (sc->data[SC_PARALYSE])
        skills2 -= 10;
    if (sc->data[SC__BODYPAINT])
        skills2 -=  2 + 5 * sc->data[SC__BODYPAINT]->val1;
    if (sc->data[SC__INVISIBILITY])
        skills2 -= sc->data[SC__INVISIBILITY]->val2 ;
    if (sc->data[SC__GROOMY])
        skills2 -= sc->data[SC__GROOMY]->val2;
    if (sc->data[SC_SWINGDANCE])
        skills2 += sc->data[SC_SWINGDANCE]->val2;
    if (sc->data[SC_DANCEWITHWUG])
        skills2 += sc->data[SC_DANCEWITHWUG]->val3;
    if (sc->data[SC_GLOOMYDAY])
        skills2 -= sc->data[SC_GLOOMYDAY]->val3;
    if (sc->data[SC_EARTHDRIVE])
        skills2 -= 25;
    if (sc->data[SC_GT_CHANGE])
        skills2 += sc->data[SC_GT_CHANGE]->val3;
    if (sc->data[SC_MELON_BOMB])
        skills2 -= sc->data[SC_MELON_BOMB]->val1;
    if (sc->data[SC_BOOST500])
        skills2 += sc->data[SC_BOOST500]->val1;
    if (sc->data[SC_EXTRACT_SALAMINE_JUICE])
        skills2 += sc->data[SC_EXTRACT_SALAMINE_JUICE]->val1;
    if (sc->data[SC_INCASPDRATE])
        skills2 += sc->data[SC_INCASPDRATE]->val1;

    return (flag&1? (skills1 + pots) : skills2);
}
#endif

static short status_calc_fix_aspd(struct block_list *bl, struct status_change *sc, int aspd)
{
    if (!sc || !sc->count)
        return cap_value(aspd, 0, 2000);

    if (!sc->data[SC_QUAGMIRE]) {
        if (sc->data[SC_FIGHTINGSPIRIT])
            aspd += sc->data[SC_FIGHTINGSPIRIT]->val3;
        if ((sc->data[SC_GUST_OPTION]
             || sc->data[SC_BLAST_OPTION]
             || sc->data[SC_WILD_STORM_OPTION])
           )
            aspd -= 50; // ventus passive = +5 ASPD
        if (sc->data[SC_OVERED_BOOST]) {
            aspd = 2000 - sc->data[SC_OVERED_BOOST]->val3*10;
        }
        //  if(sc->data[SC_FIGHTINGSPIRIT] && sc->data[SC_FIGHTINGSPIRIT]->val2 )
        //      aspd -= (sd?pc_checkskill(sd, RK_RUNEMASTERY):10) * 4;
    }

    return cap_value(aspd, 0, 2000); // will be recap for proper bl anyway
}

/// Calculates an object's ASPD modifier (alters the base amotion value).
/// Note that the scale of aspd_rate is 1000 = 100%.
static short status_calc_aspd_rate(struct block_list *bl, struct status_change *sc, int aspd_rate)
{
    int i;

    if (!sc || !sc->count)
        return cap_value(aspd_rate,0,SHRT_MAX);

    if (!sc->data[SC_QUAGMIRE]) {
        int max = 0;
        if (sc->data[SC_STAR_COMFORT])
            max = sc->data[SC_STAR_COMFORT]->val2;

        if (sc->data[SC_TWOHANDQUICKEN] &&
            max < sc->data[SC_TWOHANDQUICKEN]->val2)
            max = sc->data[SC_TWOHANDQUICKEN]->val2;

        if (sc->data[SC_ONEHAND] &&
            max < sc->data[SC_ONEHAND]->val2)
            max = sc->data[SC_ONEHAND]->val2;

        if (sc->data[SC_MERC_QUICKEN] &&
            max < sc->data[SC_MERC_QUICKEN]->val2)
            max = sc->data[SC_MERC_QUICKEN]->val2;

        if (sc->data[SC_ADRENALINE2] &&
            max < sc->data[SC_ADRENALINE2]->val3)
            max = sc->data[SC_ADRENALINE2]->val3;

        if (sc->data[SC_ADRENALINE] &&
            max < sc->data[SC_ADRENALINE]->val3)
            max = sc->data[SC_ADRENALINE]->val3;

        if (sc->data[SC_SPEARQUICKEN] &&
            max < sc->data[SC_SPEARQUICKEN]->val2)
            max = sc->data[SC_SPEARQUICKEN]->val2;

        if (sc->data[SC_GATLINGFEVER] &&
            max < sc->data[SC_GATLINGFEVER]->val2)
            max = sc->data[SC_GATLINGFEVER]->val2;

        if (sc->data[SC_FLEET] &&
            max < sc->data[SC_FLEET]->val2)
            max = sc->data[SC_FLEET]->val2;

        if (sc->data[SC_ASSNCROS] &&
            max < sc->data[SC_ASSNCROS]->val2) {
            if (bl->type!=BL_PC)
                max = sc->data[SC_ASSNCROS]->val2;
            else
                switch (((TBL_PC *)bl)->status.weapon) {
                    case W_BOW:
                    case W_REVOLVER:
                    case W_RIFLE:
                    case W_GATLING:
                    case W_SHOTGUN:
                    case W_GRENADE:
                        break;
                    default:
                        max = sc->data[SC_ASSNCROS]->val2;
                }
        }
        aspd_rate -= max;

        if ((sc->data[SC_BERSERK] || sc->data[SC__BLOODYLUST]))
            aspd_rate -= 300;
        else if (sc->data[SC_MADNESSCANCEL])
            aspd_rate -= 200;
    }

    if (sc->data[i=SC_ASPDPOTION3] ||
        sc->data[i=SC_ASPDPOTION2] ||
        sc->data[i=SC_ASPDPOTION1] ||
        sc->data[i=SC_ASPDPOTION0])
        aspd_rate -= sc->data[i]->val2;

    if (sc->data[SC_DONTFORGETME])
        aspd_rate += 10 * sc->data[SC_DONTFORGETME]->val2;
    if (sc->data[SC_LONGING])
        aspd_rate += sc->data[SC_LONGING]->val2;
    if (sc->data[SC_STEELBODY])
        aspd_rate += 250;
    if (sc->data[SC_SKA])
        aspd_rate += 250;
    if (sc->data[SC_DEFENDER])
        aspd_rate += sc->data[SC_DEFENDER]->val4;
    if (sc->data[SC_GOSPEL] && sc->data[SC_GOSPEL]->val4 == BCT_ENEMY)
        aspd_rate += 250;
    if (sc->data[SC_GRAVITATION])
        aspd_rate += sc->data[SC_GRAVITATION]->val2;
    if (sc->data[SC_JOINTBEAT]) {
        if (sc->data[SC_JOINTBEAT]->val2&BREAK_WRIST)
            aspd_rate += 250;
        if (sc->data[SC_JOINTBEAT]->val2&BREAK_KNEE)
            aspd_rate += 100;
    }
    if (sc->data[SC_FREEZING])
        aspd_rate += 300;
    if (sc->data[SC_HALLUCINATIONWALK_POSTDELAY])
        aspd_rate += 500;
    if (sc->data[SC_FIGHTINGSPIRIT] && sc->data[SC_FIGHTINGSPIRIT]->val2)
        aspd_rate -= sc->data[SC_FIGHTINGSPIRIT]->val2;
    if (sc->data[SC_PARALYSE])
        aspd_rate += 100;
    if (sc->data[SC__BODYPAINT])
        aspd_rate +=  200 + 50 * sc->data[SC__BODYPAINT]->val1;
    if (sc->data[SC__INVISIBILITY])
        aspd_rate += sc->data[SC__INVISIBILITY]->val2 * 10 ;
    if (sc->data[SC__GROOMY])
        aspd_rate += sc->data[SC__GROOMY]->val2 * 10;
    if (sc->data[SC_SWINGDANCE])
        aspd_rate -= sc->data[SC_SWINGDANCE]->val2 * 10;
    if (sc->data[SC_DANCEWITHWUG])
        aspd_rate -= sc->data[SC_DANCEWITHWUG]->val3 * 10;
    if (sc->data[SC_GLOOMYDAY])
        aspd_rate += sc->data[SC_GLOOMYDAY]->val3 * 10;
    if (sc->data[SC_EARTHDRIVE])
        aspd_rate += 250;
    if (sc->data[SC_GT_CHANGE])
        aspd_rate -= sc->data[SC_GT_CHANGE]->val3 * 10;
    if (sc->data[SC_MELON_BOMB])
        aspd_rate += sc->data[SC_MELON_BOMB]->val1 * 10;
    if (sc->data[SC_BOOST500])
        aspd_rate -= sc->data[SC_BOOST500]->val1 *10;
    if (sc->data[SC_EXTRACT_SALAMINE_JUICE])
        aspd_rate -= sc->data[SC_EXTRACT_SALAMINE_JUICE]->val1 * 10;
    if (sc->data[SC_INCASPDRATE])
        aspd_rate -= sc->data[SC_INCASPDRATE]->val1 * 10;
    if (sc->data[SC_PAIN_KILLER])
        aspd_rate += sc->data[SC_PAIN_KILLER]->val2 * 10;
    if (sc->data[SC_GOLDENE_FERSE])
        aspd_rate -= sc->data[SC_GOLDENE_FERSE]->val3 * 10;

    return (short)cap_value(aspd_rate,0,SHRT_MAX);
}

static unsigned short status_calc_dmotion(struct block_list *bl, struct status_change *sc, int dmotion)
{
    if (!sc || !sc->count || map_flag_gvg(bl->m) || map[bl->m].flag.battleground)
        return cap_value(dmotion,0,USHRT_MAX);
    /**
     * It has been confirmed on official servers that MvP mobs have no dmotion even without endure
     **/
    if (sc->data[SC_ENDURE] || (bl->type == BL_MOB && (((TBL_MOB *)bl)->status.mode&MD_BOSS)))
        return 0;
    if (sc->data[SC_CONCENTRATION])
        return 0;
    if (sc->data[SC_RUN] || sc->data[SC_WUGDASH])
        return 0;

    return (unsigned short)cap_value(dmotion,0,USHRT_MAX);
}

static unsigned int status_calc_maxhp(struct block_list *bl, struct status_change *sc, unsigned int maxhp)
{
    if (!sc || !sc->count)
        return cap_value(maxhp,1,UINT_MAX);

    if (sc->data[SC_INCMHPRATE])
        maxhp += maxhp * sc->data[SC_INCMHPRATE]->val1/100;
    if (sc->data[SC_INCMHP])
        maxhp += (sc->data[SC_INCMHP]->val1);
    if (sc->data[SC_APPLEIDUN])
        maxhp += maxhp * sc->data[SC_APPLEIDUN]->val2/100;
    if (sc->data[SC_DELUGE])
        maxhp += maxhp * sc->data[SC_DELUGE]->val2/100;
    if (sc->data[SC_BERSERK] || sc->data[SC__BLOODYLUST])
        maxhp += maxhp * 2;
    if (sc->data[SC_MARIONETTE])
        maxhp -= 1000;

    if (sc->data[SC_MERC_HPUP])
        maxhp += maxhp * sc->data[SC_MERC_HPUP]->val2/100;

    if (sc->data[SC_EPICLESIS])
        maxhp += maxhp * 5 * sc->data[SC_EPICLESIS]->val1 / 100;
    if (sc->data[SC_VENOMBLEED])
        maxhp -= maxhp * 15 / 100;
    if (sc->data[SC__WEAKNESS])
        maxhp -= maxhp * sc->data[SC__WEAKNESS]->val2 / 100;
    if (sc->data[SC_LERADSDEW])
        maxhp += maxhp * sc->data[SC_LERADSDEW]->val3 / 100;
    if (sc->data[SC_FORCEOFVANGUARD])
        maxhp += maxhp * 3 * sc->data[SC_FORCEOFVANGUARD]->val1 / 100;
    if (sc->data[SC_INSPIRATION]) //Custom value.
        maxhp += maxhp * 3 * sc->data[SC_INSPIRATION]->val1 / 100;
    if (sc->data[SC_RAISINGDRAGON])
        maxhp += maxhp * (2 + sc->data[SC_RAISINGDRAGON]->val1) / 100;
    if (sc->data[SC_GT_CHANGE]) // Max HP decrease: [Skill Level x 4] %
        maxhp -= maxhp * (4 * sc->data[SC_GT_CHANGE]->val1) / 100;
    if (sc->data[SC_GT_REVITALIZE]) // Max HP increase: [Skill Level x 2] %
        maxhp += maxhp * (2 * sc->data[SC_GT_REVITALIZE]->val1) / 100;
    if (sc->data[SC_MUSTLE_M])
        maxhp += maxhp * sc->data[SC_MUSTLE_M]->val1/100;
    if (sc->data[SC_SOLID_SKIN_OPTION])
        maxhp += 2000;// Fix amount.
    if (sc->data[SC_POWER_OF_GAIA])
        maxhp += 3000;
    if (sc->data[SC_MYSTERIOUS_POWDER])
        maxhp -= sc->data[SC_MYSTERIOUS_POWDER]->val1 / 100;
    if (sc->data[SC_EARTH_INSIGNIA] && sc->data[SC_EARTH_INSIGNIA]->val1 == 2)
        maxhp += 500;
    if (sc->data[SC_ANGRIFFS_MODUS])
        maxhp += maxhp * 5 * sc->data[SC_ANGRIFFS_MODUS]->val1 /100;
    if (sc->data[SC_GOLDENE_FERSE])
        maxhp += (maxhp * sc->data[SC_GOLDENE_FERSE]->val2) / 100;

    return cap_value(maxhp,1,UINT_MAX);
}

static unsigned int status_calc_maxsp(struct block_list *bl, struct status_change *sc, unsigned int maxsp)
{
    if (!sc || !sc->count)
        return cap_value(maxsp,1,UINT_MAX);

    if (sc->data[SC_INCMSPRATE])
        maxsp += maxsp * sc->data[SC_INCMSPRATE]->val1/100;
    if (sc->data[SC_INCMSP])
        maxsp += (sc->data[SC_INCMSP]->val1);
    if (sc->data[SC_SERVICE4U])
        maxsp += maxsp * sc->data[SC_SERVICE4U]->val2/100;
    if (sc->data[SC_MERC_SPUP])
        maxsp += maxsp * sc->data[SC_MERC_SPUP]->val2/100;
    if (sc->data[SC_RAISINGDRAGON])
        maxsp += maxsp * (2 + sc->data[SC_RAISINGDRAGON]->val1) / 100;
    if (sc->data[SC_LIFE_FORCE_F])
        maxsp += maxsp * sc->data[SC_LIFE_FORCE_F]->val1/100;
    if (sc->data[SC_EARTH_INSIGNIA] && sc->data[SC_EARTH_INSIGNIA]->val1 == 3)
        maxsp += 50;

    return cap_value(maxsp,1,UINT_MAX);
}

static unsigned char status_calc_element(struct block_list *bl, struct status_change *sc, int element)
{
    if (!sc || !sc->count)
        return element;

    if (sc->data[SC_FREEZE])
        return ELE_WATER;
    if (sc->data[SC_STONE] && sc->opt1 == OPT1_STONE)
        return ELE_EARTH;
    if (sc->data[SC_BENEDICTIO])
        return ELE_HOLY;
    if (sc->data[SC_CHANGEUNDEAD])
        return ELE_UNDEAD;
    if (sc->data[SC_ELEMENTALCHANGE])
        return sc->data[SC_ELEMENTALCHANGE]->val2;
    if (sc->data[SC_SHAPESHIFT])
        return sc->data[SC_SHAPESHIFT]->val2;

    return (unsigned char)cap_value(element,0,UCHAR_MAX);
}

static unsigned char status_calc_element_lv(struct block_list *bl, struct status_change *sc, int lv)
{
    if (!sc || !sc->count)
        return lv;

    if (sc->data[SC_FREEZE])
        return 1;
    if (sc->data[SC_STONE] && sc->opt1 == OPT1_STONE)
        return 1;
    if (sc->data[SC_BENEDICTIO])
        return 1;
    if (sc->data[SC_CHANGEUNDEAD])
        return 1;
    if (sc->data[SC_ELEMENTALCHANGE])
        return sc->data[SC_ELEMENTALCHANGE]->val1;
    if (sc->data[SC_SHAPESHIFT])
        return 1;
    if (sc->data[SC__INVISIBILITY])
        return 1;

    return (unsigned char)cap_value(lv,1,4);
}


unsigned char status_calc_attack_element(struct block_list *bl, struct status_change *sc, int element)
{
    if (!sc || !sc->count)
        return element;
    if (sc->data[SC_ENCHANTARMS])
        return sc->data[SC_ENCHANTARMS]->val2;
    if (sc->data[SC_WATERWEAPON]
        || (sc->data[SC_WATER_INSIGNIA] && sc->data[SC_WATER_INSIGNIA]->val1 == 2))
        return ELE_WATER;
    if (sc->data[SC_EARTHWEAPON]
        || (sc->data[SC_EARTH_INSIGNIA] && sc->data[SC_EARTH_INSIGNIA]->val1 == 2))
        return ELE_EARTH;
    if (sc->data[SC_FIREWEAPON]
        || (sc->data[SC_FIRE_INSIGNIA] && sc->data[SC_FIRE_INSIGNIA]->val1 == 2))
        return ELE_FIRE;
    if (sc->data[SC_WINDWEAPON]
        || (sc->data[SC_WIND_INSIGNIA] && sc->data[SC_WIND_INSIGNIA]->val1 == 2))
        return ELE_WIND;
    if (sc->data[SC_ENCPOISON])
        return ELE_POISON;
    if (sc->data[SC_ASPERSIO])
        return ELE_HOLY;
    if (sc->data[SC_SHADOWWEAPON])
        return ELE_DARK;
    if (sc->data[SC_GHOSTWEAPON] || sc->data[SC__INVISIBILITY])
        return ELE_GHOST;
    if (sc->data[SC_TIDAL_WEAPON_OPTION] || sc->data[SC_TIDAL_WEAPON])
        return ELE_WATER;
    if (sc->data[SC_PYROCLASTIC])
        return ELE_FIRE;
    return (unsigned char)cap_value(element,0,UCHAR_MAX);
}

static unsigned short status_calc_mode(struct block_list *bl, struct status_change *sc, int mode)
{
    if (!sc || !sc->count)
        return mode;
    if (sc->data[SC_MODECHANGE]) {
        if (sc->data[SC_MODECHANGE]->val2)
            mode = sc->data[SC_MODECHANGE]->val2; //Set mode
        if (sc->data[SC_MODECHANGE]->val3)
            mode|= sc->data[SC_MODECHANGE]->val3; //Add mode
        if (sc->data[SC_MODECHANGE]->val4)
            mode&=~sc->data[SC_MODECHANGE]->val4; //Del mode
    }
    return cap_value(mode,0,USHRT_MAX);
}

const char *status_get_name(struct block_list *bl)
{
    nullpo_ret(bl);
    switch (bl->type) {
        case BL_PC:
            return ((TBL_PC *)bl)->fakename[0] != '\0' ? ((TBL_PC *)bl)->fakename : ((TBL_PC *)bl)->status.name;
        case BL_MOB:
            return ((TBL_MOB *)bl)->name;
        case BL_PET:
            return ((TBL_PET *)bl)->pet.name;
        case BL_HOM:
            return ((TBL_HOM *)bl)->homunculus.name;
        case BL_NPC:
            return ((TBL_NPC *)bl)->name;
    }
    return "Unknown";
}

/*==========================================
 * Get the class of the current bl
 * return
 *  0 = fail
 *  class_id = success
 *------------------------------------------*/
int status_get_class(struct block_list *bl)
{
    nullpo_ret(bl);
    switch (bl->type) {
        case BL_PC:
            return ((TBL_PC *)bl)->status.class_;
        case BL_MOB:
            return ((TBL_MOB *)bl)->vd->class_; //Class used on all code should be the view class of the mob.
        case BL_PET:
            return ((TBL_PET *)bl)->pet.class_;
        case BL_HOM:
            return ((TBL_HOM *)bl)->homunculus.class_;
        case BL_MER:
            return ((TBL_MER *)bl)->mercenary.class_;
        case BL_NPC:
            return ((TBL_NPC *)bl)->class_;
        case BL_ELEM:
            return ((TBL_ELEM *)bl)->elemental.class_;
    }
    return 0;
}
/*==========================================
 * Get the base level of the current bl
 * return
 *  1 = fail
 *  level = success
 *------------------------------------------*/
int status_get_lv(struct block_list *bl)
{
    nullpo_ret(bl);
    switch (bl->type) {
        case BL_PC:
            return ((TBL_PC *)bl)->status.base_level;
        case BL_MOB:
            return ((TBL_MOB *)bl)->level;
        case BL_PET:
            return ((TBL_PET *)bl)->pet.level;
        case BL_HOM:
            return ((TBL_HOM *)bl)->homunculus.level;
        case BL_MER:
            return ((TBL_MER *)bl)->db->lv;
        case BL_ELEM:
            return ((TBL_ELEM *)bl)->db->lv;
    }
    return 1;
}

struct regen_data *status_get_regen_data(struct block_list *bl) {
    nullpo_retr(NULL, bl);
    switch (bl->type) {
        case BL_PC:
            return &((TBL_PC *)bl)->regen;
        case BL_HOM:
            return &((TBL_HOM *)bl)->regen;
        case BL_MER:
            return &((TBL_MER *)bl)->regen;
        case BL_ELEM:
            return &((TBL_ELEM *)bl)->regen;
        default:
            return NULL;
    }
}

struct status_data *status_get_status_data(struct block_list *bl) {
    nullpo_retr(&dummy_status, bl);

    switch (bl->type) {
        case BL_PC:
            return &((TBL_PC *)bl)->battle_status;
        case BL_MOB:
            return &((TBL_MOB *)bl)->status;
        case BL_PET:
            return &((TBL_PET *)bl)->status;
        case BL_HOM:
            return &((TBL_HOM *)bl)->battle_status;
        case BL_MER:
            return &((TBL_MER *)bl)->battle_status;
        case BL_ELEM:
            return &((TBL_ELEM *)bl)->battle_status;
        default:
            return &dummy_status;
    }
}

struct status_data *status_get_base_status(struct block_list *bl) {
    nullpo_retr(NULL, bl);
    switch (bl->type) {
        case BL_PC:
            return &((TBL_PC *)bl)->base_status;
        case BL_MOB:
            return ((TBL_MOB *)bl)->base_status ? ((TBL_MOB *)bl)->base_status : &((TBL_MOB *)bl)->db->status;
        case BL_PET:
            return &((TBL_PET *)bl)->db->status;
        case BL_HOM:
            return &((TBL_HOM *)bl)->base_status;
        case BL_MER:
            return &((TBL_MER *)bl)->base_status;
        case BL_ELEM:
            return &((TBL_ELEM *)bl)->base_status;
        default:
            return NULL;
    }
}
defType status_get_def(struct block_list *bl)
{
    struct unit_data *ud;
    struct status_data *status = status_get_status_data(bl);
    int def = status?status->def:0;
    ud = unit_bl2ud(bl);
    if (ud && ud->skilltimer != INVALID_TIMER)
        def -= def * skill_get_castdef(ud->skillid)/100;

    return cap_value(def, DEFTYPE_MIN, DEFTYPE_MAX);
}

unsigned short status_get_speed(struct block_list *bl)
{
    if (bl->type==BL_NPC) //Only BL with speed data but no status_data [Skotlex]
        return ((struct npc_data *)bl)->speed;
    return status_get_status_data(bl)->speed;
}

int status_get_party_id(struct block_list *bl)
{
    nullpo_ret(bl);
    switch (bl->type) {
        case BL_PC:
            return ((TBL_PC *)bl)->status.party_id;
        case BL_PET:
            if (((TBL_PET *)bl)->msd)
                return ((TBL_PET *)bl)->msd->status.party_id;
            break;
        case BL_MOB: {
                struct mob_data *md=(TBL_MOB *)bl;
                if (md->master_id > 0) {
                    struct map_session_data *msd;
                    if (md->special_state.ai && (msd = map_id2sd(md->master_id)) != NULL)
                        return msd->status.party_id;
                    return -md->master_id;
                }
            }
            break;
        case BL_HOM:
            if (((TBL_HOM *)bl)->master)
                return ((TBL_HOM *)bl)->master->status.party_id;
            break;
        case BL_MER:
            if (((TBL_MER *)bl)->master)
                return ((TBL_MER *)bl)->master->status.party_id;
            break;
        case BL_SKILL:
            return ((TBL_SKILL *)bl)->group->party_id;
        case BL_ELEM:
            if (((TBL_ELEM *)bl)->master)
                return ((TBL_ELEM *)bl)->master->status.party_id;
            break;
    }
    return 0;
}

int status_get_guild_id(struct block_list *bl)
{
    nullpo_ret(bl);
    switch (bl->type) {
        case BL_PC:
            return ((TBL_PC *)bl)->status.guild_id;
        case BL_PET:
            if (((TBL_PET *)bl)->msd)
                return ((TBL_PET *)bl)->msd->status.guild_id;
            break;
        case BL_MOB: {
                struct map_session_data *msd;
                struct mob_data *md = (struct mob_data *)bl;
                if (md->guardian_data)  //Guardian's guild [Skotlex]
                    return md->guardian_data->guild_id;
                if (md->special_state.ai && (msd = map_id2sd(md->master_id)) != NULL)
                    return msd->status.guild_id; //Alchemist's mobs [Skotlex]
            }
            break;
        case BL_HOM:
            if (((TBL_HOM *)bl)->master)
                return ((TBL_HOM *)bl)->master->status.guild_id;
            break;
        case BL_MER:
            if (((TBL_MER *)bl)->master)
                return ((TBL_MER *)bl)->master->status.guild_id;
            break;
        case BL_NPC:
            if (((TBL_NPC *)bl)->subtype == SCRIPT)
                return ((TBL_NPC *)bl)->u.scr.guild_id;
            break;
        case BL_SKILL:
            return ((TBL_SKILL *)bl)->group->guild_id;
        case BL_ELEM:
            if (((TBL_ELEM *)bl)->master)
                return ((TBL_ELEM *)bl)->master->status.guild_id;
            break;
    }
    return 0;
}

int status_get_emblem_id(struct block_list *bl)
{
    nullpo_ret(bl);
    switch (bl->type) {
        case BL_PC:
            return ((TBL_PC *)bl)->guild_emblem_id;
        case BL_PET:
            if (((TBL_PET *)bl)->msd)
                return ((TBL_PET *)bl)->msd->guild_emblem_id;
            break;
        case BL_MOB: {
                struct map_session_data *msd;
                struct mob_data *md = (struct mob_data *)bl;
                if (md->guardian_data)  //Guardian's guild [Skotlex]
                    return md->guardian_data->emblem_id;
                if (md->special_state.ai && (msd = map_id2sd(md->master_id)) != NULL)
                    return msd->guild_emblem_id; //Alchemist's mobs [Skotlex]
            }
            break;
        case BL_HOM:
            if (((TBL_HOM *)bl)->master)
                return ((TBL_HOM *)bl)->master->guild_emblem_id;
            break;
        case BL_MER:
            if (((TBL_MER *)bl)->master)
                return ((TBL_MER *)bl)->master->guild_emblem_id;
            break;
        case BL_NPC:
            if (((TBL_NPC *)bl)->subtype == SCRIPT && ((TBL_NPC *)bl)->u.scr.guild_id > 0) {
                struct guild *g = guild_search(((TBL_NPC *)bl)->u.scr.guild_id);
                if (g)
                    return g->emblem_id;
            }
            break;
        case BL_ELEM:
            if (((TBL_ELEM *)bl)->master)
                return ((TBL_ELEM *)bl)->master->guild_emblem_id;
            break;
    }
    return 0;
}

int status_get_mexp(struct block_list *bl)
{
    nullpo_ret(bl);
    if (bl->type==BL_MOB)
        return ((struct mob_data *)bl)->db->mexp;
    if (bl->type==BL_PET)
        return ((struct pet_data *)bl)->db->mexp;
    return 0;
}
int status_get_race2(struct block_list *bl)
{
    nullpo_ret(bl);
    if (bl->type == BL_MOB)
        return ((struct mob_data *)bl)->db->race2;
    if (bl->type==BL_PET)
        return ((struct pet_data *)bl)->db->race2;
    return 0;
}

int status_isdead(struct block_list *bl)
{
    nullpo_ret(bl);
    return status_get_status_data(bl)->hp == 0;
}

int status_isimmune(struct block_list *bl)
{
    struct status_change *sc =status_get_sc(bl);
    if (sc && sc->data[SC_HERMODE])
        return 100;

    if (bl->type == BL_PC &&
        ((TBL_PC *)bl)->special_state.no_magic_damage >= battle_config.gtb_sc_immunity)
        return ((TBL_PC *)bl)->special_state.no_magic_damage;
    return 0;
}

struct view_data *status_get_viewdata(struct block_list *bl) {
    nullpo_retr(NULL, bl);
    switch (bl->type) {
        case BL_PC:
            return &((TBL_PC *)bl)->vd;
        case BL_MOB:
            return ((TBL_MOB *)bl)->vd;
        case BL_PET:
            return &((TBL_PET *)bl)->vd;
        case BL_NPC:
            return ((TBL_NPC *)bl)->vd;
        case BL_HOM:
            return ((TBL_HOM *)bl)->vd;
        case BL_MER:
            return ((TBL_MER *)bl)->vd;
        case BL_ELEM:
            return ((TBL_ELEM *)bl)->vd;
    }
    return NULL;
}

void status_set_viewdata(struct block_list *bl, int class_)
{
    struct view_data *vd;
    nullpo_retv(bl);
    if (mobdb_checkid(class_) || mob_is_clone(class_))
        vd = mob_get_viewdata(class_);
    else if (npcdb_checkid(class_) || (bl->type == BL_NPC && class_ == WARP_CLASS))
        vd = npc_get_viewdata(class_);
    else if (homdb_checkid(class_))
        vd = merc_get_hom_viewdata(class_);
    else if (merc_class(class_))
        vd = merc_get_viewdata(class_);
    else if (elemental_class(class_))
        vd = elemental_get_viewdata(class_);
    else
        vd = NULL;

    switch (bl->type) {
        case BL_PC: {
                TBL_PC *sd = (TBL_PC *)bl;
                if (pcdb_checkid(class_)) {
                    if (sd->sc.option&OPTION_WEDDING)
                        class_ = JOB_WEDDING;
                    else if (sd->sc.option&OPTION_SUMMER)
                        class_ = JOB_SUMMER;
                    else if (sd->sc.option&OPTION_XMAS)
                        class_ = JOB_XMAS;
                    else if (sd->sc.option&OPTION_RIDING) {
                        switch (class_) {   //Adapt class to a Mounted one.
                            case JOB_KNIGHT:
                                class_ = JOB_KNIGHT2;
                                break;
                            case JOB_CRUSADER:
                                class_ = JOB_CRUSADER2;
                                break;
                            case JOB_LORD_KNIGHT:
                                class_ = JOB_LORD_KNIGHT2;
                                break;
                            case JOB_PALADIN:
                                class_ = JOB_PALADIN2;
                                break;
                            case JOB_BABY_KNIGHT:
                                class_ = JOB_BABY_KNIGHT2;
                                break;
                            case JOB_BABY_CRUSADER:
                                class_ = JOB_BABY_CRUSADER2;
                                break;
                        }
                    }
                    sd->vd.class_ = class_;
                    clif_get_weapon_view(sd, &sd->vd.weapon, &sd->vd.shield);
                    sd->vd.head_top = sd->status.head_top;
                    sd->vd.head_mid = sd->status.head_mid;
                    sd->vd.head_bottom = sd->status.head_bottom;
                    sd->vd.hair_style = cap_value(sd->status.hair,0,battle_config.max_hair_style);
                    sd->vd.hair_color = cap_value(sd->status.hair_color,0,battle_config.max_hair_color);
                    sd->vd.cloth_color = cap_value(sd->status.clothes_color,0,battle_config.max_cloth_color);
                    sd->vd.sex = sd->status.sex;
                } else if (vd)
                    memcpy(&sd->vd, vd, sizeof(struct view_data));
                else
                    ShowError("status_set_viewdata (PC): No view data for class %d\n", class_);
            }
            break;
        case BL_MOB: {
                TBL_MOB *md = (TBL_MOB *)bl;
                if (vd)
                    md->vd = vd;
                else
                    ShowError("status_set_viewdata (MOB): No view data for class %d\n", class_);
            }
            break;
        case BL_PET: {
                TBL_PET *pd = (TBL_PET *)bl;
                if (vd) {
                    memcpy(&pd->vd, vd, sizeof(struct view_data));
                    if (!pcdb_checkid(vd->class_)) {
                        pd->vd.hair_style = battle_config.pet_hair_style;
                        if (pd->pet.equip) {
                            pd->vd.head_bottom = itemdb_viewid(pd->pet.equip);
                            if (!pd->vd.head_bottom)
                                pd->vd.head_bottom = pd->pet.equip;
                        }
                    }
                } else
                    ShowError("status_set_viewdata (PET): No view data for class %d\n", class_);
            }
            break;
        case BL_NPC: {
                TBL_NPC *nd = (TBL_NPC *)bl;
                if (vd)
                    nd->vd = vd;
                else
                    ShowError("status_set_viewdata (NPC): No view data for class %d\n", class_);
            }
            break;
        case BL_HOM: {      //[blackhole89]
                struct homun_data *hd = (struct homun_data *)bl;
                if (vd)
                    hd->vd = vd;
                else
                    ShowError("status_set_viewdata (HOMUNCULUS): No view data for class %d\n", class_);
            }
            break;
        case BL_MER: {
                struct mercenary_data *md = (struct mercenary_data *)bl;
                if (vd)
                    md->vd = vd;
                else
                    ShowError("status_set_viewdata (MERCENARY): No view data for class %d\n", class_);
            }
            break;
        case BL_ELEM: {
                struct elemental_data *ed = (struct elemental_data *)bl;
                if (vd)
                    ed->vd = vd;
                else
                    ShowError("status_set_viewdata (ELEMENTAL): No view data for class %d\n", class_);
            }
            break;
    }
    vd = status_get_viewdata(bl);
    if (vd && vd->cloth_color && (
            (vd->class_==JOB_WEDDING && battle_config.wedding_ignorepalette)
            || (vd->class_==JOB_XMAS && battle_config.xmas_ignorepalette)
            || (vd->class_==JOB_SUMMER && battle_config.summer_ignorepalette)
        ))
        vd->cloth_color = 0;
}

/// Returns the status_change data of bl or NULL if it doesn't exist.
struct status_change *status_get_sc(struct block_list *bl) {
    if (bl)
        switch (bl->type) {
            case BL_PC:
                return &((TBL_PC *)bl)->sc;
            case BL_MOB:
                return &((TBL_MOB *)bl)->sc;
            case BL_NPC:
                return &((TBL_NPC *)bl)->sc;
            case BL_HOM:
                return &((TBL_HOM *)bl)->sc;
            case BL_MER:
                return &((TBL_MER *)bl)->sc;
            case BL_ELEM:
                return &((TBL_ELEM *)bl)->sc;
        }
    return NULL;
}

void status_change_init(struct block_list *bl)
{
    struct status_change *sc = status_get_sc(bl);
    nullpo_retv(sc);
    memset(sc, 0, sizeof(struct status_change));
}

//Applies SC defense to a given status change.
//Returns the adjusted duration based on flag values.
//the flag values are the same as in status_change_start.
int status_get_sc_def(struct block_list *bl, enum sc_type type, int rate, int tick, int flag)
{
    int sc_def = 0, tick_def = 0;
    struct status_data *status;
    struct status_change *sc;
    struct map_session_data *sd;

    nullpo_ret(bl);

    //Status that are blocked by Golden Thief Bug card or Wand of Hermod
    if (status_isimmune(bl))
        switch (type) {
            case SC_DECREASEAGI:
            case SC_SILENCE:
            case SC_COMA:
            case SC_INCREASEAGI:
            case SC_BLESSING:
            case SC_SLOWPOISON:
            case SC_IMPOSITIO:
            case SC_AETERNA:
            case SC_SUFFRAGIUM:
            case SC_BENEDICTIO:
            case SC_PROVIDENCE:
            case SC_KYRIE:
            case SC_ASSUMPTIO:
            case SC_ANGELUS:
            case SC_MAGNIFICAT:
            case SC_GLORIA:
            case SC_WINDWALK:
            case SC_MAGICROD:
            case SC_HALLUCINATION:
            case SC_STONE:
            case SC_QUAGMIRE:
            case SC_SUITON:
            case SC_SWINGDANCE:
            case SC__ENERVATION:
            case SC__GROOMY:
            case SC__IGNORANCE:
            case SC__LAZINESS:
            case SC__UNLUCKY:
            case SC__WEAKNESS:
            case SC__BLOODYLUST:
                return 0;
        }

    sd = BL_CAST(BL_PC,bl);
    status = status_get_status_data(bl);
    sc = status_get_sc(bl);
    if (sc && !sc->count)
        sc = NULL;
    switch (type) {
        case SC_STUN:
        case SC_POISON:
            if (sc && sc->data[SC__UNLUCKY])
                return tick;
        case SC_DPOISON:
        case SC_SILENCE:
        case SC_BLEEDING:
            sc_def = 3 +status->vit;
            break;
        case SC_SLEEP:
            sc_def = 3 +status->int_;
            break;
        case SC_DEEPSLEEP:
            tick_def = status->int_ / 10 + status_get_lv(bl) * 65 / 1000; // Seems to be -1 sec every 10 int and -5% chance every 10 int.
            sc_def = 5 * status->int_ /10;
            break;
        case SC_DECREASEAGI:
        case SC_ADORAMUS://Arch Bishop
            if (sd) tick>>=1; //Half duration for players.
        case SC_STONE:
        case SC_FREEZE:
            sc_def = 3 +status->mdef;
            break;
        case SC_CURSE:
            //Special property: inmunity when luk is greater than level or zero
            if (status->luk > status_get_lv(bl) || status->luk == 0)
                return 0;
            else
                sc_def = 3 +status->luk;
            tick_def = status->vit;
            break;
        case SC_BLIND:
            if (sc && sc->data[SC__UNLUCKY])
                return tick;
            sc_def = 3 +(status->vit + status->int_)/2;
            break;
        case SC_CONFUSION:
            sc_def = 3 +(status->str + status->int_)/2;
            break;
        case SC_ANKLE:
            if (status->mode&MD_BOSS) // Lasts 5 times less on bosses
                tick /= 5;
            sc_def = status->agi / 2;
            break;
        case SC_MAGICMIRROR:
        case SC_ARMORCHANGE:
            if (sd) //Duration greatly reduced for players.
                tick /= 15;
            //No defense against it (buff).
            rate -= (status_get_lv(bl) / 5 + status->vit / 4 + status->agi / 10)*100; // Lineal Reduction of Rate
            break;
		case SC_MARSHOFABYSS:
			//5 second (Fixed) + 25 second - {( INT + LUK ) / 20 second }
			tick -= (status->int_ + status->luk) / 20 * 1000;
			break;
		case SC_STASIS:
			//5 second (fixed) + { Stasis Skill level * 5 - (Target�s VIT + DEX) / 20 }
			tick -= (status->vit + status->dex) / 20 * 1000;
			break;
        case SC_WHITEIMPRISON:
            if (tick == 5000)  // 100% on caster
                break;
            if (bl->type == BL_PC)
                tick -= (status_get_lv(bl) / 5 + status->vit / 4 + status->agi / 10)*100;
            else
                tick -= (status->vit + status->luk) / 20 * 1000;
            break;
        case SC_BURNING:
            // From iROwiki : http://forums.irowiki.org/showpost.php?p=577240&postcount=583
            tick -= 50*status->luk + 60*status->int_ + 170*status->vit;
            tick = max(tick,10000); // Minimum Duration 10s.
            break;
        case SC_FREEZING:
            tick -= 1000 * ((status->vit + status->dex) / 20);
            tick = max(tick,10000); // Minimum Duration 10s.
            break;
        case SC_OBLIVIONCURSE: // 100% - (100 - 0.8 x INT)
            sc_def = 100 - (100 - status->int_* 8 / 10);
            sc_def = max(sc_def, 5); // minimum of 5%
            break;
        case SC_BITE: // {(Base Success chance) - (Target's AGI / 4)}
            rate -= status->agi*1000/4;
            rate = max(rate,50000); // minimum of 50%
            break;
        case SC_ELECTRICSHOCKER:
            if (bl->type == BL_MOB)
                tick -= 1000 * (status->agi/10);
            break;
        case SC_CRYSTALIZE:
            tick -= (1000*(status->vit/10))+(status_get_lv(bl)/50);
            break;
        case SC_MANDRAGORA:
            sc_def = (status->vit+status->luk)/5;
            break;
        case SC_KYOUGAKU:
            tick -= 30*status->int_;
            break;
        case SC_PARALYSIS:
            tick -= 50 * (status->vit + status->luk); //(1000/20);
            break;
        default:
            //Effect that cannot be reduced? Likely a buff.
            if (!(rnd()%10000 < rate))
                return 0;
            return tick?tick:1;
    }

    if (sd) {

        if (battle_config.pc_sc_def_rate != 100)
            sc_def = sc_def*battle_config.pc_sc_def_rate/100;

        if (sc_def < battle_config.pc_max_sc_def)
            sc_def += (battle_config.pc_max_sc_def - sc_def)*
                      status->luk/battle_config.pc_luk_sc_def;
        else
            sc_def = battle_config.pc_max_sc_def;

        if (tick_def) {
            if (battle_config.pc_sc_def_rate != 100)
                tick_def = tick_def*battle_config.pc_sc_def_rate/100;
        }

    } else {

        if (battle_config.mob_sc_def_rate != 100)
            sc_def = sc_def*battle_config.mob_sc_def_rate/100;

        if (sc_def < battle_config.mob_max_sc_def)
            sc_def += (battle_config.mob_max_sc_def - sc_def)*
                      status->luk/battle_config.mob_luk_sc_def;
        else
            sc_def = battle_config.mob_max_sc_def;

        if (tick_def) {
            if (battle_config.mob_sc_def_rate != 100)
                tick_def = tick_def*battle_config.mob_sc_def_rate/100;
        }
    }

    if (sc) {
        if (sc->data[SC_SCRESIST])
            sc_def += sc->data[SC_SCRESIST]->val1; //Status resist
        else if (sc->data[SC_SIEGFRIED])
            sc_def += sc->data[SC_SIEGFRIED]->val3; //Status resistance.
    }

    //When no tick def, reduction is the same for both.
    if (!tick_def && type != SC_STONE)  //Recent tests show duration of petrify isn't reduced by MDEF. [Inkfish]
        tick_def = sc_def;

    //Natural resistance
    if (!(flag&8)) {
        rate -= rate*sc_def/100;

        //Item resistance (only applies to rate%)
        if (sd && SC_COMMON_MIN <= type && type <= SC_COMMON_MAX) {
            if (sd->reseff[type-SC_COMMON_MIN] > 0)
                rate -= rate*sd->reseff[type-SC_COMMON_MIN]/10000;
            if (sd->sc.data[SC_COMMONSC_RESIST])
                rate -= rate*sd->sc.data[SC_COMMONSC_RESIST]->val1/100;
        }
    }
    if (!(rnd()%10000 < rate))
        return 0;

    //Why would a status start with no duration? Presume it has
    //duration defined elsewhere.
    if (!tick) return 1;

    //Rate reduction
    if (flag&2)
        return tick;

    tick -= tick*tick_def/100;
    // Changed to 5 seconds according to recent tests [Playtester]
    if (type == SC_ANKLE && tick < 5000)
        tick = 5000;
    return tick<=0?0:tick;
}

/*==========================================
 * Starts a status change.
 * 'type' = type, 'val1~4' depend on the type.
 * 'rate' = base success rate. 10000 = 100%
 * 'tick' is base duration
 * 'flag':
 * &1: Cannot be avoided (it has to start)
 * &2: Tick should not be reduced (by vit, luk, lv, etc)
 * &4: sc_data loaded, no value has to be altered.
 * &8: rate should not be reduced
 *------------------------------------------*/
int status_change_start(struct block_list *bl,enum sc_type type,int rate,int val1,int val2,int val3,int val4,int tick,int flag)
{
    struct map_session_data *sd = NULL;
    struct status_change *sc;
    struct status_change_entry *sce;
    struct status_data *status;
    struct view_data *vd;
    int opt_flag, calc_flag, undead_flag, val_flag = 0, tick_time = 0;
    bool sc_isnew = true;

    nullpo_ret(bl);
    sc = status_get_sc(bl);
    status = status_get_status_data(bl);

    if (type <= SC_NONE || type >= SC_MAX) {
        ShowError("status_change_start: invalid status change (%d)!\n", type);
        return 0;
    }

    if (!sc)
        return 0; //Unable to receive status changes

    if (status_isdead(bl) && type != SC_NOCHAT)  // SC_NOCHAT should work even on dead characters
        return 0;

    if (bl->type == BL_MOB) {
        struct mob_data *md = BL_CAST(BL_MOB,bl);
        if (md && (md->class_ == MOBID_EMPERIUM || mob_is_battleground(md)) && type != SC_SAFETYWALL && type != SC_PNEUMA)
            return 0; //Emperium/BG Monsters can't be afflicted by status changes
        //  if(md && mob_is_gvg(md) && status_sc2scb_flag(type)&SCB_MAXHP)
        //      return 0; //prevent status addinh hp to gvg mob (like bloodylust=hp*3 etc...
    }

    if (sc->data[SC_REFRESH]) {
        if (type >= SC_COMMON_MIN && type <= SC_COMMON_MAX) // Confirmed.
            return 0; // Immune to status ailements
        switch (type) {
            case SC_QUAGMIRE://Tester said it protects against this and decrease agi.
            case SC_DECREASEAGI:
            case SC_BURNING:
            case SC_FREEZING:
                //case SC_WHITEIMPRISON://Need confirm. Protected against this in the past. [Rytech]
            case SC_MARSHOFABYSS:
            case SC_TOXIN:
            case SC_PARALYSE:
            case SC_VENOMBLEED:
            case SC_MAGICMUSHROOM:
            case SC_DEATHHURT:
            case SC_PYREXIA:
            case SC_OBLIVIONCURSE:
			case SC_LEECHESEND: //08/31/2011 - Class Balance Changes
            case SC_CRYSTALIZE:
            case SC_DEEPSLEEP:
            case SC_MANDRAGORA:
                return 0;
        }
    } else if (sc->data[SC_INSPIRATION]) {
        if (type >= SC_COMMON_MIN && type <= SC_COMMON_MAX)
            return 0; // Immune to status ailements
        switch (type) {
            case SC_DEEPSLEEP:
            case SC_SATURDAYNIGHTFEVER:
            case SC_PYREXIA:
            case SC_DEATHHURT:
            case SC_MAGICMUSHROOM:
            case SC_VENOMBLEED:
            case SC_TOXIN:
            case SC_OBLIVIONCURSE:
            case SC_LEECHESEND:
            case SC__ENERVATION:
            case SC__GROOMY:
            case SC__LAZINESS:
            case SC__UNLUCKY:
            case SC__WEAKNESS:
            case SC__BODYPAINT:
            case SC__IGNORANCE:
                return 0;
        }
    }

    sd = BL_CAST(BL_PC, bl);

    //Adjust tick according to status resistances
    if (!(flag&(1|4))) {
        tick = status_get_sc_def(bl, type, rate, tick, flag);
        if (!tick) return 0;
    }

    undead_flag = battle_check_undead(status->race,status->def_ele);
    //Check for inmunities / sc fails
    switch (type) {
        case SC_ANGRIFFS_MODUS:
        case SC_GOLDENE_FERSE:
            if ((type==SC_GOLDENE_FERSE && sc->data[SC_ANGRIFFS_MODUS])
                || (type==SC_ANGRIFFS_MODUS && sc->data[SC_GOLDENE_FERSE])
               )
                return 0;
        case SC_STONE:
            if (sc->data[SC_POWER_OF_GAIA])
                return 0;
        case SC_FREEZE:
            //Undead are immune to Freeze/Stone
            if (undead_flag && !(flag&1))
                return 0;
        case SC_DEEPSLEEP:
        case SC_SLEEP:
        case SC_STUN:
        case SC_FREEZING:
        case SC_CRYSTALIZE:
            if (sc->opt1)
                return 0; //Cannot override other opt1 status changes. [Skotlex]
            if ((type == SC_FREEZE || type == SC_FREEZING || type == SC_CRYSTALIZE) && sc->data[SC_WARMER])
                return 0; //Immune to Frozen and Freezing status if under Warmer status. [Jobbie]
            break;

            //There all like berserk, do not everlap each other
        case SC__BLOODYLUST:
            if (!sd) return 0; //should only affect player
        case SC_BERSERK:
            if (((type == SC_BERSERK) && (sc->data[SC_SATURDAYNIGHTFEVER] || sc->data[SC__BLOODYLUST]))
                || ((type == SC__BLOODYLUST) && (sc->data[SC_SATURDAYNIGHTFEVER] || sc->data[SC_BERSERK]))
               )
                return 0;
            break;

        case SC_BURNING:
            if (sc->opt1 || sc->data[SC_FREEZING])
                return 0;
            break;

        case SC_SIGNUMCRUCIS:
            //Only affects demons and undead element (but not players)
            if ((!undead_flag && status->race!=RC_DEMON) || bl->type == BL_PC)
                return 0;
            break;
        case SC_AETERNA:
            if ((sc->data[SC_STONE] && sc->opt1 == OPT1_STONE) || sc->data[SC_FREEZE])
                return 0;
            break;
        case SC_KYRIE:
            if (bl->type == BL_MOB)
                return 0;
            break;
        case SC_OVERTHRUST:
            if (sc->data[SC_MAXOVERTHRUST])
                return 0; //Overthrust can't take effect if under Max Overthrust. [Skotlex]
        case SC_MAXOVERTHRUST:
            if (sc->option&OPTION_MADOGEAR)
                return 0;//Overthrust and Overthrust Max cannot be used on Mado Gear [Ind]
            break;
        case SC_ADRENALINE:
            if (sd && !pc_check_weapontype(sd,skill_get_weapontype(BS_ADRENALINE)))
                return 0;
            if (sc->data[SC_QUAGMIRE] ||
                sc->data[SC_DECREASEAGI] ||
                sc->option&OPTION_MADOGEAR //Adrenaline doesn't affect Mado Gear [Ind]
               )
                return 0;
            break;
        case SC_ADRENALINE2:
            if (sd && !pc_check_weapontype(sd,skill_get_weapontype(BS_ADRENALINE2)))
                return 0;
            if (sc->data[SC_QUAGMIRE] ||
                sc->data[SC_DECREASEAGI]
               )
                return 0;
            break;
        case SC_MAGNIFICAT:
            if (sc->option&OPTION_MADOGEAR)  //Mado is immune to magnificat
                return 0;
            break;
        case SC_ONEHAND:
        case SC_MERC_QUICKEN:
        case SC_TWOHANDQUICKEN:
            if (sc->data[SC_DECREASEAGI])
                return 0;

        case SC_INCREASEAGI:
            if (sd && pc_issit(sd)) {
                pc_setstand(sd);
            }

        case SC_CONCENTRATE:
        case SC_SPEARQUICKEN:
        case SC_TRUESIGHT:
        case SC_WINDWALK:
        case SC_CARTBOOST:
        case SC_ASSNCROS:
            if (sc->data[SC_QUAGMIRE])
                return 0;
            if (sc->option&OPTION_MADOGEAR)
                return 0;//Mado is immune to increase agi, wind walk, cart boost, etc (others above) [Ind]
            break;
        case SC_CLOAKING:
            //Avoid cloaking with no wall and low skill level. [Skotlex]
            //Due to the cloaking card, we have to check the wall versus to known
            //skill level rather than the used one. [Skotlex]
            //if (sd && val1 < 3 && skill_check_cloaking(bl,NULL))
            if (sd && pc_checkskill(sd, AS_CLOAKING) < 3 && !skill_check_cloaking(bl,NULL))
                return 0;
            break;
        case SC_MODECHANGE: {
                int mode;
                struct status_data *bstatus = status_get_base_status(bl);
                if (!bstatus) return 0;
                if (sc->data[type]) {
                    //Pile up with previous values.
                    if (!val2) val2 = sc->data[type]->val2;
                    val3 |= sc->data[type]->val3;
                    val4 |= sc->data[type]->val4;
                }
                mode = val2?val2:bstatus->mode; //Base mode
                if (val4) mode&=~val4; //Del mode
                if (val3) mode|= val3; //Add mode
                if (mode == bstatus->mode) { //No change.
                    if (sc->data[type]) //Abort previous status
                        return status_change_end(bl, type, INVALID_TIMER);
                    return 0;
                }
            }
            break;
            //Strip skills, need to divest something or it fails.
        case SC_STRIPWEAPON:
            if (sd && !(flag&4)) { //apply sc anyway if loading saved sc_data
                int i;
                opt_flag = 0; //Reuse to check success condition.
                if (sd->bonus.unstripable_equip&EQP_WEAPON)
                    return 0;
                i = sd->equip_index[EQI_HAND_L];
                if (i>=0 && sd->inventory_data[i] && sd->inventory_data[i]->type == IT_WEAPON) {
                    opt_flag|=1;
                    pc_unequipitem(sd,i,3); //L-hand weapon
                }

                i = sd->equip_index[EQI_HAND_R];
                if (i>=0 && sd->inventory_data[i] && sd->inventory_data[i]->type == IT_WEAPON) {
                    opt_flag|=2;
                    pc_unequipitem(sd,i,3);
                }
                if (!opt_flag) return 0;
            }
            if (tick == 1) return 1; //Minimal duration: Only strip without causing the SC
            break;
        case SC_STRIPSHIELD:
            if (val2 == 1) val2 = 0;  //GX effect. Do not take shield off..
            else if (sd && !(flag&4)) {
                int i;
                if (sd->bonus.unstripable_equip&EQP_SHIELD)
                    return 0;
                i = sd->equip_index[EQI_HAND_L];
                if (i < 0 || !sd->inventory_data[i] || sd->inventory_data[i]->type != IT_ARMOR)
                    return 0;
                pc_unequipitem(sd,i,3);
            }
            if (tick == 1) return 1; //Minimal duration: Only strip without causing the SC
            break;
        case SC_STRIPARMOR:
            if (sd && !(flag&4)) {
                int i;
                if (sd->bonus.unstripable_equip&EQP_ARMOR)
                    return 0;
                i = sd->equip_index[EQI_ARMOR];
                if (i < 0 || !sd->inventory_data[i])
                    return 0;
                pc_unequipitem(sd,i,3);
            }
            if (tick == 1) return 1; //Minimal duration: Only strip without causing the SC
            break;
        case SC_STRIPHELM:
            if (sd && !(flag&4)) {
                int i;
                if (sd->bonus.unstripable_equip&EQP_HELM)
                    return 0;
                i = sd->equip_index[EQI_HEAD_TOP];
                if (i < 0 || !sd->inventory_data[i])
                    return 0;
                pc_unequipitem(sd,i,3);
            }
            if (tick == 1) return 1; //Minimal duration: Only strip without causing the SC
            break;
        case SC_MERC_FLEEUP:
        case SC_MERC_ATKUP:
        case SC_MERC_HPUP:
        case SC_MERC_SPUP:
        case SC_MERC_HITUP:
            if (bl->type != BL_MER)
                return 0; // Stats only for Mercenaries
            break;
        case SC_STRFOOD:
            if (sc->data[SC_FOOD_STR_CASH] && sc->data[SC_FOOD_STR_CASH]->val1 > val1)
                return 0;
            break;
        case SC_AGIFOOD:
            if (sc->data[SC_FOOD_AGI_CASH] && sc->data[SC_FOOD_AGI_CASH]->val1 > val1)
                return 0;
            break;
        case SC_VITFOOD:
            if (sc->data[SC_FOOD_VIT_CASH] && sc->data[SC_FOOD_VIT_CASH]->val1 > val1)
                return 0;
            break;
        case SC_INTFOOD:
            if (sc->data[SC_FOOD_INT_CASH] && sc->data[SC_FOOD_INT_CASH]->val1 > val1)
                return 0;
            break;
        case SC_DEXFOOD:
            if (sc->data[SC_FOOD_DEX_CASH] && sc->data[SC_FOOD_DEX_CASH]->val1 > val1)
                return 0;
            break;
        case SC_LUKFOOD:
            if (sc->data[SC_FOOD_LUK_CASH] && sc->data[SC_FOOD_LUK_CASH]->val1 > val1)
                return 0;
            break;
        case SC_FOOD_STR_CASH:
            if (sc->data[SC_STRFOOD] && sc->data[SC_STRFOOD]->val1 > val1)
                return 0;
            break;
        case SC_FOOD_AGI_CASH:
            if (sc->data[SC_AGIFOOD] && sc->data[SC_AGIFOOD]->val1 > val1)
                return 0;
            break;
        case SC_FOOD_VIT_CASH:
            if (sc->data[SC_VITFOOD] && sc->data[SC_VITFOOD]->val1 > val1)
                return 0;
            break;
        case SC_FOOD_INT_CASH:
            if (sc->data[SC_INTFOOD] && sc->data[SC_INTFOOD]->val1 > val1)
                return 0;
            break;
        case SC_FOOD_DEX_CASH:
            if (sc->data[SC_DEXFOOD] && sc->data[SC_DEXFOOD]->val1 > val1)
                return 0;
            break;
        case SC_FOOD_LUK_CASH:
            if (sc->data[SC_LUKFOOD] && sc->data[SC_LUKFOOD]->val1 > val1)
                return 0;
            break;
        case SC_CAMOUFLAGE:
            if (sd && pc_checkskill(sd, RA_CAMOUFLAGE) < 3 && !skill_check_camouflage(bl,NULL))
                return 0;
            break;
        case SC__STRIPACCESSORY:
            if (sd) {
                int i = -1;
                if (!(sd->bonus.unstripable_equip&EQI_ACC_L)) {
                    i = sd->equip_index[EQI_ACC_L];
                    if (i >= 0 && sd->inventory_data[i] && sd->inventory_data[i]->type == IT_ARMOR)
                        pc_unequipitem(sd,i,3); //L-Accessory
                }
                if (!(sd->bonus.unstripable_equip&EQI_ACC_R)) {
                    i = sd->equip_index[EQI_ACC_R];
                    if (i >= 0 && sd->inventory_data[i] && sd->inventory_data[i]->type == IT_ARMOR)
                        pc_unequipitem(sd,i,3); //R-Accessory
                }
                if (i < 0)
                    return 0;
            }
            if (tick == 1) return 1; //Minimal duration: Only strip without causing the SC
            break;
        case SC_TOXIN:
        case SC_PARALYSE:
        case SC_VENOMBLEED:
        case SC_MAGICMUSHROOM:
        case SC_DEATHHURT:
        case SC_PYREXIA:
        case SC_OBLIVIONCURSE:
        case SC_LEECHESEND: {
                // it doesn't stack or even renewed
                int i = SC_TOXIN;
                for (; i<= SC_LEECHESEND; i++)
                    if (sc->data[i]) return 0;
            }
            break;
        case SC_SATURDAYNIGHTFEVER:
            if (sc->data[SC_BERSERK] || sc->data[SC_INSPIRATION] || sc->data[SC__BLOODYLUST])
                return 0;
            break;
    }

    //Check for BOSS resistances
    if (status->mode&MD_BOSS && !(flag&1)) {
        if (type>=SC_COMMON_MIN && type <= SC_COMMON_MAX)
            return 0;
        switch (type) {
            case SC_BLESSING:
            case SC_DECREASEAGI:
            case SC_PROVOKE:
            case SC_COMA:
            case SC_GRAVITATION:
            case SC_SUITON:
            case SC_RICHMANKIM:
            case SC_ROKISWEIL:
            case SC_FOGWALL:
            case SC_FREEZING:
            case SC_BURNING: // Place here until we have info about its behavior on Boss-monsters. [pakpil]
            case SC_MARSHOFABYSS:
            case SC_ADORAMUS:
            case SC_PARALYSIS:

                // Exploit prevention - kRO Fix
            case SC_PYREXIA:
            case SC_DEATHHURT:
            case SC_TOXIN:
            case SC_PARALYSE:
            case SC_VENOMBLEED:
            case SC_MAGICMUSHROOM:
            case SC_OBLIVIONCURSE:
            case SC_LEECHESEND:

                // Ranger Effects
            case SC_BITE:
            case SC_ELECTRICSHOCKER:
            case SC_MAGNETICFIELD:

                return 0;
        }
    }

    //Before overlapping fail, one must check for status cured.
    switch (type) {
        case SC_BLESSING:
            //TO-DO Blessing and Agi up should do 1 damage against players on Undead Status, even on PvM
            //but cannot be plagiarized (this requires aegis investigation on packets and official behavior) [Brainstorm]
            if ((!undead_flag && status->race!=RC_DEMON) || bl->type == BL_PC) {
                status_change_end(bl, SC_CURSE, INVALID_TIMER);
                if (sc->data[SC_STONE] && sc->opt1 == OPT1_STONE)
                    status_change_end(bl, SC_STONE, INVALID_TIMER);
            }
            break;
        case SC_INCREASEAGI:
            status_change_end(bl, SC_DECREASEAGI, INVALID_TIMER);
            break;
        case SC_QUAGMIRE:
            status_change_end(bl, SC_CONCENTRATE, INVALID_TIMER);
            status_change_end(bl, SC_TRUESIGHT, INVALID_TIMER);
            status_change_end(bl, SC_WINDWALK, INVALID_TIMER);
            //Also blocks the ones below...
        case SC_DECREASEAGI:
            status_change_end(bl, SC_CARTBOOST, INVALID_TIMER);
            //Also blocks the ones below...
        case SC_DONTFORGETME:
            status_change_end(bl, SC_INCREASEAGI, INVALID_TIMER);
            status_change_end(bl, SC_ADRENALINE, INVALID_TIMER);
            status_change_end(bl, SC_ADRENALINE2, INVALID_TIMER);
            status_change_end(bl, SC_SPEARQUICKEN, INVALID_TIMER);
            status_change_end(bl, SC_TWOHANDQUICKEN, INVALID_TIMER);
            status_change_end(bl, SC_ONEHAND, INVALID_TIMER);
            status_change_end(bl, SC_MERC_QUICKEN, INVALID_TIMER);
            status_change_end(bl, SC_ACCELERATION, INVALID_TIMER);
            break;
        case SC_ONEHAND:
            //Removes the Aspd potion effect, as reported by Vicious. [Skotlex]
            status_change_end(bl, SC_ASPDPOTION0, INVALID_TIMER);
            status_change_end(bl, SC_ASPDPOTION1, INVALID_TIMER);
            status_change_end(bl, SC_ASPDPOTION2, INVALID_TIMER);
            status_change_end(bl, SC_ASPDPOTION3, INVALID_TIMER);
            break;
        case SC_MAXOVERTHRUST:
            //Cancels Normal Overthrust. [Skotlex]
            status_change_end(bl, SC_OVERTHRUST, INVALID_TIMER);
            break;
        case SC_KYRIE:
            //Cancels Assumptio
            status_change_end(bl, SC_ASSUMPTIO, INVALID_TIMER);
            break;
        case SC_DELUGE:
            if (sc->data[SC_FOGWALL] && sc->data[SC_BLIND])
                status_change_end(bl, SC_BLIND, INVALID_TIMER);
            break;
        case SC_SILENCE:
            if (sc->data[SC_GOSPEL] && sc->data[SC_GOSPEL]->val4 == BCT_SELF)
                status_change_end(bl, SC_GOSPEL, INVALID_TIMER);
            break;
        case SC_HIDING:
            status_change_end(bl, SC_CLOSECONFINE, INVALID_TIMER);
            status_change_end(bl, SC_CLOSECONFINE2, INVALID_TIMER);
            break;
        case SC__BLOODYLUST:
        case SC_BERSERK:
            if (battle_config.berserk_cancels_buffs) {
                status_change_end(bl, SC_ONEHAND, INVALID_TIMER);
                status_change_end(bl, SC_TWOHANDQUICKEN, INVALID_TIMER);
                status_change_end(bl, SC_CONCENTRATION, INVALID_TIMER);
                status_change_end(bl, SC_PARRYING, INVALID_TIMER);
                status_change_end(bl, SC_AURABLADE, INVALID_TIMER);
                status_change_end(bl, SC_MERC_QUICKEN, INVALID_TIMER);
            }
#ifdef RENEWAL
            else {
                status_change_end(bl, SC_TWOHANDQUICKEN, INVALID_TIMER);
            }
#endif
            break;
        case SC_ASSUMPTIO:
            status_change_end(bl, SC_KYRIE, INVALID_TIMER);
            status_change_end(bl, SC_KAITE, INVALID_TIMER);
            break;
        case SC_KAITE:
            status_change_end(bl, SC_ASSUMPTIO, INVALID_TIMER);
            break;
        case SC_CARTBOOST:
            if (sc->data[SC_DECREASEAGI]) {
                //Cancel Decrease Agi, but take no further effect [Skotlex]
                status_change_end(bl, SC_DECREASEAGI, INVALID_TIMER);
                return 0;
            }
            break;
        case SC_FUSION:
            status_change_end(bl, SC_SPIRIT, INVALID_TIMER);
            break;
        case SC_ADJUSTMENT:
            status_change_end(bl, SC_MADNESSCANCEL, INVALID_TIMER);
            break;
        case SC_MADNESSCANCEL:
            status_change_end(bl, SC_ADJUSTMENT, INVALID_TIMER);
            break;
            //NPC_CHANGEUNDEAD will debuff Blessing and Agi Up
        case SC_CHANGEUNDEAD:
            status_change_end(bl, SC_BLESSING, INVALID_TIMER);
            status_change_end(bl, SC_INCREASEAGI, INVALID_TIMER);
            break;
        case SC_STRFOOD:
            status_change_end(bl, SC_FOOD_STR_CASH, INVALID_TIMER);
            break;
        case SC_AGIFOOD:
            status_change_end(bl, SC_FOOD_AGI_CASH, INVALID_TIMER);
            break;
        case SC_VITFOOD:
            status_change_end(bl, SC_FOOD_VIT_CASH, INVALID_TIMER);
            break;
        case SC_INTFOOD:
            status_change_end(bl, SC_FOOD_INT_CASH, INVALID_TIMER);
            break;
        case SC_DEXFOOD:
            status_change_end(bl, SC_FOOD_DEX_CASH, INVALID_TIMER);
            break;
        case SC_LUKFOOD:
            status_change_end(bl, SC_FOOD_LUK_CASH, INVALID_TIMER);
            break;
        case SC_FOOD_STR_CASH:
            status_change_end(bl, SC_STRFOOD, INVALID_TIMER);
            break;
        case SC_FOOD_AGI_CASH:
            status_change_end(bl, SC_AGIFOOD, INVALID_TIMER);
            break;
        case SC_FOOD_VIT_CASH:
            status_change_end(bl, SC_VITFOOD, INVALID_TIMER);
            break;
        case SC_FOOD_INT_CASH:
            status_change_end(bl, SC_INTFOOD, INVALID_TIMER);
            break;
        case SC_FOOD_DEX_CASH:
            status_change_end(bl, SC_DEXFOOD, INVALID_TIMER);
            break;
        case SC_FOOD_LUK_CASH:
            status_change_end(bl, SC_LUKFOOD, INVALID_TIMER);
            break;
        case SC_FIGHTINGSPIRIT:
            status_change_end(bl, type, INVALID_TIMER); // Remove previous one.
            break;
        case SC_MARSHOFABYSS:
            status_change_end(bl, SC_INCAGI, INVALID_TIMER);
            status_change_end(bl, SC_WINDWALK, INVALID_TIMER);
            status_change_end(bl, SC_ASPDPOTION0, INVALID_TIMER);
            status_change_end(bl, SC_ASPDPOTION1, INVALID_TIMER);
            status_change_end(bl, SC_ASPDPOTION2, INVALID_TIMER);
            status_change_end(bl, SC_ASPDPOTION3, INVALID_TIMER);
            break;
        case SC_SWINGDANCE:
        case SC_SYMPHONYOFLOVER:
        case SC_MOONLITSERENADE:
        case SC_RUSHWINDMILL:
        case SC_ECHOSONG:
        case SC_HARMONIZE: //group A doesn't overlap
            if (type != SC_SWINGDANCE) status_change_end(bl, SC_SWINGDANCE, INVALID_TIMER);
            if (type != SC_SYMPHONYOFLOVER) status_change_end(bl, SC_SYMPHONYOFLOVER, INVALID_TIMER);
            if (type != SC_MOONLITSERENADE) status_change_end(bl, SC_MOONLITSERENADE, INVALID_TIMER);
            if (type != SC_RUSHWINDMILL) status_change_end(bl, SC_RUSHWINDMILL, INVALID_TIMER);
            if (type != SC_ECHOSONG) status_change_end(bl, SC_ECHOSONG, INVALID_TIMER);
            if (type != SC_HARMONIZE) status_change_end(bl, SC_HARMONIZE, INVALID_TIMER);
            break;
        case SC_VOICEOFSIREN:
        case SC_DEEPSLEEP:
        case SC_GLOOMYDAY:
        case SC_SONGOFMANA:
        case SC_DANCEWITHWUG:
        case SC_SATURDAYNIGHTFEVER:
        case SC_LERADSDEW:
        case SC_MELODYOFSINK:
        case SC_BEYONDOFWARCRY:
        case SC_UNLIMITEDHUMMINGVOICE: //group B
            if (type != SC_VOICEOFSIREN) status_change_end(bl, SC_VOICEOFSIREN, INVALID_TIMER);
            if (type != SC_DEEPSLEEP) status_change_end(bl, SC_DEEPSLEEP, INVALID_TIMER);
            if (type != SC_LERADSDEW) status_change_end(bl, SC_LERADSDEW, INVALID_TIMER);
            if (type != SC_MELODYOFSINK) status_change_end(bl, SC_MELODYOFSINK, INVALID_TIMER);
            if (type != SC_BEYONDOFWARCRY) status_change_end(bl, SC_BEYONDOFWARCRY, INVALID_TIMER);
            if (type != SC_UNLIMITEDHUMMINGVOICE) status_change_end(bl, SC_UNLIMITEDHUMMINGVOICE, INVALID_TIMER);
            if (type != SC_GLOOMYDAY) {
                status_change_end(bl, SC_GLOOMYDAY, INVALID_TIMER);
                status_change_end(bl, SC_GLOOMYDAY_SK, INVALID_TIMER);
            }
            if (type != SC_SONGOFMANA) status_change_end(bl, SC_SONGOFMANA, INVALID_TIMER);
            if (type != SC_DANCEWITHWUG) status_change_end(bl, SC_DANCEWITHWUG, INVALID_TIMER);
            if (type != SC_SATURDAYNIGHTFEVER) {
                if (sc->data[SC_SATURDAYNIGHTFEVER]) {
                    sc->data[SC_SATURDAYNIGHTFEVER]->val2 = 0; //mark to not lose hp
                    status_change_end(bl, SC_SATURDAYNIGHTFEVER, INVALID_TIMER);
                }
            }
            break;
        case SC_REFLECTSHIELD:
            status_change_end(bl, SC_REFLECTDAMAGE, INVALID_TIMER);
            break;
        case SC_REFLECTDAMAGE:
            status_change_end(bl, SC_REFLECTSHIELD, INVALID_TIMER);
            break;
        case SC_SHIELDSPELL_DEF:
        case SC_SHIELDSPELL_MDEF:
        case SC_SHIELDSPELL_REF:
            status_change_end(bl, SC_MAGNIFICAT, INVALID_TIMER);
            if (type != SC_SHIELDSPELL_DEF)
                status_change_end(bl, SC_SHIELDSPELL_DEF, INVALID_TIMER);
            if (type != SC_SHIELDSPELL_MDEF)
                status_change_end(bl, SC_SHIELDSPELL_MDEF, INVALID_TIMER);
            if (type != SC_SHIELDSPELL_REF)
                status_change_end(bl, SC_SHIELDSPELL_REF, INVALID_TIMER);
            break;
        case SC_GT_ENERGYGAIN:
        case SC_GT_CHANGE:
        case SC_GT_REVITALIZE:
            if (type != SC_GT_REVITALIZE)
                status_change_end(bl, SC_GT_REVITALIZE, INVALID_TIMER);
            if (type != SC_GT_ENERGYGAIN)
                status_change_end(bl, SC_GT_ENERGYGAIN, INVALID_TIMER);
            if (type != SC_GT_CHANGE)
                status_change_end(bl, SC_GT_CHANGE, INVALID_TIMER);
            break;
        case SC_INVINCIBLE:
            status_change_end(bl, SC_INVINCIBLEOFF, INVALID_TIMER);
            break;
        case SC_INVINCIBLEOFF:
            status_change_end(bl, SC_INVINCIBLE, INVALID_TIMER);
            break;
    }

    //Check for overlapping fails
    if ((sce = sc->data[type])) {
        switch (type) {
            case SC_MERC_FLEEUP:
            case SC_MERC_ATKUP:
            case SC_MERC_HPUP:
            case SC_MERC_SPUP:
            case SC_MERC_HITUP:
                if (sce->val1 > val1)
                    val1 = sce->val1;
                break;
            case SC_ADRENALINE:
            case SC_ADRENALINE2:
            case SC_WEAPONPERFECTION:
            case SC_OVERTHRUST:
                if (sce->val2 > val2)
                    return 0;
                break;
            case SC_S_LIFEPOTION:
            case SC_L_LIFEPOTION:
            case SC_BOSSMAPINFO:
            case SC_STUN:
            case SC_SLEEP:
            case SC_POISON:
            case SC_CURSE:
            case SC_SILENCE:
            case SC_CONFUSION:
            case SC_BLIND:
            case SC_BLEEDING:
            case SC_DPOISON:
            case SC_CLOSECONFINE2: //Can't be re-closed in.
            case SC_MARIONETTE:
            case SC_MARIONETTE2:
            case SC_NOCHAT:
            case SC_CHANGE: //Otherwise your Hp/Sp would get refilled while still within effect of the last invocation.
            case SC__INVISIBILITY:
            case SC__ENERVATION:
            case SC__GROOMY:
            case SC__IGNORANCE:
            case SC__LAZINESS:
            case SC__WEAKNESS:
            case SC__UNLUCKY:
                return 0;
            case SC_COMBO:
            case SC_DANCING:
            case SC_DEVOTION:
            case SC_ASPDPOTION0:
            case SC_ASPDPOTION1:
            case SC_ASPDPOTION2:
            case SC_ASPDPOTION3:
            case SC_ATKPOTION:
            case SC_MATKPOTION:
            case SC_ENCHANTARMS:
            case SC_ARMOR_ELEMENT:
            case SC_ARMOR_RESIST:
                break;
            case SC_GOSPEL:
                //Must not override a casting gospel char.
                if (sce->val4 == BCT_SELF)
                    return 0;
                if (sce->val1 > val1)
                    return 1;
                break;
            case SC_ENDURE:
                if (sce->val4 && !val4)
                    return 1; //Don't let you override infinite endure.
                if (sce->val1 > val1)
                    return 1;
                break;
            case SC_KAAHI:
                //Kaahi overwrites previous level regardless of existing level.
                //Delete timer if it exists.
                if (sce->val4 != INVALID_TIMER) {
                    delete_timer(sce->val4,kaahi_heal_timer);
                    sce->val4 = INVALID_TIMER;
                }
                break;
            case SC_JAILED:
                //When a player is already jailed, do not edit the jail data.
                val2 = sce->val2;
                val3 = sce->val3;
                val4 = sce->val4;
                break;
            case SC_LERADSDEW:
                if (sc && (sc->data[SC_BERSERK] || sc->data[SC__BLOODYLUST]))
                    return 0;
            case SC_SHAPESHIFT:
            case SC_PROPERTYWALK:
                break;
            case SC_LEADERSHIP:
            case SC_GLORYWOUNDS:
            case SC_SOULCOLD:
            case SC_HAWKEYES:
                if (sce->val4 && !val4) //you cannot override master guild aura
                    return 0;
                break;
            case SC_JOINTBEAT:
                val2 |= sce->val2; // stackable ailments
            default:
                if (sce->val1 > val1)
                    return 1; //Return true to not mess up skill animations. [Skotlex]
        }
    }

    vd = status_get_viewdata(bl);
    calc_flag = StatusChangeFlagTable[type];
    if (!(flag&4)) //&4 - Do not parse val settings when loading SCs
        switch (type) {
            case SC_DECREASEAGI:
            case SC_INCREASEAGI:
                val2 = 2 + val1; //Agi change
                break;
            case SC_ENDURE:
                val2 = 7; // Hit-count [Celest]
                if (!(flag&1) && (bl->type&(BL_PC|BL_MER)) && !map_flag_gvg(bl->m) && !map[bl->m].flag.battleground && !val4) {
                    struct map_session_data *tsd;
                    if (sd) {
                        int i;
                        for (i = 0; i < 5; i++) {
                            if (sd->devotion[i] && (tsd = map_id2sd(sd->devotion[i])))
                                status_change_start(&tsd->bl, type, 10000, val1, val2, val3, val4, tick, 1);
                        }
                    } else if (bl->type == BL_MER && ((TBL_MER *)bl)->devotion_flag && (tsd = ((TBL_MER *)bl)->master))
                        status_change_start(&tsd->bl, type, 10000, val1, val2, val3, val4, tick, 1);
                }
                //val4 signals infinite endure (if val4 == 2 it is infinite endure from Berserk)
                if (val4)
                    tick = -1;
                break;
            case SC_AUTOBERSERK:
                if (status->hp < status->max_hp>>2 &&
                    (!sc->data[SC_PROVOKE] || sc->data[SC_PROVOKE]->val2==0))
                    sc_start4(bl,SC_PROVOKE,100,10,1,0,0,60000);
                tick = -1;
                break;
            case SC_SIGNUMCRUCIS:
                val2 = 10 + 4*val1; //Def reduction
                tick = -1;
                clif_emotion(bl,E_SWT);
                break;
            case SC_MAXIMIZEPOWER:
                tick_time = val2 = tick>0?tick:60000;
                tick = -1; // duration sent to the client should be infinite
                break;
            case SC_EDP:    // [Celest]
                val2 = val1 + 2; //Chance to Poison enemies.
#ifndef RENEWAL_EDP
                val3 = 50*(val1+1); //Damage increase (+50 +50*lv%)
#endif
                if (sd) //[Ind] - iROwiki says each level increases its duration by 3 seconds
                    tick += pc_checkskill(sd,GC_RESEARCHNEWPOISON)*3000;
                break;
            case SC_POISONREACT:
                val2=(val1+1)/2 + val1/10; // Number of counters [Skotlex]
                val3=50; // + 5*val1; //Chance to counter. [Skotlex]
                break;
            case SC_MAGICROD:
                val2 = val1*20; //SP gained
                break;
            case SC_KYRIE:
                val2 = status->max_hp * (val1 * 2 + 10) / 100; //%Max HP to absorb
                val3 = (val1 / 2 + 5); //Hits
                break;
            case SC_MAGICPOWER:
                //val1: Skill lv
                val2 = 1; //Lasts 1 invocation
                val3 = 5*val1; //Matk% increase
                val4 = 0; // 0 = ready to be used, 1 = activated and running
                break;
            case SC_SACRIFICE:
                val2 = 5; //Lasts 5 hits
                tick = -1;
                break;
            case SC_ENCPOISON:
                val2= 250+50*val1;  //Poisoning Chance (2.5+0.5%) in 1/10000 rate
            case SC_ASPERSIO:
            case SC_FIREWEAPON:
            case SC_WATERWEAPON:
            case SC_WINDWEAPON:
            case SC_EARTHWEAPON:
            case SC_SHADOWWEAPON:
            case SC_GHOSTWEAPON:
                skill_enchant_elemental_end(bl,type);
                break;
            case SC_ELEMENTALCHANGE:
                // val1 : Element Lvl (if called by skill lvl 1, takes random value between 1 and 4)
                // val2 : Element (When no element, random one is picked)
                // val3 : 0 = called by skill 1 = called by script (fixed level)
                if (!val2) val2 = rnd()%ELE_MAX;

                if (val1 == 1 && val3 == 0)
                    val1 = 1 + rnd()%4;
                else if (val1 > 4)
                    val1 = 4; // Max Level
                val3 = 0; // Not need to keep this info.
                break;
            case SC_PROVIDENCE:
                val2=val1*5; //Race/Ele resist
                break;
            case SC_REFLECTSHIELD:
                val2=10+val1*3; // %Dmg reflected
                if (!(flag&1) && (bl->type&(BL_PC|BL_MER))) {
                    struct map_session_data *tsd;
                    if (sd) {
                        int i;
                        for (i = 0; i < 5; i++) {
                            if (sd->devotion[i] && (tsd = map_id2sd(sd->devotion[i])))
                                status_change_start(&tsd->bl, type, 10000, val1, val2, 0, 0, tick, 1);
                        }
                    } else if (bl->type == BL_MER && ((TBL_MER *)bl)->devotion_flag && (tsd = ((TBL_MER *)bl)->master))
                        status_change_start(&tsd->bl, type, 10000, val1, val2, 0, 0, tick, 1);
                }
                break;
            case SC_STRIPWEAPON:
                if (!sd) //Watk reduction
                    val2 = 25;
                break;
            case SC_STRIPSHIELD:
                if (!sd) //Def reduction
                    val2 = 15;
                break;
            case SC_STRIPARMOR:
                if (!sd) //Vit reduction
                    val2 = 40;
                break;
            case SC_STRIPHELM:
                if (!sd) //Int reduction
                    val2 = 40;
                break;
            case SC_AUTOSPELL:
                //Val1 Skill LV of Autospell
                //Val2 Skill ID to cast
                //Val3 Max Lv to cast
                val4 = 5 + val1*2; //Chance of casting
                break;
            case SC_VOLCANO:
                val2 = val1*10; //Watk increase
#ifndef RENEWAL
                if (status->def_ele != ELE_FIRE)
                    val2 = 0;
#endif
                break;
            case SC_VIOLENTGALE:
                val2 = val1*3; //Flee increase
#ifndef RENEWAL
                if (status->def_ele != ELE_WIND)
                    val2 = 0;
#endif
                break;
            case SC_DELUGE:
                val2 = deluge_eff[val1-1]; //HP increase
#ifndef RENEWAL
                if (status->def_ele != ELE_WATER)
                    val2 = 0;
#endif
                break;
            case SC_SUITON:
                if (!val2 || (sd && (sd->class_&MAPID_UPPERMASK) == MAPID_NINJA)) {
                    //No penalties.
                    val2 = 0; //Agi penalty
                    val3 = 0; //Walk speed penalty
                    break;
                }
                val3 = 50;
                val2 = 3*((val1+1)/3);
                if (val1 > 4) val2--;
                break;
            case SC_ONEHAND:
            case SC_TWOHANDQUICKEN:
                val2 = 300;
                if (val1 > 10) //For boss casted skills [Skotlex]
                    val2 += 20*(val1-10);
                break;
            case SC_MERC_QUICKEN:
                val2 = 300;
                break;
#ifndef RENEWAL
            case SC_SPEARQUICKEN:
                val2 = 200+10*val1;
                break;
#endif
            case SC_DANCING:
                //val1 : Skill ID + LV
                //val2 : Skill Group of the Dance.
                //val3 : Brings the skilllv (merged into val1 here)
                //val4 : Partner
                if (val1 == CG_MOONLIT)
                    clif_status_change(bl,SI_MOONLIT,1,tick,0, 0, 0);
                val1|= (val3<<16);
                val3 = tick/1000; //Tick duration
                tick_time = 1000; // [GodLesZ] tick time
                break;
            case SC_LONGING:
                val2 = 500-100*val1; //Aspd penalty.
                break;
            case SC_EXPLOSIONSPIRITS:
                val2 = 75 + 25*val1; //Cri bonus
                break;

            case SC_ASPDPOTION0:
            case SC_ASPDPOTION1:
            case SC_ASPDPOTION2:
            case SC_ASPDPOTION3:
                val2 = 50*(2+type-SC_ASPDPOTION0);
                break;

            case SC_WEDDING:
            case SC_XMAS:
            case SC_SUMMER:
                if (!vd) return 0;
                //Store previous values as they could be removed.
                val1 = vd->class_;
                val2 = vd->weapon;
                val3 = vd->shield;
                val4 = vd->cloth_color;
                unit_stop_attack(bl);
                clif_changelook(bl,LOOK_WEAPON,0);
                clif_changelook(bl,LOOK_SHIELD,0);
                clif_changelook(bl,LOOK_BASE,type==SC_WEDDING?JOB_WEDDING:type==SC_XMAS?JOB_XMAS:JOB_SUMMER);
                clif_changelook(bl,LOOK_CLOTHES_COLOR,vd->cloth_color);
                break;
            case SC_NOCHAT:
                // [GodLesZ] FIXME: is this correct? a hardcoded interval of 60sec? what about configuration ?_?
                tick = 60000;
                val1 = battle_config.manner_system; //Mute filters.
                if (sd) {
                    clif_changestatus(sd,SP_MANNER,sd->status.manner);
                    clif_updatestatus(sd,SP_MANNER);
                }
                break;

            case SC_STONE:
                val3 = tick/1000; //Petrified HP-damage iterations.
                if (val3 < 1) val3 = 1;
                tick = val4; //Petrifying time.
                tick = max(tick, 1000); //Min time
                calc_flag = 0; //Actual status changes take effect on petrified state.
                break;

            case SC_DPOISON:
                //Lose 10/15% of your life as long as it doesn't brings life below 25%
                if (status->hp > status->max_hp>>2) {
                    int diff = status->max_hp*(bl->type==BL_PC?10:15)/100;
                    if (status->hp - diff < status->max_hp>>2)
                        diff = status->hp - (status->max_hp>>2);
                    if (val2 && bl->type == BL_MOB) {
                        struct block_list *src = map_id2bl(val2);
                        if (src)
                            mob_log_damage((TBL_MOB *)bl,src,diff);
                    }
                    status_zap(bl, diff, 0);
                }
                // fall through
            case SC_POISON:
                val3 = tick/1000; //Damage iterations
                if (val3 < 1) val3 = 1;
                tick_time = 1000; // [GodLesZ] tick time
                //val4: HP damage
                if (bl->type == BL_PC)
                    val4 = (type == SC_DPOISON) ? 3 + status->max_hp/50 : 3 + status->max_hp*3/200;
                else
                    val4 = (type == SC_DPOISON) ? 3 + status->max_hp/100 : 3 + status->max_hp/200;

                break;
            case SC_CONFUSION:
                clif_emotion(bl,E_WHAT);
                break;
            case SC_BLEEDING:
                val4 = tick/10000;
                if (!val4) val4 = 1;
                tick_time = 10000; // [GodLesZ] tick time
                break;
            case SC_S_LIFEPOTION:
            case SC_L_LIFEPOTION:
                if (val1 == 0) return 0;
                // val1 = heal percent/amout
                // val2 = seconds between heals
                // val4 = total of heals
                if (val2 < 1) val2 = 1;
                if ((val4 = tick/(val2 * 1000)) < 1)
                    val4 = 1;
                tick_time = val2 * 1000; // [GodLesZ] tick time
                break;
            case SC_BOSSMAPINFO:
                if (sd != NULL) {
                    struct mob_data *boss_md = map_getmob_boss(bl->m); // Search for Boss on this Map
                    if (boss_md == NULL || boss_md->bl.prev == NULL) {
                        // No MVP on this map - MVP is dead
                        clif_bossmapinfo(sd->fd, boss_md, 1);
                        return 0; // No need to start SC
                    }
                    val1 = boss_md->bl.id;
                    if ((val4 = tick/1000) < 1)
                        val4 = 1;
                    tick_time = 1000; // [GodLesZ] tick time
                }
                break;
            case SC_HIDING:
                val2 = tick/1000;
                tick_time = 1000; // [GodLesZ] tick time
                val3 = 0; // unused, previously speed adjustment
                val4 = val1+3; //Seconds before SP substraction happen.
                break;
            case SC_CHASEWALK:
                val2 = tick>0?tick:10000; //Interval at which SP is drained.
                val3 = 35 - 5 * val1; //Speed adjustment.
                if (sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_ROGUE)
                    val3 -= 40;
                val4 = 10+val1*2; //SP cost.
                if (map_flag_gvg(bl->m) || map[bl->m].flag.battleground) val4 *= 5;
                break;
            case SC_CLOAKING:
                if (!sd) //Monsters should be able to walk with no penalties. [Skotlex]
                    val1 = 10;
                tick_time = val2 = tick>0?tick:60000; //SP consumption rate.
                tick = -1; // duration sent to the client should be infinite
                val3 = 0; // unused, previously walk speed adjustment
                //val4&1 signals the presence of a wall.
                //val4&2 makes cloak not end on normal attacks [Skotlex]
                //val4&4 makes cloak not end on using skills
                if (bl->type == BL_PC || (bl->type == BL_MOB && ((TBL_MOB *)bl)->special_state.clone))  //Standard cloaking.
                    val4 |= battle_config.pc_cloak_check_type&7;
                else
                    val4 |= battle_config.monster_cloak_check_type&7;
                break;
            case SC_SIGHT:          /* splash status */
            case SC_RUWACH:
            case SC_SIGHTBLASTER:
                val3 = skill_get_splash(val2, val1); //Val2 should bring the skill-id.
                val2 = tick/250;
                tick_time = 10; // [GodLesZ] tick time
                break;

                //Permanent effects.
            case SC_AETERNA:
            case SC_MODECHANGE:
            case SC_WEIGHT50:
            case SC_WEIGHT90:
            case SC_BROKENWEAPON:
            case SC_BROKENARMOR:
            case SC_READYSTORM:
            case SC_READYDOWN:
            case SC_READYCOUNTER:
            case SC_READYTURN:
            case SC_DODGE:
            case SC_PUSH_CART:
                tick = -1;
                break;

            case SC_AUTOGUARD:
                if (!(flag&1)) {
                    struct map_session_data *tsd;
                    int i,t;
                    for (i = val2 = 0; i < val1; i++) {
                        t = 5-(i>>1);
                        val2 += (t < 0)? 1:t;
                    }

                    if (bl->type&(BL_PC|BL_MER)) {
                        if (sd) {
                            for (i = 0; i < 5; i++) {
                                if (sd->devotion[i] && (tsd = map_id2sd(sd->devotion[i])))
                                    status_change_start(&tsd->bl, type, 10000, val1, val2, 0, 0, tick, 1);
                            }
                        } else if (bl->type == BL_MER && ((TBL_MER *)bl)->devotion_flag && (tsd = ((TBL_MER *)bl)->master))
                            status_change_start(&tsd->bl, type, 10000, val1, val2, 0, 0, tick, 1);
                    }
                }
                break;

            case SC_DEFENDER:
                if (!(flag&1)) {
                    val2 = 5 + 15*val1; //Damage reduction
                    val3 = 0; // unused, previously speed adjustment
                    val4 = 250 - 50*val1; //Aspd adjustment

                    if (sd) {
                        struct map_session_data *tsd;
                        int i;
                        for (i = 0; i < 5; i++) {
                            //See if there are devoted characters, and pass the status to them. [Skotlex]
                            if (sd->devotion[i] && (tsd = map_id2sd(sd->devotion[i])))
                                status_change_start(&tsd->bl,type,10000,val1,5+val1*5,val3,val4,tick,1);
                        }
                    }
                }
                break;

            case SC_TENSIONRELAX:
                if (sd) {
                    pc_setsit(sd);
                    clif_sitting(&sd->bl);
                }
                val2 = 12; //SP cost
                val4 = 10000; //Decrease at 10secs intervals.
                val3 = tick/val4;
                tick = -1; // duration sent to the client should be infinite
                tick_time = val4; // [GodLesZ] tick time
                break;
            case SC_PARRYING:
                val2 = 20 + val1*3; //Block Chance
                break;

            case SC_WINDWALK:
                val2 = (val1+1)/2; // Flee bonus is 1/1/2/2/3/3/4/4/5/5
                break;

            case SC_JOINTBEAT:
                if (val2&BREAK_NECK)
                    sc_start(bl,SC_BLEEDING,100,val1,skill_get_time2(status_sc2skill(type),val1));
                break;

            case SC_BERSERK:
                if (!sc->data[SC_ENDURE] || !sc->data[SC_ENDURE]->val4)
                    sc_start4(bl, SC_ENDURE, 100,10,0,0,2, tick);
            case SC__BLOODYLUST:
                //HP healing is performing after the calc_status call.
                //Val2 holds HP penalty
                if (!val4) val4 = skill_get_time2(status_sc2skill(type),val1);
                if (!val4) val4 = 10000; //Val4 holds damage interval
                val3 = tick/val4; //val3 holds skill duration
                tick_time = val4; // [GodLesZ] tick time
                break;

            case SC_GOSPEL:
                if (val4 == BCT_SELF) { // self effect
                    val2 = tick/10000;
                    tick_time = 10000; // [GodLesZ] tick time
                    status_change_clear_buffs(bl,3); //Remove buffs/debuffs
                }
                break;

            case SC_MARIONETTE: {
                    int stat;

                    val3 = 0;
                    val4 = 0;
                    stat = (sd ? sd->status.str : status_get_base_status(bl)->str) / 2;
                    val3 |= cap_value(stat,0,0xFF)<<16;
                    stat = (sd ? sd->status.agi : status_get_base_status(bl)->agi) / 2;
                    val3 |= cap_value(stat,0,0xFF)<<8;
                    stat = (sd ? sd->status.vit : status_get_base_status(bl)->vit) / 2;
                    val3 |= cap_value(stat,0,0xFF);
                    stat = (sd ? sd->status.int_: status_get_base_status(bl)->int_) / 2;
                    val4 |= cap_value(stat,0,0xFF)<<16;
                    stat = (sd ? sd->status.dex : status_get_base_status(bl)->dex) / 2;
                    val4 |= cap_value(stat,0,0xFF)<<8;
                    stat = (sd ? sd->status.luk : status_get_base_status(bl)->luk) / 2;
                    val4 |= cap_value(stat,0,0xFF);
                    break;
                }
            case SC_MARIONETTE2: {
                    int stat,max_stat;
                    // fetch caster information
                    struct block_list *pbl = map_id2bl(val1);
                    struct status_change *psc = pbl?status_get_sc(pbl):NULL;
                    struct status_change_entry *psce = psc?psc->data[SC_MARIONETTE]:NULL;
                    // fetch target's stats
                    struct status_data *status = status_get_status_data(bl); // battle status

                    if (!psce)
                        return 0;

                    val3 = 0;
                    val4 = 0;
                    max_stat = battle_config.max_parameter; //Cap to 99 (default)
                    stat = (psce->val3 >>16)&0xFF;
                    stat = min(stat, max_stat - status->str);
                    val3 |= cap_value(stat,0,0xFF)<<16;
                    stat = (psce->val3 >> 8)&0xFF;
                    stat = min(stat, max_stat - status->agi);
                    val3 |= cap_value(stat,0,0xFF)<<8;
                    stat = (psce->val3 >> 0)&0xFF;
                    stat = min(stat, max_stat - status->vit);
                    val3 |= cap_value(stat,0,0xFF);
                    stat = (psce->val4 >>16)&0xFF;
                    stat = min(stat, max_stat - status->int_);
                    val4 |= cap_value(stat,0,0xFF)<<16;
                    stat = (psce->val4 >> 8)&0xFF;
                    stat = min(stat, max_stat - status->dex);
                    val4 |= cap_value(stat,0,0xFF)<<8;
                    stat = (psce->val4 >> 0)&0xFF;
                    stat = min(stat, max_stat - status->luk);
                    val4 |= cap_value(stat,0,0xFF);
                    break;
                }
            case SC_REJECTSWORD:
                val2 = 15*val1; //Reflect chance
                val3 = 3; //Reflections
                tick = -1;
                break;

            case SC_MEMORIZE:
                val2 = 5; //Memorized casts.
                tick = -1;
                break;

            case SC_GRAVITATION:
                val2 = 50*val1; //aspd reduction
                break;

            case SC_REGENERATION:
                if (val1 == 1)
                    val2 = 2;
                else
                    val2 = val1; //HP Regerenation rate: 200% 200% 300%
                val3 = val1; //SP Regeneration Rate: 100% 200% 300%
                //if val4 comes set, this blocks regen rather than increase it.
                break;

            case SC_DEVOTION: {
                    struct block_list *d_bl;
                    struct status_change *d_sc;

                    if ((d_bl = map_id2bl(val1)) && (d_sc = status_get_sc(d_bl)) && d_sc->count) {
                        // Inherits Status From Source
                        const enum sc_type types[] = { SC_AUTOGUARD, SC_DEFENDER, SC_REFLECTSHIELD, SC_ENDURE };
                        enum sc_type type2;
                        int i = (map_flag_gvg(bl->m) || map[bl->m].flag.battleground)?2:3;
                        while (i >= 0) {
                            type2 = types[i];
                            if (d_sc->data[type2])
                                sc_start(bl, type2, 100, d_sc->data[type2]->val1, skill_get_time(status_sc2skill(type2),d_sc->data[type2]->val1));
                            i--;
                        }
                    }
                    break;
                }

            case SC_COMA: //Coma. Sends a char to 1HP. If val2, do not zap sp
                if (val3 && bl->type == BL_MOB) {
                    struct block_list *src = map_id2bl(val3);
                    if (src)
                        mob_log_damage((TBL_MOB *)bl,src,status->hp - 1);
                }
                status_zap(bl, status->hp-1, val2?0:status->sp);
                return 1;
                break;
            case SC_CLOSECONFINE2: {
                    struct block_list *src = val2?map_id2bl(val2):NULL;
                    struct status_change *sc2 = src?status_get_sc(src):NULL;
                    struct status_change_entry *sce2 = sc2?sc2->data[SC_CLOSECONFINE]:NULL;
                    if (src && sc2) {
                        if (!sce2) //Start lock on caster.
                            sc_start4(src,SC_CLOSECONFINE,100,val1,1,0,0,tick+1000);
                        else { //Increase count of locked enemies and refresh time.
                            (sce2->val2)++;
                            delete_timer(sce2->timer, status_change_timer);
                            sce2->timer = add_timer(gettick()+tick+1000, status_change_timer, src->id, SC_CLOSECONFINE);
                        }
                    } else //Status failed.
                        return 0;
                }
                break;
            case SC_KAITE:
                val2 = 1+val1/5; //Number of bounces: 1 + skilllv/5
                break;
            case SC_KAUPE:
                switch (val1) {
                    case 3: //33*3 + 1 -> 100%
                        val2++;
                    case 1:
                    case 2: //33, 66%
                        val2 += 33*val1;
                        val3 = 1; //Dodge 1 attack total.
                        break;
                    default: //Custom. For high level mob usage, higher level means more blocks. [Skotlex]
                        val2 = 100;
                        val3 = val1-2;
                        break;
                }
                break;

            case SC_COMBO: {
                    //val1: Skill ID
                    //val2: When given, target (for autotargetting skills)
                    //val3: When set, this combo time should NOT delay attack/movement
                    //val3: TK: Last used kick
                    //val4: TK: Combo time
                    struct unit_data *ud = unit_bl2ud(bl);
                    if (ud && !val3) {
                        tick += 300 * battle_config.combo_delay_rate/100;
                        ud->attackabletime = gettick()+tick;
                        unit_set_walkdelay(bl, gettick(), tick, 1);
                    }
                    val3 = 0;
                    val4 = tick;
                }
                break;
            case SC_EARTHSCROLL:
                val2 = 11-val1; //Chance to consume: 11-skilllv%
                break;
            case SC_RUN:
                val4 = gettick(); //Store time at which you started running.
                tick = -1;
                break;
            case SC_KAAHI:
                val2 = 200*val1; //HP heal
                val3 = 5*val1; //SP cost
                val4 = INVALID_TIMER;   //Kaahi Timer.
                break;
            case SC_BLESSING:
                if ((!undead_flag && status->race!=RC_DEMON) || bl->type == BL_PC)
                    val2 = val1;
                else
                    val2 = 0; //0 -> Half stat.
                break;
            case SC_TRICKDEAD:
                if (vd) vd->dead_sit = 1;
                tick = -1;
                break;
            case SC_CONCENTRATE:
                val2 = 2 + val1;
                if (sd) { //Store the card-bonus data that should not count in the %
                    val3 = sd->param_bonus[1]; //Agi
                    val4 = sd->param_bonus[4]; //Dex
                } else {
                    val3 = val4 = 0;
                }
                break;
            case SC_MAXOVERTHRUST:
                val2 = 20*val1; //Power increase
                break;
            case SC_OVERTHRUST:
                //val2 holds if it was casted on self, or is bonus received from others
                val3 = 5*val1; //Power increase
                if (sd && pc_checkskill(sd,BS_HILTBINDING)>0)
                    tick += tick / 10;
                break;
            case SC_ADRENALINE2:
            case SC_ADRENALINE:
                val3 = (val2) ? 300 : 200; // aspd increase
            case SC_WEAPONPERFECTION:
                if (sd && pc_checkskill(sd,BS_HILTBINDING)>0)
                    tick += tick / 10;
                break;
            case SC_CONCENTRATION:
                val2 = 5*val1; //Batk/Watk Increase
                val3 = 10*val1; //Hit Increase
                val4 = 5*val1; //Def reduction
                break;
            case SC_ANGELUS:
                val2 = 5*val1; //def increase
                break;
            case SC_IMPOSITIO:
                val2 = 5*val1; //watk increase
                break;
            case SC_MELTDOWN:
                val2 = 100*val1; //Chance to break weapon
                val3 = 70*val1; //Change to break armor
                break;
            case SC_TRUESIGHT:
                val2 = 10*val1; //Critical increase
                val3 = 3*val1; //Hit increase
                break;
            case SC_SUN_COMFORT:
                val2 = (status_get_lv(bl) + status->dex + status->luk)/2; //def increase
                break;
            case SC_MOON_COMFORT:
                val2 = (status_get_lv(bl) + status->dex + status->luk)/10; //flee increase
                break;
            case SC_STAR_COMFORT:
                val2 = (status_get_lv(bl) + status->dex + status->luk); //Aspd increase
                break;
            case SC_QUAGMIRE:
                val2 = (sd?5:10)*val1; //Agi/Dex decrease.
                break;

                // gs_something1 [Vicious]
            case SC_GATLINGFEVER:
                val2 = 20*val1; //Aspd increase
                val3 = 20+10*val1; //Batk increase
                val4 = 5*val1; //Flee decrease
                break;

            case SC_FLING:
                if (bl->type == BL_PC)
                    val2 = 0; //No armor reduction to players.
                else
                    val2 = 5*val1; //Def reduction
                val3 = 5*val1; //Def2 reduction
                break;
            case SC_PROVOKE:
                //val2 signals autoprovoke.
                val3 = 2+3*val1; //Atk increase
                val4 = 5+5*val1; //Def reduction.
                break;
            case SC_AVOID:
                //val2 = 10*val1; //Speed change rate.
                break;
            case SC_DEFENCE:
                val2 = 2*val1; //Def bonus
                break;
            case SC_BLOODLUST:
                val2 = 20+10*val1; //Atk rate change.
                val3 = 3*val1; //Leech chance
                val4 = 20; //Leech percent
                break;
            case SC_FLEET:
                val2 = 30*val1; //Aspd change
                val3 = 5+5*val1; //bAtk/wAtk rate change
                break;
            case SC_MINDBREAKER:
                val2 = 20*val1; //matk increase.
                val3 = 12*val1; //mdef2 reduction.
                break;
            case SC_SKA:
                val2 = tick/1000;
                val3 = rnd()%100; //Def changes randomly every second...
                tick_time = 1000; // [GodLesZ] tick time
                break;
            case SC_JAILED:
                //Val1 is duration in minutes. Use INT_MAX to specify 'unlimited' time.
                tick = val1>0?1000:250;
                if (sd) {
                    if (sd->mapindex != val2) {
                        int pos = (bl->x&0xFFFF)|(bl->y<<16),  //Current Coordinates
                            map =  sd->mapindex; //Current Map
                        //1. Place in Jail (val2 -> Jail Map, val3 -> x, val4 -> y
                        pc_setpos(sd,(unsigned short)val2,val3,val4, CLR_TELEPORT);
                        //2. Set restore point (val3 -> return map, val4 return coords
                        val3 = map;
                        val4 = pos;
                    } else if (!val3 || val3 == sd->mapindex) { //Use save point.
                        val3 = sd->status.save_point.map;
                        val4 = (sd->status.save_point.x&0xFFFF)
                               |(sd->status.save_point.y<<16);
                    }
                }
                break;
            case SC_UTSUSEMI:
                val2=(val1+1)/2; // number of hits blocked
                val3=skill_get_blewcount(NJ_UTSUSEMI, val1); //knockback value.
                break;
            case SC_BUNSINJYUTSU:
                val2=(val1+1)/2; // number of hits blocked
                break;
            case SC_CHANGE:
                val2= 30*val1; //Vit increase
                val3= 20*val1; //Int increase
                break;
            case SC_SWOO:
                if (status->mode&MD_BOSS)
                    tick /= 5; //TODO: Reduce skill's duration. But for how long?
                break;
            case SC_SPIDERWEB:
                if (bl->type == BL_PC)
                    tick /= 2;
                break;
            case SC_ARMOR:
                //NPC_DEFENDER:
                val2 = 80; //Damage reduction
                //Attack requirements to be blocked:
                val3 = BF_LONG; //Range
                val4 = BF_WEAPON|BF_MISC; //Type
                break;
            case SC_ENCHANTARMS:
                //end previous enchants
                skill_enchant_elemental_end(bl,type);
                //Make sure the received element is valid.
                if (val2 >= ELE_MAX)
                    val2 = val2%ELE_MAX;
                else if (val2 < 0)
                    val2 = rnd()%ELE_MAX;
                break;
            case SC_CRITICALWOUND:
                val2 = 20*val1; //Heal effectiveness decrease
                break;
            case SC_MAGICMIRROR:
            case SC_SLOWCAST:
                val2 = 20*val1; //Magic reflection/cast rate
                break;

            case SC_ARMORCHANGE:
                if (val2 == NPC_ANTIMAGIC) {
                    //Boost mdef
                    val2 =-20;
                    val3 = 20;
                } else { //Boost def
                    val2 = 20;
                    val3 =-20;
                }
                val2*=val1; //20% per level
                val3*=val1;
                break;
            case SC_EXPBOOST:
            case SC_JEXPBOOST:
                if (val1 < 0)
                    val1 = 0;
                break;
            case SC_INCFLEE2:
            case SC_INCCRI:
                val2 = val1*10; //Actual boost (since 100% = 1000)
                break;
            case SC_SUFFRAGIUM:
                val2 = 15 * val1; //Speed cast decrease
                break;
            case SC_INCHEALRATE:
                if (val1 < 1)
                    val1 = 1;
                break;
            case SC_HALLUCINATION:
                val2 = 5+val1; //Factor by which displayed damage is increased by
                break;
            case SC_DOUBLECAST:
                val2 = 30+10*val1; //Trigger rate
                break;
            case SC_KAIZEL:
                val2 = 10*val1; //% of life to be revived with
                break;
                // case SC_ARMOR_ELEMENT:
                // case SC_ARMOR_RESIST:
                // Mod your resistance against elements:
                // val1 = water | val2 = earth | val3 = fire | val4 = wind
                // break;
                //case ????:
                //Place here SCs that have no SCB_* data, no skill associated, no ICON
                //associated, and yet are not wrong/unknown. [Skotlex]
                //break;

            case SC_MERC_FLEEUP:
            case SC_MERC_ATKUP:
            case SC_MERC_HITUP:
                val2 = 15 * val1;
                break;
            case SC_MERC_HPUP:
            case SC_MERC_SPUP:
                val2 = 5 * val1;
                break;
            case SC_REBIRTH:
                val2 = 20*val1; //% of life to be revived with
                break;

            case SC_MANU_DEF:
            case SC_MANU_ATK:
            case SC_MANU_MATK:
                val2 = 1; // Manuk group
                break;
            case SC_SPL_DEF:
            case SC_SPL_ATK:
            case SC_SPL_MATK:
                val2 = 2; // Splendide group
                break;
                /**
                 * General
                 **/
            case SC_FEAR:
                val2 = 2;
                val4 = tick / 1000;
                tick_time = 1000; // [GodLesZ] tick time
                break;
            case SC_BURNING:
                val4 = tick / 2000; // Total Ticks to Burn!!
                tick_time = 2000; // [GodLesZ] tick time
                break;
                /**
                 * Rune Knight
                 **/
            case SC_DEATHBOUND:
                val2 = 500 + 100 * val1;
                break;
            case SC_FIGHTINGSPIRIT:
                val_flag |= 1|2;
                break;
            case SC_ABUNDANCE:
                val4 = tick / 10000;
                tick_time = 10000; // [GodLesZ] tick time
                break;
            case SC_GIANTGROWTH:
                val2 = 10; // Triple damage success rate.
                break;
                /**
                 * Arch Bishop
                 **/
            case SC_RENOVATIO:
                val4 = tick / 5000;
                tick_time = 5000;
                break;
            case SC_SECRAMENT:
                val2 = 10 * val1;
                break;
            case SC_VENOMIMPRESS:
                val2 = 10 * val1;
                val_flag |= 1|2;
                break;
            case SC_POISONINGWEAPON:
                val_flag |= 1|2|4;
                break;
            case SC_WEAPONBLOCKING:
                val2 = 10 + 2 * val1; // Chance
                val4 = tick / 3000;
                tick_time = 3000; // [GodLesZ] tick time
                val_flag |= 1|2;
                break;
            case SC_TOXIN:
                val4 = tick / 10000;
                tick_time = 10000; // [GodLesZ] tick time
                break;
            case SC_MAGICMUSHROOM:
                val4 = tick / 4000;
                tick_time = 4000; // [GodLesZ] tick time
                break;
            case SC_PYREXIA:
                status_change_start(bl,SC_BLIND,10000,val1,0,0,0,30000,11); // Blind status that last for 30 seconds
                val4 = tick / 3000;
                tick_time = 3000; // [GodLesZ] tick time
                break;
            case SC_LEECHESEND:
                val4 = tick / 1000;
                tick_time = 1000; // [GodLesZ] tick time
                break;
            case SC_OBLIVIONCURSE:
                val4 = tick / 3000;
                tick_time = 3000; // [GodLesZ] tick time
                break;
            case SC_ROLLINGCUTTER:
                val_flag |= 1;
                break;
            case SC_CLOAKINGEXCEED:
                val2 = (val1 + 1) / 2;   // Hits
                val3 = 90 + val1 * 10; // Walk speed
                val_flag |= 1|2|4;
                if (bl->type == BL_PC)
                    val4 |= battle_config.pc_cloak_check_type&7;
                else
                    val4 |= battle_config.monster_cloak_check_type&7;
                tick_time = 1000; // [GodLesZ] tick time
                break;
            case SC_HALLUCINATIONWALK:
                val2 = 50 * val1; // Evasion rate of physical attacks. Flee
                val3 = 10 * val1; // Evasion rate of magical attacks.
                val_flag |= 1|2|4;
                break;
            case SC_WHITEIMPRISON:
                status_change_end(bl, SC_BURNING, INVALID_TIMER);
                status_change_end(bl, SC_FREEZING, INVALID_TIMER);
                status_change_end(bl, SC_FREEZE, INVALID_TIMER);
                status_change_end(bl, SC_STONE, INVALID_TIMER);
                break;
            case SC_FREEZING:
                status_change_end(bl, SC_BURNING, INVALID_TIMER);
                break;
            case SC_READING_SB:
                // val2 = sp reduction per second
                tick_time = 5000; // [GodLesZ] tick time
                break;
            case SC_SPHERE_1:
            case SC_SPHERE_2:
            case SC_SPHERE_3:
            case SC_SPHERE_4:
            case SC_SPHERE_5:
                if (!sd)
                    return 0;   // Should only work on players.
                val4 = tick / 1000;
                if (val4 < 1)
                    val4 = 1;
                tick_time = 1000; // [GodLesZ] tick time
                val_flag |= 1;
                break;
            case SC_SHAPESHIFT:
                switch (val1) {
                    case 1:
                        val2 = ELE_FIRE;
                        break;
                    case 2:
                        val2 = ELE_EARTH;
                        break;
                    case 3:
                        val2 = ELE_WIND;
                        break;
                    case 4:
                        val2 = ELE_WATER;
                        break;
                }
                break;
            case SC_ELECTRICSHOCKER:
            case SC_CRYSTALIZE:
            case SC_MEIKYOUSISUI:
                val4 = tick / 1000;
                if (val4 < 1)
                    val4 = 1;
                tick_time = 1000; // [GodLesZ] tick time
                break;
            case SC_CAMOUFLAGE:
                val4 = tick/1000;
                tick_time = 1000; // [GodLesZ] tick time
                break;
            case SC_WUGDASH:
                val4 = gettick(); //Store time at which you started running.
                tick = -1;
                break;
            case SC__SHADOWFORM: {
                    struct map_session_data *s_sd = map_id2sd(val2);
                    if (s_sd)
                        s_sd->shadowform_id = bl->id;
                    val4 = tick / 1000;
                    val_flag |= 1|2|4;
                    tick_time = 1000; // [GodLesZ] tick time
                }
                break;
            case SC__STRIPACCESSORY:
                if (!sd)
                    val2 = 20;
                break;
            case SC__INVISIBILITY:
                val2 = 50 - 10 * val1; // ASPD
                val3 = 20 * val1; // CRITICAL
                val4 = tick / 1000;
                tick_time = 1000; // [GodLesZ] tick time
                val_flag |= 1|2;
                break;
            case SC__ENERVATION:
                val2 = 20 + 10 * val1; // ATK Reduction
                val_flag |= 1|2;
                if (sd) pc_delspiritball(sd,sd->spiritball,0);
                break;
            case SC__GROOMY:
                val2 = 20 + 10 * val1; //ASPD. Need to confirm if Movement Speed reduction is the same. [Jobbie]
                val3 = 20 * val1; //HIT
                val_flag |= 1|2|4;
                if (sd) {
                    // Removes Animals
                    if (pc_isriding(sd)) pc_setriding(sd, 0);
                    if (pc_isridingdragon(sd)) pc_setoption(sd, sd->sc.option&~OPTION_DRAGON);
                    if (pc_iswug(sd)) pc_setoption(sd, sd->sc.option&~OPTION_WUG);
                    if (pc_isridingwug(sd)) pc_setoption(sd, sd->sc.option&~OPTION_WUGRIDER);
                    if (pc_isfalcon(sd)) pc_setoption(sd, sd->sc.option&~OPTION_FALCON);
                    if (sd->status.pet_id > 0) pet_menu(sd, 3);
                    if (merc_is_hom_active(sd->hd)) merc_hom_vaporize(sd,1);
                    if (sd->md) merc_delete(sd->md,3);
                }
                break;
            case SC__LAZINESS:
                val2 = 10 + 10 * val1; // Cast reduction
                val3 = 10 * val1; // Flee Reduction
                val_flag |= 1|2|4;
                break;
            case SC__UNLUCKY:
                val2 = 10 * val1; // Crit and Flee2 Reduction
                val_flag |= 1|2|4;
                break;
            case SC__WEAKNESS:
                val2 = 10 * val1;
                val_flag |= 1|2;
                // bypasses coating protection and MADO
                sc_start(bl,SC_STRIPWEAPON,100,val1,tick);
                sc_start(bl,SC_STRIPSHIELD,100,val1,tick);
                break;
                break;
            case SC_GN_CARTBOOST:
                if (val1 < 3)
                    val2 = 50;
                else if (val1 < 5)
                    val2 = 75;
                else
                    val2 = 100;
                break;
            case SC_PROPERTYWALK:
                val_flag |= 1|2;
                val3 = 0;
                break;
            case SC_WARMER:
                status_change_end(bl, SC_FREEZE, INVALID_TIMER);
                status_change_end(bl, SC_FREEZING, INVALID_TIMER);
                status_change_end(bl, SC_CRYSTALIZE, INVALID_TIMER);
                break;
            case SC_STRIKING:
                val1 = 6 - val1;//spcost = 6 - level (lvl1:5 ... lvl 5: 1)
                val4 = tick / 1000;
                tick_time = 1000; // [GodLesZ] tick time
                break;
            case SC_BLOODSUCKER:
                val4 = tick / 1000;
                tick_time = 1000; // [GodLesZ] tick time
                break;
            case SC_VACUUM_EXTREME:
                tick -= (status->str / 20) * 1000;
                val4 = val3 = tick / 100;
                tick_time = 100; // [GodLesZ] tick time
                break;
            case SC_SWINGDANCE:
                val2 = 4 * val1; // Walk speed and aspd reduction.
                break;
            case SC_SYMPHONYOFLOVER:
            case SC_RUSHWINDMILL:
            case SC_ECHOSONG:
                val2 = 6 * val1;
                val2 += val3; //Adding 1% * Lesson Bonus
                val2 += (int)(val4*2/10); //Adding 0.2% per JobLevel
                break;
            case SC_MOONLITSERENADE:
                val2 = 10 * val1;
                break;
            case SC_HARMONIZE:
                val2 = 5 + 5 * val1;
                break;
            case SC_VOICEOFSIREN:
                val4 = tick / 2000;
                tick_time = 2000; // [GodLesZ] tick time
                break;
            case SC_DEEPSLEEP:
                val4 = tick / 2000;
                tick_time = 2000; // [GodLesZ] tick time
                break;
            case SC_SIRCLEOFNATURE:
                val2 = 1 + val1; //SP consume
                val3 = 40 * val1;   //HP recovery
                val4 = tick / 1000;
                tick_time = 1000; // [GodLesZ] tick time
                break;
            case SC_SONGOFMANA:
                val3 = 10 + (2 * val2);
                val4 = tick/3000;
                tick_time = 3000; // [GodLesZ] tick time
                break;
            case SC_SATURDAYNIGHTFEVER:
                if (!val4) val4 = skill_get_time2(status_sc2skill(type),val1);
                if (!val4) val4 = 3000;
                val3 = tick/val4;
                tick_time = val4; // [GodLesZ] tick time
                break;
            case SC_GLOOMYDAY:
                val2 = 20 + 5 * val1; // Flee reduction.
                val3 = 15 + 5 * val1; // ASPD reduction.
                if (sd && rand()%100 < val1) { // (Skill Lv) %
                    val4 = 1; // reduce walk speed by half.
                    if (pc_isriding(sd)) pc_setriding(sd, 0);
                    if (pc_isridingdragon(sd)) pc_setoption(sd, sd->sc.option&~OPTION_DRAGON);
                }
                break;
            case SC_GLOOMYDAY_SK:
                // Random number between [15 ~ (Voice Lesson Skill Level x 5) + (Skill Level x 10)] %.
                val2 = 15 + rand()%((sd?pc_checkskill(sd, WM_LESSON)*5:0) + val1*10);
                break;
            case SC_SITDOWN_FORCE:
            case SC_BANANA_BOMB_SITDOWN:
                if (sd && !pc_issit(sd)) {
                    pc_setsit(sd);
                    skill_sit(sd,1);
                    clif_sitting(bl);
                }
                break;
            case SC_DANCEWITHWUG:
                val3 = (5 * val1) + (1 * val2); //Still need official value.
                break;
            case SC_LERADSDEW:
                val3 = (5 * val1) + (1 * val2);
                break;
            case SC_MELODYOFSINK:
                val3 = (5 * val1) + (1 * val2);
                break;
            case SC_BEYONDOFWARCRY:
                val3 = (5 * val1) + (1 * val2);
                break;
            case SC_UNLIMITEDHUMMINGVOICE: {
                    struct unit_data *ud = unit_bl2ud(bl);
                    if (ud == NULL) return 0;
                    ud->state.skillcastcancel = 0;
                    val3 = 15 - (2 * val2);
                }
                break;
            case SC_REFLECTDAMAGE:
                val2 = 15 + 5 * val1;
                val3 = (val1==5)?20:(val1+4)*2; // SP consumption
                val4 = tick/10000;
                tick_time = 10000; // [GodLesZ] tick time
                break;
            case SC_FORCEOFVANGUARD: // This is not the official way to handle it but I think we should use it. [pakpil]
                val2 = 20 + 12 * (val1 - 1); // Chance
                val3 = 5 + (2 * val1); // Max rage counters
                tick = -1; //endless duration in the client
                tick_time = 6000; // [GodLesZ] tick time
                val_flag |= 1|2|4;
                break;
            case SC_EXEEDBREAK:
                val1 *= 150; // 150 * skill_lv
                if (sd && sd->inventory_data[sd->equip_index[EQI_HAND_R]]) {   // Chars.
                    val1 += (sd->inventory_data[sd->equip_index[EQI_HAND_R]]->weight/10 * sd->inventory_data[sd->equip_index[EQI_HAND_R]]->wlv * status_get_lv(bl) / 100);
                    val1 += 15 * (sd ? sd->status.job_level:50) + 100;
                } else  // Mobs
                    val1 += (400 * status_get_lv(bl) / 100) + (15 * (status_get_lv(bl) / 2));   // About 1138% at mob_lvl 99. Is an aproximation to a standard weapon. [pakpil]
                break;
            case SC_PRESTIGE:   // Bassed on suggested formula in iRO Wiki and some test, still need more test. [pakpil]
                val2 = ((status->int_ + status->luk) / 6) + 5;  // Chance to evade magic damage.
                val1 *= 15; // Defence added
                if (sd)
                    val1 += 10 * pc_checkskill(sd,CR_DEFENDER);
                val_flag |= 1|2;
                break;
            case SC_BANDING:
                tick_time = 5000; // [GodLesZ] tick time
                val_flag |= 1;
                break;
            case SC_SHIELDSPELL_DEF:
            case SC_SHIELDSPELL_MDEF:
            case SC_SHIELDSPELL_REF:
                val_flag |= 1|2;
                break;
            case SC_MAGNETICFIELD:
                val3 = tick / 1000;
                tick_time = 1000; // [GodLesZ] tick time
                break;
            case SC_INSPIRATION:
                if (sd) {
                    val2 = (40 * val1) + (3 * sd->status.job_level); // ATK bonus
                    val3 = (sd->status.job_level / 10) * 2 + 12; // All stat bonus
                }
                val4 = tick / 1000;
                tick_time = 1000; // [GodLesZ] tick time
                status_change_clear_buffs(bl,3); //Remove buffs/debuffs
                break;
            case SC_SPELLFIST:
            case SC_CURSEDCIRCLE_ATKER:
                val_flag |= 1|2|4;
                break;
            case SC_CRESCENTELBOW:
                val2 = 94 + val1;
                val_flag |= 1|2;
                break;
            case SC_LIGHTNINGWALK: //  [(Job Level / 2) + (40 + 5 * Skill Level)] %
                val1 = (sd?sd->status.job_level:2)/2 + 40 + 5 * val1;
                val_flag |= 1;
                break;
            case SC_RAISINGDRAGON:
                val3 = tick / 5000;
                tick_time = 5000; // [GodLesZ] tick time
                break;
            case SC_GT_CHANGE: {
                    // take note there is no def increase as skill desc says. [malufett]
                    struct block_list *src;
                    val3 = status->agi * val1 / 60; // ASPD increase: [(Target AGI x Skill Level) / 60] %
                    if ((src = map_id2bl(val2)))
                        val4 = (200/status_get_int(src)) * val1;  // MDEF decrease: MDEF [(200 / Caster INT) x Skill Level]
                }
                break;
            case SC_GT_REVITALIZE: {
                    // take note there is no vit,aspd,speed increase as skill desc says. [malufett]
                    struct block_list *src;
                    val3 = val1 * 30 + 150; // Natural HP recovery increase: [(Skill Level x 30) + 50] %
                    if ((src = map_id2bl(val2)))  // the stat def is not shown in the status window and it is process differently
                        val4 = (status_get_vit(src)/4) * val1;   // STAT DEF increase: [(Caster VIT / 4) x Skill Level]
                }
                break;
            case SC_PYROTECHNIC_OPTION:
                val2 = 60;  // Watk TODO: Renewal (Atk2)
                val3 = 11;  // % Increase damage.
                val_flag |= 1|2|4;
                break;
            case SC_HEATER_OPTION:
                val2 = 120; // Watk. TODO: Renewal (Atk2)
                val3 = 33;  // % Increase effects.
                val4 = 3;   // Change into fire element.
                val_flag |= 1|2|4;
                break;
            case SC_TROPIC_OPTION:
                val2 = 180; // Watk. TODO: Renewal (Atk2)
                val3 = MG_FIREBOLT;
                break;
            case SC_AQUAPLAY_OPTION:
                val2 = 40; // Matk. TODO: Renewal (Matk1)
                val3 = 33;  // % Increase effects.
                val_flag |= 1|2|4;
                break;
            case SC_COOLER_OPTION:
                val2 = 80;  // % Freezing chance
                val3 = 33;  // % increased damage
                val4 = 1;   // Change into water elemet
                val_flag |= 1|2|4;
                break;
            case SC_CHILLY_AIR_OPTION:
                val2 = 120; // Matk. TODO: Renewal (Matk1)
                val3 = MG_COLDBOLT;
                val_flag |= 1|2;
                break;
            case SC_GUST_OPTION:
                val2 = 33;
                val_flag |= 1|2;
                break;
            case SC_WIND_STEP_OPTION:
                val2 = 50;  // % Increase speed and flee.
                break;
            case SC_BLAST_OPTION:
                val2 = 33;
                val3 = 4;
                val_flag |= 1|2|4;
                break;
            case SC_WILD_STORM_OPTION:
                val2 = MG_LIGHTNINGBOLT;
                val_flag |= 1|2;
                break;
            case SC_PETROLOGY_OPTION:
                val2 = 5;
                val3 = 33;
                val_flag |= 1|2|4;
                break;
            case SC_CURSED_SOIL_OPTION:
                val2 = 10;
                val3 = 33;
                val4 = 2;
                val_flag |= 1|2|4;
                break;
            case SC_UPHEAVAL_OPTION:
                val2 = WZ_EARTHSPIKE;
                val_flag |= 1|2;
                break;
            case SC_CIRCLE_OF_FIRE_OPTION:
                val2 = 300;
                val_flag |= 1|2;
                break;
            case SC_FIRE_CLOAK_OPTION:
            case SC_WATER_DROP_OPTION:
            case SC_WIND_CURTAIN_OPTION:
            case SC_STONE_SHIELD_OPTION:
                val2 = 20;  // Elemental modifier. Not confirmed.
                break;
            case SC_CIRCLE_OF_FIRE:
            case SC_FIRE_CLOAK:
            case SC_WATER_DROP:
            case SC_WATER_SCREEN:
            case SC_WIND_CURTAIN:
            case SC_WIND_STEP:
            case SC_STONE_SHIELD:
            case SC_SOLID_SKIN:
                val2 = 10;
                tick_time = 2000; // [GodLesZ] tick time
                break;
            case SC_WATER_BARRIER:
                val2 = 40;  // Increasement. Mdef1 ???
                val3 = 20;  // Reductions. Atk2, Flee1, Matk1 ????
                val_flag |= 1|2|4;
                break;
            case SC_ZEPHYR:
                val2 = 22;  // Flee.
                break;
            case SC_TIDAL_WEAPON:
                val2 = 20; // Increase Elemental's attack.
                break;
            case SC_ROCK_CRUSHER:
            case SC_ROCK_CRUSHER_ATK:
            case SC_POWER_OF_GAIA:
                val2 = 33;
                break;
            case SC_MELON_BOMB:
            case SC_BANANA_BOMB:
                val1 = 15;
                break;
            case SC_STOMACHACHE:
                val2 = 8;   // SP consume.
                val4 = tick / 10000;
                tick_time = 10000; // [GodLesZ] tick time
                break;
            case SC_KYOUGAKU:
                val2 = 2*val1 + rand()%val1;
                clif_status_change(bl,SI_ACTIVE_MONSTER_TRANSFORM,1,0,1002,0,0);
                break;
            case SC_KAGEMUSYA:
                val3 = val1 * 2;
            case SC_IZAYOI:
                val2 = tick/1000;
                tick_time = 1000;
                break;
            case SC_ZANGETSU:
                if ((status_get_hp(bl)+status_get_sp(bl)) % 2 == 0)
                    val2 = status_get_lv(bl) / 2 + 50;
                else
                    val2 -= 50;
                break;
            case SC_GENSOU: {
                    int hp = status_get_hp(bl), lv = 5;
                    short per = 100 / (status_get_max_hp(bl) / hp);

                    if (per <= 15)
                        lv = 1;
                    else if (per <= 30)
                        lv = 2;
                    else if (per <= 50)
                        lv = 3;
                    else if (per <= 75)
                        lv = 4;
                    if (hp % 2 == 0)
                        status_heal(bl, hp * (6-lv) * 4 / 100, status_get_sp(bl) * (6-lv) * 3 / 100, 1);
                    else
                        status_zap(bl, hp * (lv*4) / 100, status_get_sp(bl) * (lv*3) / 100);
                }
                break;
            case SC_ANGRIFFS_MODUS:
                val2 = 50 + 20 * val1; //atk bonus
                val3 = 40 + 20 * val1; // Flee reduction.
                val4 = tick/1000; // hp/sp reduction timer
                tick_time = 1000;
                break;
            case SC_GOLDENE_FERSE:
                val2 = 10 + 10*val1; //max hp bonus
                val3 = 6 + 4 * val1; // Aspd Bonus
                val4 = 2 + 2 * val1; // Chance of holy attack
                break;
            case SC_OVERED_BOOST:
                val2 = 300 + 40*val1; //flee bonus
                val3 = 179 + 2*val1; //aspd bonus
                break;
            case SC_GRANITIC_ARMOR:
                val2 = 2*val1; //dmg reduction
                val3 = 6*val1; //dmg on status end
                break;
            case SC_MAGMA_FLOW:
                val2 = 3*val1; //activation chance
                break;
            case SC_PYROCLASTIC:
                val2 += 10*val1; //atk bonus
                break;
            case SC_PARALYSIS: //[Lighta] need real info
                val2 = 2*val1; //def reduction
                val3 = 500*val1; //varcast augmentation
                break;
            case SC_PAIN_KILLER: //[Lighta] need real info
                val2 = 2*val1; //aspd reduction %
                val3 = 2*val1; //dmg reduction %
                if (sc->data[SC_PARALYSIS])
                    sc_start(bl, SC_ENDURE, 100, val1, tick); //start endure for same duration
                break;
            default:
                if (calc_flag == SCB_NONE && StatusSkillChangeTable[type] == 0 && StatusIconChangeTable[type] == 0) {
                    //Status change with no calc, no icon, and no skill associated...?
                    ShowError("UnknownStatusChange [%d]\n", type);
                    return 0;
                }
        }
    else //Special considerations when loading SC data.
        switch (type) {
            case SC_WEDDING:
            case SC_XMAS:
            case SC_SUMMER:
                clif_changelook(bl,LOOK_WEAPON,0);
                clif_changelook(bl,LOOK_SHIELD,0);
                clif_changelook(bl,LOOK_BASE,type==SC_WEDDING?JOB_WEDDING:type==SC_XMAS?JOB_XMAS:JOB_SUMMER);
                clif_changelook(bl,LOOK_CLOTHES_COLOR,val4);
                break;
            case SC_KAAHI:
                val4 = INVALID_TIMER;
                break;
        }

    //Those that make you stop attacking/walking....
    switch (type) {
        case SC_FREEZE:
        case SC_STUN:
        case SC_SLEEP:
        case SC_STONE:
        case SC_DEEPSLEEP:
            if (sd && pc_issit(sd)) //Avoid sprite sync problems.
                pc_setstand(sd);
        case SC_TRICKDEAD:
            unit_stop_attack(bl);
            status_change_end(bl, SC_DANCING, INVALID_TIMER);
            // Cancel cast when get status [LuzZza]
            if (battle_config.sc_castcancel&bl->type)
                unit_skillcastcancel(bl, 0);
        case SC_STOP:
        case SC_CONFUSION:
        case SC_CLOSECONFINE:
        case SC_CLOSECONFINE2:
        case SC_ANKLE:
        case SC_SPIDERWEB:
        case SC_ELECTRICSHOCKER:
        case SC_BITE:
        case SC_THORNSTRAP:
        case SC__MANHOLE:
        case SC_CRYSTALIZE:
        case SC_WHITEIMPRISON:
        case SC_CURSEDCIRCLE_ATKER:
        case SC_CURSEDCIRCLE_TARGET:
        case SC_FEAR:
        case SC_NETHERWORLD:
        case SC_MEIKYOUSISUI:
        case SC_KYOUGAKU:
        case SC_PARALYSIS:
            unit_stop_walking(bl,1);
            break;
        case SC_HIDING:
        case SC_CLOAKING:
        case SC_CLOAKINGEXCEED:
        case SC_CHASEWALK:
        case SC_WEIGHT90:
        case SC_CAMOUFLAGE:
        case SC_VOICEOFSIREN:
            unit_stop_attack(bl);
            break;
        case SC_SILENCE:
            if (battle_config.sc_castcancel&bl->type)
                unit_skillcastcancel(bl, 0);
            break;
    }

    // Set option as needed.
    opt_flag = 1;
    switch (type) {
            //OPT1
        case SC_STONE:
            sc->opt1 = OPT1_STONEWAIT;
            break;
        case SC_FREEZE:
            sc->opt1 = OPT1_FREEZE;
            break;
        case SC_STUN:
            sc->opt1 = OPT1_STUN;
            break;
        case SC_SLEEP:
        case SC_DEEPSLEEP:
			if(type == SC_DEEPSLEEP)
				opt_flag = 0;
            sc->opt1 = OPT1_SLEEP;
            break;
        case SC_BURNING:
            sc->opt1 = OPT1_BURNING;
            break; // Burning need this to be showed correctly. [pakpil]
        case SC_WHITEIMPRISON:
            sc->opt1 = OPT1_IMPRISON;
            break;
        case SC_CRYSTALIZE:
            sc->opt1 = OPT1_CRYSTALIZE;
            break;
            //OPT2
        case SC_POISON:
            sc->opt2 |= OPT2_POISON;
            break;
        case SC_CURSE:
            sc->opt2 |= OPT2_CURSE;
            break;
        case SC_SILENCE:
            sc->opt2 |= OPT2_SILENCE;
            break;

        case SC_SIGNUMCRUCIS:
            sc->opt2 |= OPT2_SIGNUMCRUCIS;
            break;

        case SC_BLIND:
            sc->opt2 |= OPT2_BLIND;
            break;
        case SC_ANGELUS:
            sc->opt2 |= OPT2_ANGELUS;
            break;
        case SC_BLEEDING:
            sc->opt2 |= OPT2_BLEEDING;
            break;
        case SC_DPOISON:
            sc->opt2 |= OPT2_DPOISON;
            break;
            //OPT3
        case SC_TWOHANDQUICKEN:
        case SC_ONEHAND:
        case SC_SPEARQUICKEN:
        case SC_CONCENTRATION:
        case SC_MERC_QUICKEN:
            sc->opt3 |= OPT3_QUICKEN;
            opt_flag = 0;
            break;
        case SC_MAXOVERTHRUST:
        case SC_OVERTHRUST:
        case SC_SWOO:   //Why does it shares the same opt as Overthrust? Perhaps we'll never know...
            sc->opt3 |= OPT3_OVERTHRUST;
            opt_flag = 0;
            break;
        case SC_ENERGYCOAT:
        case SC_SKE:
            sc->opt3 |= OPT3_ENERGYCOAT;
            opt_flag = 0;
            break;
        case SC_INCATKRATE:
            //Simulate Explosion Spirits effect for NPC_POWERUP [Skotlex]
            if (bl->type != BL_MOB) {
                opt_flag = 0;
                break;
            }
        case SC_EXPLOSIONSPIRITS:
            sc->opt3 |= OPT3_EXPLOSIONSPIRITS;
            opt_flag = 0;
            break;
        case SC_STEELBODY:
        case SC_SKA:
            sc->opt3 |= OPT3_STEELBODY;
            opt_flag = 0;
            break;
        case SC_BLADESTOP:
            sc->opt3 |= OPT3_BLADESTOP;
            opt_flag = 0;
            break;
        case SC_AURABLADE:
            sc->opt3 |= OPT3_AURABLADE;
            opt_flag = 0;
            break;
        case SC_BERSERK:
            opt_flag = 0;
            //      case SC__BLOODYLUST:
            sc->opt3 |= OPT3_BERSERK;
            break;
            //      case ???: // doesn't seem to do anything
            //          sc->opt3 |= OPT3_LIGHTBLADE;
            //          opt_flag = 0;
            //          break;
        case SC_DANCING:
            if ((val1&0xFFFF) == CG_MOONLIT)
                sc->opt3 |= OPT3_MOONLIT;
            opt_flag = 0;
            break;
        case SC_MARIONETTE:
        case SC_MARIONETTE2:
            sc->opt3 |= OPT3_MARIONETTE;
            opt_flag = 0;
            break;
        case SC_ASSUMPTIO:
            sc->opt3 |= OPT3_ASSUMPTIO;
            opt_flag = 0;
            break;
        case SC_WARM: //SG skills [Komurka]
            sc->opt3 |= OPT3_WARM;
            opt_flag = 0;
            break;
        case SC_KAITE:
            sc->opt3 |= OPT3_KAITE;
            opt_flag = 0;
            break;
        case SC_BUNSINJYUTSU:
            sc->opt3 |= OPT3_BUNSIN;
            opt_flag = 0;
            break;
        case SC_SPIRIT:
            sc->opt3 |= OPT3_SOULLINK;
            opt_flag = 0;
            break;
        case SC_CHANGEUNDEAD:
            sc->opt3 |= OPT3_UNDEAD;
            opt_flag = 0;
            break;
            //      case ???: // from DA_CONTRACT (looks like biolab mobs aura)
            //          sc->opt3 |= OPT3_CONTRACT;
            //          opt_flag = 0;
            //          break;
            //OPTION
        case SC_HIDING:
            sc->option |= OPTION_HIDE;
            opt_flag = 2;
            break;
        case SC_CLOAKING:
        case SC_CLOAKINGEXCEED:
        case SC__INVISIBILITY:
            sc->option |= OPTION_CLOAK;
            opt_flag = 2;
            break;
        case SC_CHASEWALK:
            sc->option |= OPTION_CHASEWALK|OPTION_CLOAK;
            opt_flag = 2;
            break;
        case SC_SIGHT:
            sc->option |= OPTION_SIGHT;
            break;
        case SC_RUWACH:
            sc->option |= OPTION_RUWACH;
            break;
        case SC_WEDDING:
            sc->option |= OPTION_WEDDING;
            break;
        case SC_XMAS:
            sc->option |= OPTION_XMAS;
            break;
        case SC_SUMMER:
            sc->option |= OPTION_SUMMER;
            break;
        case SC_ORCISH:
            sc->option |= OPTION_ORCISH;
            break;
        case SC_FUSION:
            sc->option |= OPTION_FLYING;
            break;
        default:
            opt_flag = 0;
    }

    //On Aegis, when turning on a status change, first goes the option packet, then the sc packet.
    if (opt_flag)
        clif_changeoption(bl);

    if (calc_flag&SCB_DYE) {
        //Reset DYE color
        if (vd && vd->cloth_color) {
            val4 = vd->cloth_color;
            clif_changelook(bl,LOOK_CLOTHES_COLOR,0);
        }
        calc_flag&=~SCB_DYE;
    }

    clif_status_change(bl,StatusIconChangeTable[type],1,tick,(val_flag&1)?val1:1,(val_flag&2)?val2:0,(val_flag&4)?val3:0);

    /**
     * used as temporary storage for scs with interval ticks, so that the actual duration is sent to the client first.
     **/
    if (tick_time)
        tick = tick_time;

    //Don't trust the previous sce assignment, in case the SC ended somewhere between there and here.
    if ((sce=sc->data[type])) { // reuse old sc
        if (sce->timer != INVALID_TIMER)
            delete_timer(sce->timer, status_change_timer);
        sc_isnew = false;
    } else {// new sc
        ++(sc->count);
        sce = sc->data[type] = ers_alloc(sc_data_ers, struct status_change_entry);
    }
    sce->val1 = val1;
    sce->val2 = val2;
    sce->val3 = val3;
    sce->val4 = val4;
    if (tick >= 0)
        sce->timer = add_timer(gettick() + tick, status_change_timer, bl->id, type);
    else
        sce->timer = INVALID_TIMER; //Infinite duration

    if (calc_flag)
        status_calc_bl(bl,calc_flag);

    if (sc_isnew && StatusChangeStateTable[type])   /* non-zero */
        status_calc_state(bl,sc,(enum scs_flag) StatusChangeStateTable[type],true);


    if (sd && sd->pd)
        pet_sc_check(sd, type); //Skotlex: Pet Status Effect Healing

    switch (type) {
        case SC__BLOODYLUST:
        case SC_BERSERK:
            if (!(sce->val2)) { //don't heal if already set
                status_heal(bl, status->max_hp, 0, 1); //Do not use percent_heal as this healing must override BERSERK's block.
                status_set_sp(bl, 0, 0); //Damage all SP
            }
            sce->val2 = 5 * status->max_hp / 100;
            break;
        case SC_CHANGE:
            status_percent_heal(bl, 100, 100);
            break;
        case SC_RUN: {
                struct unit_data *ud = unit_bl2ud(bl);
                if (ud)
                    ud->state.running = unit_run(bl);
            }
            break;
        case SC_BOSSMAPINFO:
            clif_bossmapinfo(sd->fd, map_id2boss(sce->val1), 0); // First Message
            break;
        case SC_MERC_HPUP:
            status_percent_heal(bl, 100, 0); // Recover Full HP
            break;
        case SC_MERC_SPUP:
            status_percent_heal(bl, 0, 100); // Recover Full SP
            break;
            /**
             * Ranger
             **/
        case SC_WUGDASH: {
                struct unit_data *ud = unit_bl2ud(bl);
                if (ud)
                    ud->state.running = unit_wugdash(bl, sd);
            }
            break;
        case SC_COMBO:
            switch (sce->val1) {
                case TK_STORMKICK:
                    clif_skill_nodamage(bl,bl,TK_READYSTORM,1,1);
                    break;
                case TK_DOWNKICK:
                    clif_skill_nodamage(bl,bl,TK_READYDOWN,1,1);
                    break;
                case TK_TURNKICK:
                    clif_skill_nodamage(bl,bl,TK_READYTURN,1,1);
                    break;
                case TK_COUNTER:
                    clif_skill_nodamage(bl,bl,TK_READYCOUNTER,1,1);
                    break;
                case MO_COMBOFINISH:
                case CH_TIGERFIST:
                case CH_CHAINCRUSH:
                    if (sd)
                        clif_skillinfo(sd,MO_EXTREMITYFIST, INF_SELF_SKILL);
                    break;
                case TK_JUMPKICK:
                    if (sd)
                        clif_skillinfo(sd,TK_JUMPKICK, INF_SELF_SKILL);
                    break;
                case MO_TRIPLEATTACK:
                    if (sd && pc_checkskill(sd, SR_DRAGONCOMBO) > 0)
                        clif_skillinfo(sd,SR_DRAGONCOMBO, INF_SELF_SKILL);
                    break;
                case SR_FALLENEMPIRE:
                    if (sd) {
                        clif_skillinfo(sd,SR_GATEOFHELL, INF_SELF_SKILL);
                        clif_skillinfo(sd,SR_TIGERCANNON, INF_SELF_SKILL);
                    }
                    break;
            }
            break;
        case SC_RAISINGDRAGON:
            sce->val2 = status->max_hp / 100;// Officially tested its 1%hp drain. [Jobbie]
            break;
    }

    if (opt_flag&2 && sd && sd->touching_id)
        npc_touchnext_areanpc(sd,false); // run OnTouch_ on next char in range

    return 1;
}

/*==========================================
 * Ending all status except those listed.
 * @TODO maybe usefull for dispel instead reseting a liste there.
 * type:
 * 0 - PC killed -> Place here statuses that do not dispel on death.
 * 1 - If for some reason status_change_end decides to still keep the status when quitting.
 * 2 - Do clif
 * 3 - Do not remove some permanent/time-independent effects
 *------------------------------------------*/
int status_change_clear(struct block_list *bl, int type)
{
    struct status_change *sc;
    int i;

    sc = status_get_sc(bl);

    if (!sc || !sc->count)
        return 0;

    for (i = 0; i < SC_MAX; i++) {
        if (!sc->data[i])
            continue;

        if (type == 0)
            switch (i) {
                    //Type 0: PC killed -> Place here statuses that do not dispel on death.
                case SC_ELEMENTALCHANGE://Only when its Holy or Dark that it doesn't dispell on death
                    if (sc->data[i]->val2 != ELE_HOLY && sc->data[i]->val2 != ELE_DARK)
                        break;
                case SC_WEIGHT50:
                case SC_WEIGHT90:
                case SC_EDP:
                case SC_MELTDOWN:
                case SC_XMAS:
                case SC_SUMMER:
                case SC_NOCHAT:
                case SC_FUSION:
                case SC_EARTHSCROLL:
                case SC_READYSTORM:
                case SC_READYDOWN:
                case SC_READYCOUNTER:
                case SC_READYTURN:
                case SC_DODGE:
                case SC_JAILED:
                case SC_EXPBOOST:
                case SC_ITEMBOOST:
                case SC_HELLPOWER:
                case SC_JEXPBOOST:
                case SC_AUTOTRADE:
                case SC_WHISTLE:
                case SC_ASSNCROS:
                case SC_POEMBRAGI:
                case SC_APPLEIDUN:
                case SC_HUMMING:
                case SC_DONTFORGETME:
                case SC_FORTUNE:
                case SC_SERVICE4U:
                case SC_FOOD_STR_CASH:
                case SC_FOOD_AGI_CASH:
                case SC_FOOD_VIT_CASH:
                case SC_FOOD_DEX_CASH:
                case SC_FOOD_INT_CASH:
                case SC_FOOD_LUK_CASH:
                case SC_DEF_RATE:
                case SC_MDEF_RATE:
                case SC_INCHEALRATE:
                case SC_INCFLEE2:
                case SC_INCHIT:
                case SC_ATKPOTION:
                case SC_MATKPOTION:
                case SC_S_LIFEPOTION:
                case SC_L_LIFEPOTION:
                case SC_PUSH_CART:
                    continue;

            }

        if (type == 3) {
            switch (i) {
                    // TODO: This list may be incomplete
                case SC_WEIGHT50:
                case SC_WEIGHT90:
                case SC_NOCHAT:
                case SC_PUSH_CART:
                    continue;
            }
        }

        status_change_end(bl, (sc_type)i, INVALID_TIMER);

        if (type == 1 && sc->data[i]) {
            //If for some reason status_change_end decides to still keep the status when quitting. [Skotlex]
            (sc->count)--;
            if (sc->data[i]->timer != INVALID_TIMER)
                delete_timer(sc->data[i]->timer, status_change_timer);
            ers_free(sc_data_ers, sc->data[i]);
            sc->data[i] = NULL;
        }
    }

    sc->opt1 = 0;
    sc->opt2 = 0;
    sc->opt3 = 0;
    sc->option &= OPTION_MASK;

    if (type == 0 || type == 2)
        clif_changeoption(bl);

    return 1;
}

/*==========================================
 * Special condition we want to effectuate, check before ending a status.
 *------------------------------------------*/
int status_change_end_(struct block_list *bl, enum sc_type type, int tid, const char *file, int line)
{
    struct map_session_data *sd;
    struct status_change *sc;
    struct status_change_entry *sce;
    struct status_data *status;
    struct view_data *vd;
    int opt_flag=0, calc_flag;

    nullpo_ret(bl);

    sc = status_get_sc(bl);
    status = status_get_status_data(bl);

    if (type < 0 || type >= SC_MAX || !sc || !(sce = sc->data[type]))
        return 0;

    sd = BL_CAST(BL_PC,bl);

    if (sce->timer != tid && tid != INVALID_TIMER)
        return 0;

    if (tid == INVALID_TIMER) {
        if (type == SC_ENDURE && sce->val4)
            //Do not end infinite endure.
            return 0;
        if (sce->timer != INVALID_TIMER) //Could be a SC with infinite duration
            delete_timer(sce->timer,status_change_timer);
        if (sc->opt1)
            switch (type) {
                    //"Ugly workaround"  [Skotlex]
                    //delays status change ending so that a skill that sets opt1 fails to
                    //trigger when it also removed one
                case SC_STONE:
                    sce->val3 = 0; //Petrify time counter.
                case SC_FREEZE:
                case SC_STUN:
                case SC_SLEEP:
                    if (sce->val1) {
                        //Removing the 'level' shouldn't affect anything in the code
                        //since these SC are not affected by it, and it lets us know
                        //if we have already delayed this attack or not.
                        sce->val1 = 0;
                        sce->timer = add_timer(gettick()+10, status_change_timer, bl->id, type);
                        return 1;
                    }
            }
    }

    (sc->count)--;

    if (StatusChangeStateTable[type])
        status_calc_state(bl,sc,(enum scs_flag) StatusChangeStateTable[type],false);

    sc->data[type] = NULL;

    vd = status_get_viewdata(bl);
    calc_flag = StatusChangeFlagTable[type];
    switch (type) {
        case SC_GRANITIC_ARMOR: {
                int dammage = status->max_hp*sce->val3/100;
                if (status->hp < dammage) //to not kill him
                    dammage = status->hp-1;
                status_damage(NULL, bl, dammage,0,0,1);
                break;
            }
        case SC_PYROCLASTIC:
            if (bl->type == BL_PC)
                skill_break_equip(bl,EQP_WEAPON,10000,BCT_SELF);
            break;
        case SC_WEDDING:
        case SC_XMAS:
        case SC_SUMMER:
            if (!vd) break;
            if (sd) {
                //Load data from sd->status.* as the stored values could have changed.
                //Must remove OPTION to prevent class being rechanged.
                sc->option &= type==SC_WEDDING?~OPTION_WEDDING:type==SC_XMAS?~OPTION_XMAS:~OPTION_SUMMER;
                clif_changeoption(&sd->bl);
                status_set_viewdata(bl, sd->status.class_);
            } else {
                vd->class_ = sce->val1;
                vd->weapon = sce->val2;
                vd->shield = sce->val3;
                vd->cloth_color = sce->val4;
            }
            clif_changelook(bl,LOOK_BASE,vd->class_);
            clif_changelook(bl,LOOK_CLOTHES_COLOR,vd->cloth_color);
            clif_changelook(bl,LOOK_WEAPON,vd->weapon);
            clif_changelook(bl,LOOK_SHIELD,vd->shield);
            if (sd) clif_skillinfoblock(sd);
            break;
        case SC_RUN: {
                struct unit_data *ud = unit_bl2ud(bl);
                bool begin_spurt = true;
                if (ud) {
                    if (!ud->state.running)
                        begin_spurt = false;
                    ud->state.running = 0;
                    if (ud->walktimer != INVALID_TIMER)
                        unit_stop_walking(bl,1);
                }
                if (begin_spurt && sce->val1 >= 7 &&
                    DIFF_TICK(gettick(), sce->val4) <= 1000 &&
                    (!sd || (sd->weapontype1 == 0 && sd->weapontype2 == 0))
                   )
                    sc_start(bl,SC_SPURT,100,sce->val1,skill_get_time2(status_sc2skill(type), sce->val1));
            }
            break;
        case SC_AUTOBERSERK:
            if (sc->data[SC_PROVOKE] && sc->data[SC_PROVOKE]->val2 == 1)
                status_change_end(bl, SC_PROVOKE, INVALID_TIMER);
            break;

        case SC_ENDURE:
        case SC_DEFENDER:
        case SC_REFLECTSHIELD:
        case SC_AUTOGUARD: {
                struct map_session_data *tsd;
                if (bl->type == BL_PC) {
                    // Clear Status from others
                    int i;
                    for (i = 0; i < 5; i++) {
                        if (sd->devotion[i] && (tsd = map_id2sd(sd->devotion[i])) && tsd->sc.data[type])
                            status_change_end(&tsd->bl, type, INVALID_TIMER);
                    }
                } else if (bl->type == BL_MER && ((TBL_MER *)bl)->devotion_flag) {
                    // Clear Status from Master
                    tsd = ((TBL_MER *)bl)->master;
                    if (tsd && tsd->sc.data[type])
                        status_change_end(&tsd->bl, type, INVALID_TIMER);
                }
            }
            break;
        case SC_DEVOTION: {
                struct block_list *d_bl = map_id2bl(sce->val1);
                if (d_bl) {
                    if (d_bl->type == BL_PC)
                        ((TBL_PC *)d_bl)->devotion[sce->val2] = 0;
                    else if (d_bl->type == BL_MER)
                        ((TBL_MER *)d_bl)->devotion_flag = 0;
                    clif_devotion(d_bl, NULL);
                }

                status_change_end(bl, SC_AUTOGUARD, INVALID_TIMER);
                status_change_end(bl, SC_DEFENDER, INVALID_TIMER);
                status_change_end(bl, SC_REFLECTSHIELD, INVALID_TIMER);
                status_change_end(bl, SC_ENDURE, INVALID_TIMER);
            }
            break;

        case SC_BLADESTOP:
            if (sce->val4) {
                int tid = sce->val4;
                struct block_list *tbl = map_id2bl(tid);
                struct status_change *tsc = status_get_sc(tbl);
                sce->val4 = 0;
                if (tbl && tsc && tsc->data[SC_BLADESTOP]) {
                    tsc->data[SC_BLADESTOP]->val4 = 0;
                    status_change_end(tbl, SC_BLADESTOP, INVALID_TIMER);
                }
                clif_bladestop(bl, tid, 0);
            }
            break;
        case SC_DANCING: {
                const char *prevfile = "<unknown>";
                int prevline = 0;
                struct map_session_data *dsd;
                struct status_change_entry *dsc;
                struct skill_unit_group *group;

                if (sd) {
                    if (sd->delunit_prevfile) {
                        // initially this is NULL, when a character logs in
                        prevfile = sd->delunit_prevfile;
                        prevline = sd->delunit_prevline;
                    } else {
                        prevfile = "<none>";
                    }
                    sd->delunit_prevfile = file;
                    sd->delunit_prevline = line;
                }

                if (sce->val4 && sce->val4 != BCT_SELF && (dsd=map_id2sd(sce->val4))) {
                    // end status on partner as well
                    dsc = dsd->sc.data[SC_DANCING];
                    if (dsc) {

                        //This will prevent recursive loops.
                        dsc->val2 = dsc->val4 = 0;

                        status_change_end(&dsd->bl, SC_DANCING, INVALID_TIMER);
                    }
                }

                if (sce->val2) {
                    // erase associated land skill
                    group = skill_id2group(sce->val2);

                    if (group == NULL) {
                        ShowDebug("status_change_end: SC_DANCING is missing skill unit group (val1=%d, val2=%d, val3=%d, val4=%d, timer=%d, tid=%d, char_id=%d, map=%s, x=%d, y=%d, prev=%s:%d, from=%s:%d). Please report this! (#3504)\n",
                                  sce->val1, sce->val2, sce->val3, sce->val4, sce->timer, tid,
                                  sd ? sd->status.char_id : 0,
                                  mapindex_id2name(map_id2index(bl->m)), bl->x, bl->y,
                                  prevfile, prevline,
                                  file, line);
                    }

                    sce->val2 = 0;
                    skill_delunitgroup(group);
                }

                if ((sce->val1&0xFFFF) == CG_MOONLIT)
                    clif_status_change(bl,SI_MOONLIT,0,0,0,0,0);

                status_change_end(bl, SC_LONGING, INVALID_TIMER);
            }
            break;
        case SC_NOCHAT:
            if (sd && sd->status.manner < 0 && tid != INVALID_TIMER)
                sd->status.manner = 0;
            if (sd && tid == INVALID_TIMER) {
                clif_changestatus(sd,SP_MANNER,sd->status.manner);
                clif_updatestatus(sd,SP_MANNER);
            }
            break;
        case SC_SPLASHER: {
                struct block_list *src=map_id2bl(sce->val3);
                if (src && tid != INVALID_TIMER)
                    skill_castend_damage_id(src, bl, sce->val2, sce->val1, gettick(), SD_LEVEL);
            }
            break;
        case SC_CLOSECONFINE2: {
                struct block_list *src = sce->val2?map_id2bl(sce->val2):NULL;
                struct status_change *sc2 = src?status_get_sc(src):NULL;
                if (src && sc2 && sc2->data[SC_CLOSECONFINE]) {
                    //If status was already ended, do nothing.
                    //Decrease count
                    if (--(sc2->data[SC_CLOSECONFINE]->val1) <= 0) //No more holds, free him up.
                        status_change_end(src, SC_CLOSECONFINE, INVALID_TIMER);
                }
            }
        case SC_CLOSECONFINE:
            if (sce->val2 > 0) {
                //Caster has been unlocked... nearby chars need to be unlocked.
                int range = 1
                            +skill_get_range2(bl, status_sc2skill(type), sce->val1)
                            +skill_get_range2(bl, TF_BACKSLIDING, 1); //Since most people use this to escape the hold....
                map_foreachinarea(status_change_timer_sub,
                                  bl->m, bl->x-range, bl->y-range, bl->x+range,bl->y+range,BL_CHAR,bl,sce,type,gettick());
            }
            break;
        case SC_COMBO:
            if (sd)
                switch (sce->val1) {
                    case MO_COMBOFINISH:
                    case CH_TIGERFIST:
                    case CH_CHAINCRUSH:
                        clif_skillinfo(sd, MO_EXTREMITYFIST, 0);
                        break;
                    case TK_JUMPKICK:
                        clif_skillinfo(sd, TK_JUMPKICK, 0);
                        break;
                    case MO_TRIPLEATTACK:
                        if (pc_checkskill(sd, SR_DRAGONCOMBO) > 0)
                            clif_skillinfo(sd, SR_DRAGONCOMBO, 0);
                        break;
                    case SR_FALLENEMPIRE:
                        clif_skillinfo(sd, SR_GATEOFHELL, 0);
                        clif_skillinfo(sd, SR_TIGERCANNON, 0);
                        break;
                }
            break;

        case SC_MARIONETTE:
        case SC_MARIONETTE2:    /// Marionette target
            if (sce->val1) {
                // check for partner and end their marionette status as well
                enum sc_type type2 = (type == SC_MARIONETTE) ? SC_MARIONETTE2 : SC_MARIONETTE;
                struct block_list *pbl = map_id2bl(sce->val1);
                struct status_change *sc2 = pbl?status_get_sc(pbl):NULL;

                if (sc2 && sc2->data[type2]) {
                    sc2->data[type2]->val1 = 0;
                    status_change_end(pbl, type2, INVALID_TIMER);
                }
            }
            break;

        case SC_BERSERK:
        case SC_SATURDAYNIGHTFEVER:
            //If val2 is removed, no HP penalty (dispelled?) [Skotlex]
            if (status->hp > 100 && sce->val2)
                status_set_hp(bl, 100, 0);
            if (sc->data[SC_ENDURE] && sc->data[SC_ENDURE]->val4 == 2) {
                sc->data[SC_ENDURE]->val4 = 0;
                status_change_end(bl, SC_ENDURE, INVALID_TIMER);
            }
        case SC__BLOODYLUST:
            sc_start4(bl, SC_REGENERATION, 100, 10,0,0,(RGN_HP|RGN_SP), skill_get_time(LK_BERSERK, sce->val1));
            if (type == SC_SATURDAYNIGHTFEVER)  //Sit down force of Saturday Night Fever has the duration of only 3 seconds.
                sc_start(bl,SC_SITDOWN_FORCE,100,sce->val1,skill_get_time2(WM_SATURDAY_NIGHT_FEVER,sce->val1));
            break;
        case SC_GOSPEL:
            if (sce->val3) { //Clear the group.
                struct skill_unit_group *group = skill_id2group(sce->val3);
                sce->val3 = 0;
                skill_delunitgroup(group);
            }
            break;
        case SC_HERMODE:
            if (sce->val3 == BCT_SELF)
                skill_clear_unitgroup(bl);
            break;
        case SC_BASILICA: //Clear the skill area. [Skotlex]
            skill_clear_unitgroup(bl);
            break;
        case SC_TRICKDEAD:
            if (vd) vd->dead_sit = 0;
            break;
        case SC_WARM:
        case SC__MANHOLE:
            if (sce->val4) { //Clear the group.
                struct skill_unit_group *group = skill_id2group(sce->val4);
                sce->val4 = 0;
                if (group)  /* might have been cleared before status ended, e.g. land protector */
                    skill_delunitgroup(group);
            }
            break;
        case SC_KAAHI:
            //Delete timer if it exists.
            if (sce->val4 != INVALID_TIMER)
                delete_timer(sce->val4,kaahi_heal_timer);
            break;
        case SC_JAILED:
            if (tid == INVALID_TIMER)
                break;
            //natural expiration.
            if (sd && sd->mapindex == sce->val2)
                pc_setpos(sd,(unsigned short)sce->val3,sce->val4&0xFFFF, sce->val4>>16, CLR_TELEPORT);
            break; //guess hes not in jail :P
        case SC_CHANGE:
            if (tid == INVALID_TIMER)
                break;
            // "lose almost all their HP and SP" on natural expiration.
            status_set_hp(bl, 10, 0);
            status_set_sp(bl, 10, 0);
            break;
        case SC_AUTOTRADE:
            if (tid == INVALID_TIMER)
                break;
            // Note: vending/buying is closed by unit_remove_map, no
            // need to do it here.
            map_quit(sd);
            // Because map_quit calls status_change_end with tid -1
            // from here it's not neccesary to continue
            return 1;
            break;
        case SC_STOP:
            if (sce->val2) {
                struct block_list *tbl = map_id2bl(sce->val2);
                sce->val2 = 0;
                if (tbl && (sc = status_get_sc(tbl)) && sc->data[SC_STOP] && sc->data[SC_STOP]->val2 == bl->id)
                    status_change_end(tbl, SC_STOP, INVALID_TIMER);
            }
            break;
            /**
             * 3rd Stuff
             **/
        case SC_MILLENNIUMSHIELD:
            clif_millenniumshield(sd,0);
            break;
        case SC_HALLUCINATIONWALK:
            sc_start(bl,SC_HALLUCINATIONWALK_POSTDELAY,100,sce->val1,skill_get_time2(GC_HALLUCINATIONWALK,sce->val1));
            break;
        case SC_WHITEIMPRISON:
            if (tid == -1)
                break; // Terminated by Damage
            status_fix_damage(bl,bl,400*sce->val1,clif_damage(bl,bl,gettick(),0,0,400*sce->val1,0,0,0));
            break;
        case SC_WUGDASH: {
                struct unit_data *ud = unit_bl2ud(bl);
                if (ud) {
                    ud->state.running = 0;
                    if (ud->walktimer != -1)
                        unit_stop_walking(bl,1);
                }
            }
            break;
        case SC_ADORAMUS:
            status_change_end(bl, SC_BLIND, INVALID_TIMER);
            break;
        case SC__SHADOWFORM: {
                struct map_session_data *s_sd = map_id2sd(sce->val2);
                if (!s_sd)
                    break;
                s_sd->shadowform_id = 0;
            }
            break;
        case SC_SITDOWN_FORCE:
            if (sd && pc_issit(sd)) {
                pc_setstand(sd);
                clif_standing(bl);
            }
            break;
        case SC_NEUTRALBARRIER_MASTER:
        case SC_STEALTHFIELD_MASTER:
            if (sce->val2) {
                struct skill_unit_group *group = skill_id2group(sce->val2);
                sce->val2 = 0;
                if (group)  /* might have been cleared before status ended, e.g. land protector */
                    skill_delunitgroup(group);
            }
            break;
        case SC_BANDING:
            if (sce->val4) {
                struct skill_unit_group *group = skill_id2group(sce->val4);
                sce->val4 = 0;
                if (group)  /* might have been cleared before status ended, e.g. land protector */
                    skill_delunitgroup(group);
            }
            break;
        case SC_CURSEDCIRCLE_ATKER:
            if (sce->val2)  // used the default area size cause there is a chance the caster could knock back and can't clear the target.
                map_foreachinrange(status_change_timer_sub, bl, battle_config.area_size,BL_CHAR, bl, sce, SC_CURSEDCIRCLE_TARGET, gettick());
            break;
        case SC_RAISINGDRAGON:
            if (sd && sce->val2 && !pc_isdead(sd)) {
                int i;
                i = min(sd->spiritball,5);
                pc_delspiritball(sd, sd->spiritball, 0);
                status_change_end(bl, SC_EXPLOSIONSPIRITS, INVALID_TIMER);
                while (i > 0) {
                    pc_addspiritball(sd, skill_get_time(MO_CALLSPIRITS, pc_checkskill(sd,MO_CALLSPIRITS)), 5);
                    --i;
                }
            }
            break;
        case SC_CURSEDCIRCLE_TARGET: {
                struct block_list *src = map_id2bl(sce->val2);
                struct status_change *sc = status_get_sc(src);
                if (sc && sc->data[SC_CURSEDCIRCLE_ATKER] && --(sc->data[SC_CURSEDCIRCLE_ATKER]->val2) == 0) {
                    status_change_end(src, SC_CURSEDCIRCLE_ATKER, INVALID_TIMER);
                    clif_bladestop(bl, sce->val2, 0);
                }
            }
            break;
        case SC_BLOODSUCKER:
            if (sce->val2) {
                struct block_list *src = map_id2bl(sce->val2);
                if (src) {
                    struct status_change *sc = status_get_sc(src);
                    sc->bs_counter--;
                }
            }
            break;
        case SC_VACUUM_EXTREME:
            if (sc && sc->cant.move > 0) sc->cant.move--;
            break;
        case SC_KYOUGAKU:
            clif_status_load(bl, SI_KYOUGAKU, 0); // Avoid client crash
            clif_status_load(bl, SI_ACTIVE_MONSTER_TRANSFORM, 0);
            break;
        case SC_INTRAVISION:
            calc_flag = SCB_ALL;/* required for overlapping */
            break;
    }

    opt_flag = 1;
    switch (type) {
        case SC_STONE:
        case SC_FREEZE:
        case SC_STUN:
        case SC_SLEEP:
        case SC_DEEPSLEEP:
        case SC_BURNING:
        case SC_WHITEIMPRISON:
        case SC_CRYSTALIZE:
            sc->opt1 = 0;
            break;

        case SC_POISON:
        case SC_CURSE:
        case SC_SILENCE:
        case SC_BLIND:
            sc->opt2 &= ~(1<<(type-SC_POISON));
            break;
        case SC_DPOISON:
            sc->opt2 &= ~OPT2_DPOISON;
            break;
        case SC_SIGNUMCRUCIS:
            sc->opt2 &= ~OPT2_SIGNUMCRUCIS;
            break;

        case SC_HIDING:
            sc->option &= ~OPTION_HIDE;
            opt_flag|= 2|4; //Check for warp trigger + AoE trigger
            break;
        case SC_CLOAKING:
        case SC_CLOAKINGEXCEED:
        case SC__INVISIBILITY:
            sc->option &= ~OPTION_CLOAK;
        case SC_CAMOUFLAGE:
            opt_flag|= 2;
            break;
        case SC_CHASEWALK:
            sc->option &= ~(OPTION_CHASEWALK|OPTION_CLOAK);
            opt_flag|= 2;
            break;
        case SC_SIGHT:
            sc->option &= ~OPTION_SIGHT;
            break;
        case SC_WEDDING:
            sc->option &= ~OPTION_WEDDING;
            break;
        case SC_XMAS:
            sc->option &= ~OPTION_XMAS;
            break;
        case SC_SUMMER:
            sc->option &= ~OPTION_SUMMER;
            break;
        case SC_ORCISH:
            sc->option &= ~OPTION_ORCISH;
            break;
        case SC_RUWACH:
            sc->option &= ~OPTION_RUWACH;
            break;
        case SC_FUSION:
            sc->option &= ~OPTION_FLYING;
            break;
            //opt3
        case SC_TWOHANDQUICKEN:
        case SC_ONEHAND:
        case SC_SPEARQUICKEN:
        case SC_CONCENTRATION:
        case SC_MERC_QUICKEN:
            sc->opt3 &= ~OPT3_QUICKEN;
            opt_flag = 0;
            break;
        case SC_OVERTHRUST:
        case SC_MAXOVERTHRUST:
        case SC_SWOO:
            sc->opt3 &= ~OPT3_OVERTHRUST;
            if (type == SC_SWOO)
                opt_flag = 8;
            else
                opt_flag = 0;
            break;
        case SC_ENERGYCOAT:
        case SC_SKE:
            sc->opt3 &= ~OPT3_ENERGYCOAT;
            opt_flag = 0;
            break;
        case SC_INCATKRATE: //Simulated Explosion spirits effect.
            if (bl->type != BL_MOB) {
                opt_flag = 0;
                break;
            }
        case SC_EXPLOSIONSPIRITS:
            sc->opt3 &= ~OPT3_EXPLOSIONSPIRITS;
            opt_flag = 0;
            break;
        case SC_STEELBODY:
        case SC_SKA:
            sc->opt3 &= ~OPT3_STEELBODY;
            opt_flag = 0;
            break;
        case SC_BLADESTOP:
            sc->opt3 &= ~OPT3_BLADESTOP;
            opt_flag = 0;
            break;
        case SC_AURABLADE:
            sc->opt3 &= ~OPT3_AURABLADE;
            opt_flag = 0;
            break;
        case SC_BERSERK:
            opt_flag = 0;
            //  case SC__BLOODYLUST:
            sc->opt3 &= ~OPT3_BERSERK;
            break;
            //  case ???: // doesn't seem to do anything
            //      sc->opt3 &= ~OPT3_LIGHTBLADE;
            //      opt_flag = 0;
            //      break;
        case SC_DANCING:
            if ((sce->val1&0xFFFF) == CG_MOONLIT)
                sc->opt3 &= ~OPT3_MOONLIT;
            opt_flag = 0;
            break;
        case SC_MARIONETTE:
        case SC_MARIONETTE2:
            sc->opt3 &= ~OPT3_MARIONETTE;
            opt_flag = 0;
            break;
        case SC_ASSUMPTIO:
            sc->opt3 &= ~OPT3_ASSUMPTIO;
            opt_flag = 0;
            break;
        case SC_WARM: //SG skills [Komurka]
            sc->opt3 &= ~OPT3_WARM;
            opt_flag = 0;
            break;
        case SC_KAITE:
            sc->opt3 &= ~OPT3_KAITE;
            opt_flag = 0;
            break;
        case SC_BUNSINJYUTSU:
            sc->opt3 &= ~OPT3_BUNSIN;
            opt_flag = 0;
            break;
        case SC_SPIRIT:
            sc->opt3 &= ~OPT3_SOULLINK;
            opt_flag = 0;
            break;
        case SC_CHANGEUNDEAD:
            sc->opt3 &= ~OPT3_UNDEAD;
            opt_flag = 0;
            break;
            //  case ???: // from DA_CONTRACT (looks like biolab mobs aura)
            //      sc->opt3 &= ~OPT3_CONTRACT;
            //      opt_flag = 0;
            //      break;
        default:
            opt_flag = 0;
    }

    if (calc_flag&SCB_DYE) {
        //Restore DYE color
        if (vd && !vd->cloth_color && sce->val4)
            clif_changelook(bl,LOOK_CLOTHES_COLOR,sce->val4);
        calc_flag&=~SCB_DYE;
    }

    //On Aegis, when turning off a status change, first goes the sc packet, then the option packet.
    clif_status_change(bl,StatusIconChangeTable[type],0,0,0,0,0);

    if (opt_flag&8)  //bugreport:681
        clif_changeoption2(bl);
    else if (opt_flag)
        clif_changeoption(bl);

    if (calc_flag)
        status_calc_bl(bl,calc_flag);

    if (opt_flag&4) //Out of hiding, invoke on place.
        skill_unit_move(bl,gettick(),1);

    if (opt_flag&2 && sd && map_getcell(bl->m,bl->x,bl->y,CELL_CHKNPC))
        npc_touch_areanpc(sd,bl->m,bl->x,bl->y); //Trigger on-touch event.

    ers_free(sc_data_ers, sce);
    return 1;
}

int kaahi_heal_timer(int tid, unsigned int tick, int id, intptr_t data)
{
    struct block_list *bl;
    struct status_change *sc;
    struct status_change_entry *sce;
    struct status_data *status;
    int hp;

    if (!((bl=map_id2bl(id))&&
          (sc=status_get_sc(bl)) &&
          (sce = sc->data[SC_KAAHI])))
        return 0;

    if (sce->val4 != tid) {
        ShowError("kaahi_heal_timer: Timer mismatch: %d != %d\n", tid, sce->val4);
        sce->val4 = INVALID_TIMER;
        return 0;
    }

    status=status_get_status_data(bl);
    if (!status_charge(bl, 0, sce->val3)) {
        sce->val4 = INVALID_TIMER;
        return 0;
    }

    hp = status->max_hp - status->hp;
    if (hp > sce->val2)
        hp = sce->val2;
    if (hp)
        status_heal(bl, hp, 0, 2);
    sce->val4 = INVALID_TIMER;
    return 1;
}

/*==========================================
 * For recusive status, like for each 5s we drop sp etc.
 * Reseting the end timer.
 *------------------------------------------*/
int status_change_timer(int tid, unsigned int tick, int id, intptr_t data)
{
    enum sc_type type = (sc_type)data;
    struct block_list *bl;
    struct map_session_data *sd;
    struct status_data *status;
    struct status_change *sc;
    struct status_change_entry *sce;

    bl = map_id2bl(id);
    if (!bl) {
        ShowDebug("status_change_timer: Null pointer id: %d data: %d\n", id, data);
        return 0;
    }
    sc = status_get_sc(bl);
    status = status_get_status_data(bl);

    if (!(sc && (sce = sc->data[type]))) {
        ShowDebug("status_change_timer: Null pointer id: %d data: %d bl-type: %d\n", id, data, bl->type);
        return 0;
    }

    if (sce->timer != tid) {
        ShowError("status_change_timer: Mismatch for type %d: %d != %d (bl id %d)\n",type,tid,sce->timer, bl->id);
        return 0;
    }

    sd = BL_CAST(BL_PC, bl);

    // set the next timer of the sce (don't assume the status still exists)
#define sc_timer_next(t,f,i,d) \
    if( (sce=sc->data[type]) ) \
        sce->timer = add_timer(t,f,i,d); \
    else \
        ShowError("status_change_timer: Unexpected NULL status change id: %d data: %d\n", id, data)

    switch (type) {
        case SC_MAXIMIZEPOWER:
        case SC_CLOAKING:
            if (!status_charge(bl, 0, 1))
                break; //Not enough SP to continue.
            sc_timer_next(sce->val2+tick, status_change_timer, bl->id, data);
            return 0;

        case SC_CHASEWALK:
            if (!status_charge(bl, 0, sce->val4))
                break; //Not enough SP to continue.

            if (!sc->data[SC_INCSTR]) {
                sc_start(bl, SC_INCSTR,100,1<<(sce->val1-1),
                         (sc->data[SC_SPIRIT] && sc->data[SC_SPIRIT]->val2 == SL_ROGUE?10:1) //SL bonus -> x10 duration
                         *skill_get_time2(status_sc2skill(type),sce->val1));
            }
            sc_timer_next(sce->val2+tick, status_change_timer, bl->id, data);
            return 0;
            break;

        case SC_SKA:
            if (--(sce->val2)>0) {
                sce->val3 = rnd()%100; //Random defense.
                sc_timer_next(1000+tick, status_change_timer,bl->id, data);
                return 0;
            }
            break;

        case SC_HIDING:
            if (--(sce->val2)>0) {

                if (sce->val2 % sce->val4 == 0 && !status_charge(bl, 0, 1))
                    break; //Fail if it's time to substract SP and there isn't.

                sc_timer_next(1000+tick, status_change_timer,bl->id, data);
                return 0;
            }
            break;

        case SC_SIGHT:
        case SC_RUWACH:
        case SC_SIGHTBLASTER:
            map_foreachinrange(status_change_timer_sub, bl, sce->val3, BL_CHAR, bl, sce, type, tick);

            if (--(sce->val2)>0) {
                sce->val4 += 250; // use for Shadow Form 2 seconds checking.
                sc_timer_next(250+tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_PROVOKE:
            if (sce->val2) { //Auto-provoke (it is ended in status_heal)
                sc_timer_next(1000*60+tick,status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_STONE:
            if (sc->opt1 == OPT1_STONEWAIT && sce->val3) {
                sce->val4 = 0;
                unit_stop_walking(bl,1);
                unit_stop_attack(bl);
                sc->opt1 = OPT1_STONE;
                clif_changeoption(bl);
                sc_timer_next(1000+tick,status_change_timer, bl->id, data);
                status_calc_bl(bl, StatusChangeFlagTable[type]);
                return 0;
            }
            if (--(sce->val3) > 0) {
                if (++(sce->val4)%5 == 0 && status->hp > status->max_hp/4)
                    status_percent_damage(NULL, bl, 1, 0, false);
                sc_timer_next(1000+tick,status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_POISON:
            if (status->hp <= max(status->max_hp>>2, sce->val4)) //Stop damaging after 25% HP left.
                break;
        case SC_DPOISON:
            if (--(sce->val3) > 0) {
                if (!sc->data[SC_SLOWPOISON]) {
                    if (sce->val2 && bl->type == BL_MOB) {
                        struct block_list *src = map_id2bl(sce->val2);
                        if (src)
                            mob_log_damage((TBL_MOB *)bl,src,sce->val4);
                    }
                    map_freeblock_lock();
                    status_zap(bl, sce->val4, 0);
                    if (sc->data[type]) { // Check if the status still last ( can be dead since then ).
                        sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                    }
                    map_freeblock_unlock();
                }
                return 0;
            }
            break;

        case SC_TENSIONRELAX:
            if (status->max_hp > status->hp && --(sce->val3) > 0) {
                sc_timer_next(sce->val4+tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_KNOWLEDGE:
            if (!sd) break;
            if (bl->m == sd->feel_map[0].m ||
                bl->m == sd->feel_map[1].m ||
                bl->m == sd->feel_map[2].m) {
                //Timeout will be handled by pc_setpos
                sce->timer = INVALID_TIMER;
                return 0;
            }
            break;

        case SC_BLEEDING:
            if (--(sce->val4) >= 0) {
                int hp =  rnd()%600 + 200;
                map_freeblock_lock();
                status_fix_damage(NULL, bl, sd||hp<status->hp?hp:status->hp-1, 1);
                if (sc->data[type]) {
                    if (status->hp == 1) {
                        map_freeblock_unlock();
                        break;
                    }
                    sc_timer_next(10000 + tick, status_change_timer, bl->id, data);
                }
                map_freeblock_unlock();
                return 0;
            }
            break;

        case SC_S_LIFEPOTION:
        case SC_L_LIFEPOTION:
            if (sd && --(sce->val4) >= 0) {
                // val1 < 0 = per max% | val1 > 0 = exact amount
                int hp = 0;
                if (status->hp < status->max_hp)
                    hp = (sce->val1 < 0) ? (int)(sd->status.max_hp * -1 * sce->val1 / 100.) : sce->val1 ;
                status_heal(bl, hp, 0, 2);
                sc_timer_next((sce->val2 * 1000) + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_BOSSMAPINFO:
            if (sd && --(sce->val4) >= 0) {
                struct mob_data *boss_md = map_id2boss(sce->val1);
                if (boss_md && sd->bl.m == boss_md->bl.m) {
                    clif_bossmapinfo(sd->fd, boss_md, 1); // Update X - Y on minimap
                    if (boss_md->bl.prev != NULL) {
                        sc_timer_next(5000 + tick, status_change_timer, bl->id, data);
                        return 0;
                    }
                }
            }
            break;

        case SC_DANCING: { //SP consumption by time of dancing skills
                int s = 0;
                int sp = 1;
                if (--sce->val3 <= 0)
                    break;
                switch (sce->val1&0xFFFF) {
                    case BD_RICHMANKIM:
                    case BD_DRUMBATTLEFIELD:
                    case BD_RINGNIBELUNGEN:
                    case BD_SIEGFRIED:
                    case BA_DISSONANCE:
                    case BA_ASSASSINCROSS:
                    case DC_UGLYDANCE:
                        s=3;
                        break;
                    case BD_LULLABY:
                    case BD_ETERNALCHAOS:
                    case BD_ROKISWEIL:
                    case DC_FORTUNEKISS:
                        s=4;
                        break;
                    case CG_HERMODE:
                    case BD_INTOABYSS:
                    case BA_WHISTLE:
                    case DC_HUMMING:
                    case BA_POEMBRAGI:
                    case DC_SERVICEFORYOU:
                        s=5;
                        break;
                    case BA_APPLEIDUN:
#ifdef RENEWAL
                        s=5;
#else
                        s=6;
#endif
                        break;
                    case CG_MOONLIT:
                        //Moonlit's cost is 4sp*skill_lv [Skotlex]
                        sp= 4*(sce->val1>>16);
                        //Upkeep is also every 10 secs.
                    case DC_DONTFORGETME:
                        s=10;
                        break;
                }
                if (s != 0 && sce->val3 % s == 0) {
                    if (sc->data[SC_LONGING])
                        sp*= 3;
                    if (!status_charge(bl, 0, sp))
                        break;
                }
                sc_timer_next(1000+tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;
        case SC__BLOODYLUST:
        case SC_BERSERK:
            // 5% every 10 seconds [DracoRPG]
            if (--(sce->val3) > 0 && status_charge(bl, sce->val2, 0) && status->hp > 100) {
                sc_timer_next(sce->val4+tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_NOCHAT:
            if (sd) {
                sd->status.manner++;
                clif_changestatus(sd,SP_MANNER,sd->status.manner);
                clif_updatestatus(sd,SP_MANNER);
                if (sd->status.manner < 0) {
                    //Every 60 seconds your manner goes up by 1 until it gets back to 0.
                    sc_timer_next(60000+tick, status_change_timer, bl->id, data);
                    return 0;
                }
            }
            break;

        case SC_SPLASHER:
            // custom Venom Splasher countdown timer
            //if (sce->val4 % 1000 == 0) {
            //  char timer[10];
            //  snprintf (timer, 10, "%d", sce->val4/1000);
            //  clif_message(bl, timer);
            //}
            if ((sce->val4 -= 500) > 0) {
                sc_timer_next(500 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_MARIONETTE:
        case SC_MARIONETTE2: {
                struct block_list *pbl = map_id2bl(sce->val1);
                if (pbl && check_distance_bl(bl, pbl, 7)) {
                    sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                    return 0;
                }
            }
            break;

        case SC_GOSPEL:
            if (sce->val4 == BCT_SELF && --(sce->val2) > 0) {
                int hp, sp;
                hp = (sce->val1 > 5) ? 45 : 30;
                sp = (sce->val1 > 5) ? 35 : 20;
                if (!status_charge(bl, hp, sp))
                    break;
                sc_timer_next(10000+tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_JAILED:
            if (sce->val1 == INT_MAX || --(sce->val1) > 0) {
                sc_timer_next(60000+tick, status_change_timer, bl->id,data);
                return 0;
            }
            break;

        case SC_BLIND:
            if (sc->data[SC_FOGWALL]) {
                //Blind lasts forever while you are standing on the fog.
                sc_timer_next(5000+tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;
        case SC_ABUNDANCE:
            if (--(sce->val4) > 0) {
                status_heal(bl,0,60,0);
                sc_timer_next(10000+tick, status_change_timer, bl->id, data);
            }
            break;

        case SC_PYREXIA:
            if (--(sce->val4) >= 0) {
                map_freeblock_lock();
                clif_damage(bl,bl,tick,status_get_amotion(bl),status_get_dmotion(bl)+500,100,0,0,0);
                status_fix_damage(NULL,bl,100,0);
                if (sc->data[type]) {
                    sc_timer_next(3000+tick,status_change_timer,bl->id,data);
                }
                map_freeblock_unlock();
                return 0;
            }
            break;

        case SC_LEECHESEND:
            if (--(sce->val4) >= 0) {
                int damage = status->max_hp/100; // {Target VIT x (New Poison Research Skill Level - 3)} + (Target HP/100)
                damage += status->vit * (sce->val1 - 3);
                unit_skillcastcancel(bl,2);
                map_freeblock_lock();
                status_damage(bl, bl, damage, 0, clif_damage(bl,bl,tick,status_get_amotion(bl),status_get_dmotion(bl)+500,damage,1,0,0), 1);
                if (sc->data[type]) {
                    sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                }
                map_freeblock_unlock();
                return 0;
            }
            break;

        case SC_MAGICMUSHROOM:
            if (--(sce->val4) >= 0) {
                bool flag = 0;
                int damage = status->max_hp * 3 / 100;
                if (status->hp <= damage)
                    damage = status->hp - 1; // Cannot Kill

                if (damage > 0) {  // 3% Damage each 4 seconds
                    map_freeblock_lock();
                    status_zap(bl,damage,0);
                    flag = !sc->data[type]; // Killed? Should not
                    map_freeblock_unlock();
                }

                if (!flag) {  // Random Skill Cast
                    if (sd && !pc_issit(sd)) { //can't cast if sit
                        int mushroom_skillid = 0, i;
                        unit_stop_attack(bl);
                        unit_skillcastcancel(bl,1);
                        do {
                            i = rnd() % MAX_SKILL_MAGICMUSHROOM_DB;
                            mushroom_skillid = skill_magicmushroom_db[i].skillid;
                        } while (mushroom_skillid == 0);

                        switch (skill_get_casttype(mushroom_skillid)) {  // Magic Mushroom skills are buffs or area damage
                            case CAST_GROUND:
                                skill_castend_pos2(bl,bl->x,bl->y,mushroom_skillid,1,tick,0);
                                break;
                            case CAST_NODAMAGE:
                                skill_castend_nodamage_id(bl,bl,mushroom_skillid,1,tick,0);
                                break;
                            case CAST_DAMAGE:
                                skill_castend_damage_id(bl,bl,mushroom_skillid,1,tick,0);
                                break;
                        }
                    }

                    clif_emotion(bl,E_HEH);
                    sc_timer_next(4000+tick,status_change_timer,bl->id,data);
                }
                return 0;
            }
            break;

        case SC_TOXIN:
            if (--(sce->val4) >= 0) {
                //Damage is every 10 seconds including 3%sp drain.
                map_freeblock_lock();
                clif_damage(bl,bl,tick,status_get_amotion(bl),1,1,0,0,0);
                status_damage(NULL, bl, 1, status->max_sp * 3 / 100, 0, 0); //cancel dmg only if cancelable
                if (sc->data[type]) {
                    sc_timer_next(10000 + tick, status_change_timer, bl->id, data);
                }
                map_freeblock_unlock();
                return 0;
            }
            break;

        case SC_OBLIVIONCURSE:
            if (--(sce->val4) >= 0) {
                clif_emotion(bl,E_WHAT);
                sc_timer_next(3000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_WEAPONBLOCKING:
            if (--(sce->val4) >= 0) {
                if (!status_charge(bl,0,3))
                    break;
                sc_timer_next(3000+tick,status_change_timer,bl->id,data);
                return 0;
            }
            break;

        case SC_CLOAKINGEXCEED:
            if (!status_charge(bl,0,10-sce->val1))
                break;
            sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
            return 0;

        case SC_RENOVATIO:
            if (--(sce->val4) >= 0) {
                int heal = status->max_hp * 3 / 100;
                if (sc && sc->data[SC_AKAITSUKI] && heal)
                    heal = ~heal + 1;
                status_heal(bl, heal, 0, 2);
                sc_timer_next(5000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_BURNING:
            if (--(sce->val4) >= 0) {
                struct block_list *src = map_id2bl(sce->val3);
                int damage = 1000 + 3 * status_get_max_hp(bl) / 100; // Deals fixed (1000 + 3%*MaxHP)

                map_freeblock_lock();
                clif_damage(bl,bl,tick,0,0,damage,1,9,0); //damage is like endure effect with no walk delay
                status_damage(src, bl, damage, 0, 0, 1);

                if (sc->data[type]) { // Target still lives. [LimitLine]
                    sc_timer_next(2000 + tick, status_change_timer, bl->id, data);
                }
                map_freeblock_unlock();
                return 0;
            }
            break;

        case SC_FEAR:
            if (--(sce->val4) >= 0) {
                if (sce->val2 > 0)
                    sce->val2--;
                sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_SPHERE_1:
        case SC_SPHERE_2:
        case SC_SPHERE_3:
        case SC_SPHERE_4:
        case SC_SPHERE_5:
            if (--(sce->val4) >= 0) {
                if (!status_charge(bl, 0, 1))
                    break;
                sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_READING_SB:
            if (!status_charge(bl, 0, sce->val2)) {
                int i;
                for (i = SC_SPELLBOOK1; i <= SC_MAXSPELLBOOK; i++) // Also remove stored spell as well.
                    status_change_end(bl, (sc_type)i, INVALID_TIMER);
                break;
            }
            sc_timer_next(5000 + tick, status_change_timer, bl->id, data);
            return 0;

        case SC_ELECTRICSHOCKER:
            if (--(sce->val4) >= 0) {
                status_charge(bl, 0, status->max_sp / 100 * sce->val1);
                sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_CAMOUFLAGE:
            if (--(sce->val4) > 0) {
                status_charge(bl,0,7 - sce->val1);
                sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC__REPRODUCE:
            if (!status_charge(bl, 0, 1))
                break;
            sc_timer_next(1000+tick, status_change_timer, bl->id, data);
            return 0;

        case SC__SHADOWFORM:
            if (--(sce->val4) >= 0) {
                if (!status_charge(bl, 0, sce->val1 - (sce->val1 - 1)))
                    break;
                sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC__INVISIBILITY:
            if (--(sce->val4) >= 0) {
                if (!status_charge(bl, 0, (status->sp * 6 - sce->val1) / 100)) // 6% - skilllv.
                    break;
                sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_STRIKING:
            if (--(sce->val4) >= 0) {
                if (!status_charge(bl,0, sce->val1))
                    break;
                sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;
        case SC_VACUUM_EXTREME:
            if (--(sce->val4) >= 0) {
                if (!unit_is_walking(bl) && !sce->val2) {
                    sc->cant.move++;
                    sce->val2 = 1;
                }
                sc_timer_next(100 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;
        case SC_BLOODSUCKER:
            if (--(sce->val4) >= 0) {
                struct block_list *src = map_id2bl(sce->val2);
                int damage;
                if (!src || (src && (status_isdead(src) || src->m != bl->m || distance_bl(src, bl) >= 12)))
                    break;
                map_freeblock_lock();
                damage =  200 + 100 * sce->val1 + status_get_int(src);
                status_damage(src, bl, damage, 0, clif_damage(bl,bl,tick,status->amotion,status->dmotion+200,damage,1,0,0), 1);
                unit_skillcastcancel(bl,1);
                if (sc->data[type]) {
                    sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                }
                map_freeblock_unlock();
                status_heal(src, damage*(5 + 5 * sce->val1)/100, 0, 0); // 5 + 5% per level
                return 0;
            }
            break;

        case SC_VOICEOFSIREN:
            if (--(sce->val4) >= 0) {
                clif_emotion(bl,E_LV);
                sc_timer_next(2000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_DEEPSLEEP:
            if (--(sce->val4) >= 0) {
                // Recovers 1% HP/SP every 2 seconds.
                status_heal(bl, status->max_hp / 100, status->max_sp / 100, 2);
                sc_timer_next(2000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_SIRCLEOFNATURE:
            if (--(sce->val4) >= 0) {
                if (!status_charge(bl,0,sce->val2))
                    break;
                status_heal(bl, sce->val3, 0, 1);
                sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_SONGOFMANA:
            if (--(sce->val4) >= 0) {
                status_heal(bl,0,sce->val3,3);
                sc_timer_next(3000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;


        case SC_SATURDAYNIGHTFEVER:
            // 1% HP/SP drain every val4 seconds [Jobbie]
            if (--(sce->val3) >= 0) {
                int hp = status->hp / 100;
                int sp = status->sp / 100;
                if (!status_charge(bl, hp, sp))
                    break;
                sc_timer_next(sce->val4+tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_CRYSTALIZE:
            if (--(sce->val4) >= 0) {
                // Drains 2% of HP and 1% of SP every seconds.
                if (bl->type != BL_MOB) // doesn't work on mobs
                    status_charge(bl, status->max_hp * 2 / 100, status->max_sp / 100);
                sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_FORCEOFVANGUARD:
            if (!status_charge(bl,0,20))
                break;
            sc_timer_next(6000 + tick, status_change_timer, bl->id, data);
            return 0;

        case SC_BANDING:
            if (status_charge(bl, 0, 7 - sce->val1)) {
                if (sd) pc_banding(sd, sce->val1);
                sc_timer_next(5000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_REFLECTDAMAGE:
            if (--(sce->val4) >= 0) {
                if (!status_charge(bl,0,sce->val3))
                    break;
                sc_timer_next(10000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_OVERHEAT_LIMITPOINT:
            if (--(sce->val1) > 0) {  // Cooling
                sc_timer_next(30000 + tick, status_change_timer, bl->id, data);
            }
            break;

        case SC_OVERHEAT: {
                int damage = status->max_hp / 100; // Suggestion 1% each second
                if (damage >= status->hp) damage = status->hp - 1;  // Do not kill, just keep you with 1 hp minimum
                map_freeblock_lock();
                status_fix_damage(NULL,bl,damage,clif_damage(bl,bl,tick,0,0,damage,0,0,0));
                if (sc->data[type]) {
                    sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                }
                map_freeblock_unlock();
            }
            break;

        case SC_MAGNETICFIELD: {
                if (--(sce->val3) <= 0)
                    break; // Time out
                if (sce->val2 == bl->id) {
                    if (!status_charge(bl,0,14 + (3 * sce->val1)))
                        break; // No more SP status should end, and in the next second will end for the other affected players
                } else {
                    struct block_list *src = map_id2bl(sce->val2);
                    struct status_change *ssc;
                    if (!src || (ssc = status_get_sc(src)) == NULL || !ssc->data[SC_MAGNETICFIELD])
                        break; // Source no more under Magnetic Field
                }
                sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
            }
            break;

        case SC_INSPIRATION:
            if (--(sce->val4) >= 0) {
                int hp = status->max_hp * (7-sce->val1) / 100;
                int sp = status->max_sp * (9-sce->val1) / 100;

                if (!status_charge(bl,hp,sp)) break;

                sc_timer_next(1000+tick,status_change_timer,bl->id, data);
                return 0;
            }
            break;

        case SC_RAISINGDRAGON:
            // 1% every 5 seconds [Jobbie]
            if (--(sce->val3)>0 && status_charge(bl, sce->val2, 0)) {
                if (!sc->data[type]) return 0;
                sc_timer_next(5000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;

        case SC_CIRCLE_OF_FIRE:
        case SC_FIRE_CLOAK:
        case SC_WATER_DROP:
        case SC_WATER_SCREEN:
        case SC_WIND_CURTAIN:
        case SC_WIND_STEP:
        case SC_STONE_SHIELD:
        case SC_SOLID_SKIN:
            if (!status_charge(bl,0,sce->val2)) {
                struct block_list *s_bl = battle_get_master(bl);
                if (s_bl)
                    status_change_end(s_bl,type+1,INVALID_TIMER);
                status_change_end(bl,type,INVALID_TIMER);
                break;
            }
            sc_timer_next(2000 + tick, status_change_timer, bl->id, data);
            return 0;

        case SC_STOMACHACHE:
            if (--(sce->val4) > 0) {
                status_charge(bl,0,sce->val2);  // Reduce 8 every 10 seconds.
                if (sd && !pc_issit(sd)) {   // Force to sit every 10 seconds.
                    pc_stop_walking(sd,1|4);
                    pc_stop_attack(sd);
                    pc_setsit(sd);
                    clif_sitting(bl);
                }
                sc_timer_next(10000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;
        case SC_LEADERSHIP:
        case SC_GLORYWOUNDS:
        case SC_SOULCOLD:
        case SC_HAWKEYES:
            /* they only end by status_change_end */
            sc_timer_next(600000 + tick, status_change_timer, bl->id, data);
            return 0;
        case SC_MEIKYOUSISUI:
            if (--(sce->val4) > 0) {
                status_heal(bl, status->max_hp * (sce->val1+1) / 100, status->max_sp * sce->val1 / 100, 0);
                sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;
        case SC_IZAYOI:
        case SC_KAGEMUSYA:
            if (--(sce->val2) > 0) {
                if (!status_charge(bl, 0, 1)) break;
                sc_timer_next(1000+tick, status_change_timer, bl->id, data);
                return 0;
            }
            break;
        case SC_ANGRIFFS_MODUS:
            if (--(sce->val4) >= 0) { //drain hp/sp
                if (!status_charge(bl,100,20)) break;
                sc_timer_next(1000+tick,status_change_timer,bl->id, data);
                return 0;
            }
            break;
    }

    // default for all non-handled control paths is to end the status
    return status_change_end(bl,type,tid);
#undef sc_timer_next
}

/*==========================================
 * Foreach iteration of repetitive status
 *------------------------------------------*/
int status_change_timer_sub(struct block_list *bl, va_list ap)
{
    struct status_change *tsc;

    struct block_list *src = va_arg(ap,struct block_list *);
    struct status_change_entry *sce = va_arg(ap,struct status_change_entry *);
    enum sc_type type = (sc_type)va_arg(ap,int); //gcc: enum args get promoted to int
    unsigned int tick = va_arg(ap,unsigned int);

    if (status_isdead(bl))
        return 0;

    tsc = status_get_sc(bl);

    switch (type) {
        case SC_SIGHT: /* Reveal hidden ennemy on 3*3 range */
            if (tsc && tsc->data[SC__SHADOWFORM] && (sce && sce->val4 >0 && sce->val4%2000 == 0) && // for every 2 seconds do the checking
                rnd()%100 < 100-tsc->data[SC__SHADOWFORM]->val1*10)  // [100 - (Skill Level x 10)] %
                status_change_end(bl, SC__SHADOWFORM, INVALID_TIMER);
        case SC_CONCENTRATE:
            status_change_end(bl, SC_HIDING, INVALID_TIMER);
            status_change_end(bl, SC_CLOAKING, INVALID_TIMER);
            status_change_end(bl, SC_CLOAKINGEXCEED, INVALID_TIMER);
            status_change_end(bl, SC_CAMOUFLAGE, INVALID_TIMER);
            status_change_end(bl, SC__INVISIBILITY, INVALID_TIMER);
            break;
        case SC_RUWACH: /* Reveal hidden target and deal little dammages if ennemy */
            if (tsc && (tsc->data[SC_HIDING] || tsc->data[SC_CLOAKING] ||
                        tsc->data[SC_CAMOUFLAGE] || tsc->data[SC_CLOAKINGEXCEED] ||
                        tsc->data[SC__INVISIBILITY])) {
                status_change_end(bl, SC_HIDING, INVALID_TIMER);
                status_change_end(bl, SC_CLOAKING, INVALID_TIMER);
                status_change_end(bl, SC_CAMOUFLAGE, INVALID_TIMER);
                status_change_end(bl, SC_CLOAKINGEXCEED, INVALID_TIMER);
                status_change_end(bl, SC__INVISIBILITY, INVALID_TIMER);
                if (battle_check_target(src, bl, BCT_ENEMY) > 0)
                    skill_attack(BF_MAGIC,src,src,bl,AL_RUWACH,1,tick,0);
            }
            if (tsc && tsc->data[SC__SHADOWFORM] && (sce && sce->val4 >0 && sce->val4%2000 == 0) && // for every 2 seconds do the checking
                rnd()%100 < 100-tsc->data[SC__SHADOWFORM]->val1*10)  // [100 - (Skill Level x 10)] %
                status_change_end(bl, SC__SHADOWFORM, INVALID_TIMER);
            break;
        case SC_SIGHTBLASTER:
            if (battle_check_target(src, bl, BCT_ENEMY) > 0 &&
                status_check_skilluse(src, bl, WZ_SIGHTBLASTER, 2)) {
                skill_attack(BF_MAGIC,src,src,bl,WZ_SIGHTBLASTER,1,tick,0);
                if (sce) sce->val2 = 0; //This signals it to end.
            }
            break;
        case SC_CLOSECONFINE:
            //Lock char has released the hold on everyone...
            if (tsc && tsc->data[SC_CLOSECONFINE2] && tsc->data[SC_CLOSECONFINE2]->val2 == src->id) {
                tsc->data[SC_CLOSECONFINE2]->val2 = 0;
                status_change_end(bl, SC_CLOSECONFINE2, INVALID_TIMER);
            }
            break;
        case SC_CURSEDCIRCLE_TARGET:
            if (tsc && tsc->data[SC_CURSEDCIRCLE_TARGET] && tsc->data[SC_CURSEDCIRCLE_TARGET]->val2 == src->id) {
                clif_bladestop(bl, tsc->data[SC_CURSEDCIRCLE_TARGET]->val2, 0);
                status_change_end(bl, type, INVALID_TIMER);
            }
            break;
    }
    return 0;
}

/*==========================================
 * Clears buffs/debuffs of a character.
 * type&1 -> buffs, type&2 -> debuffs
 * type&4 -> especific debuffs(implemented with refresh)
 *------------------------------------------*/
int status_change_clear_buffs(struct block_list *bl, int type)
{
    int i;
    struct status_change *sc= status_get_sc(bl);

    if (!sc || !sc->count)
        return 0;

    if (type&6) //Debuffs
        for (i = SC_COMMON_MIN; i <= SC_COMMON_MAX; i++)
            status_change_end(bl, (sc_type)i, INVALID_TIMER);

    for (i = SC_COMMON_MAX+1; i < SC_MAX; i++) {
        if (!sc->data[i])
            continue;

        switch (i) {
                //Stuff that cannot be removed
            case SC_WEIGHT50:
            case SC_WEIGHT90:
            case SC_COMBO:
            case SC_SMA:
            case SC_DANCING:
            case SC_LEADERSHIP:
            case SC_GLORYWOUNDS:
            case SC_SOULCOLD:
            case SC_HAWKEYES:
            case SC_GUILDAURA:
            case SC_SAFETYWALL:
            case SC_PNEUMA:
            case SC_NOCHAT:
            case SC_JAILED:
            case SC_ANKLE:
            case SC_BLADESTOP:
            case SC_CP_WEAPON:
            case SC_CP_SHIELD:
            case SC_CP_ARMOR:
            case SC_CP_HELM:
            case SC_STRFOOD:
            case SC_AGIFOOD:
            case SC_VITFOOD:
            case SC_INTFOOD:
            case SC_DEXFOOD:
            case SC_LUKFOOD:
            case SC_HITFOOD:
            case SC_FLEEFOOD:
            case SC_BATKFOOD:
            case SC_WATKFOOD:
            case SC_MATKFOOD:
            case SC_FOOD_STR_CASH:
            case SC_FOOD_AGI_CASH:
            case SC_FOOD_VIT_CASH:
            case SC_FOOD_DEX_CASH:
            case SC_FOOD_INT_CASH:
            case SC_FOOD_LUK_CASH:
            case SC_EXPBOOST:
            case SC_JEXPBOOST:
            case SC_ITEMBOOST:
            case SC_ELECTRICSHOCKER:
            case SC__MANHOLE:
            case SC_GIANTGROWTH:
            case SC_MILLENNIUMSHIELD:
            case SC_REFRESH:
            case SC_STONEHARDSKIN:
            case SC_VITALITYACTIVATION:
            case SC_FIGHTINGSPIRIT:
            case SC_ABUNDANCE:
            case SC_CURSEDCIRCLE_ATKER:
            case SC_CURSEDCIRCLE_TARGET:
                continue;

            //Debuffs that can be removed.
			case SC_DEEPSLEEP:
			case SC_BURNING:
			case SC_FREEZING:
			case SC_CRYSTALIZE:
			case SC_TOXIN:
			case SC_PARALYSE:
			case SC_VENOMBLEED:
			case SC_MAGICMUSHROOM:
			case SC_DEATHHURT:
			case SC_PYREXIA:
			case SC_OBLIVIONCURSE:
			case SC_LEECHESEND:
			case SC_MARSHOFABYSS:
			case SC_MANDRAGORA:
				if(!(type&4))
					continue;
				break;
			case SC_HALLUCINATION:
            case SC_QUAGMIRE:
			case SC_SIGNUMCRUCIS:
            case SC_DECREASEAGI:
            case SC_SLOWDOWN:
            case SC_MINDBREAKER:
            case SC_WINKCHARM:
            case SC_STOP:
            case SC_ORCISH:
            case SC_STRIPWEAPON:
            case SC_STRIPSHIELD:
            case SC_STRIPARMOR:
            case SC_STRIPHELM:
            case SC_BITE:
            case SC_ADORAMUS:
            case SC_VACUUM_EXTREME:
            case SC_FEAR:
            case SC_MAGNETICFIELD:
            case SC_NETHERWORLD:
                if (!(type&2))
                    continue;
                break;
                //The rest are buffs that can be removed.
            case SC__BLOODYLUST:
            case SC_BERSERK:
            case SC_SATURDAYNIGHTFEVER:
                if (!(type&1))
                    continue;
                sc->data[i]->val2 = 0;
                break;
            default:
                if (!(type&1))
                    continue;
                break;
        }
        status_change_end(bl, (sc_type)i, INVALID_TIMER);
    }
    return 0;
}

int status_change_spread(struct block_list *src, struct block_list *bl)
{
    int i, flag = 0;
    struct status_change *sc = status_get_sc(src);
    const struct TimerData *timer;
    unsigned int tick;
    struct status_change_data data;

    if (!sc || !sc->count)
        return 0;

    tick = gettick();

    for (i = SC_COMMON_MIN; i < SC_MAX; i++) {
        if (!sc->data[i] || i == SC_COMMON_MAX)
            continue;

        switch (i) {
                //Debuffs that can be spreaded.
                // NOTE: We'll add/delte SCs when we are able to confirm it.
            case SC_CURSE:
            case SC_SILENCE:
            case SC_CONFUSION:
            case SC_BLIND:
            case SC_NOCHAT:
            case SC_HALLUCINATION:
            case SC_SIGNUMCRUCIS:
            case SC_DECREASEAGI:
            case SC_SLOWDOWN:
            case SC_MINDBREAKER:
            case SC_WINKCHARM:
            case SC_STOP:
            case SC_ORCISH:
                //case SC_STRIPWEAPON://Omg I got infected and had the urge to strip myself physically.
                //case SC_STRIPSHIELD://No this is stupid and shouldnt be spreadable at all.
                //case SC_STRIPARMOR:// Disabled until I can confirm if it does or not. [Rytech]
                //case SC_STRIPHELM:
                //case SC__STRIPACCESSORY:
            case SC_BITE:
            case SC_FREEZING:
            case SC_VENOMBLEED:
            case SC_DEATHHURT:
            case SC_PARALYSE:
                if (sc->data[i]->timer != INVALID_TIMER) {
                    timer = get_timer(sc->data[i]->timer);
                    if (timer == NULL || timer->func != status_change_timer || DIFF_TICK(timer->tick,tick) < 0)
                        continue;
                    data.tick = DIFF_TICK(timer->tick,tick);
                } else
                    data.tick = INVALID_TIMER;
                break;
                // Special cases
            case SC_POISON:
            case SC_DPOISON:
                data.tick = sc->data[i]->val3 * 1000;
                break;
            case SC_FEAR:
            case SC_LEECHESEND:
                data.tick = sc->data[i]->val4 * 1000;
                break;
            case SC_BURNING:
                data.tick = sc->data[i]->val4 * 2000;
                break;
            case SC_PYREXIA:
            case SC_OBLIVIONCURSE:
                data.tick = sc->data[i]->val4 * 3000;
                break;
            case SC_MAGICMUSHROOM:
                data.tick = sc->data[i]->val4 * 4000;
                break;
            case SC_TOXIN:
            case SC_BLEEDING:
                data.tick = sc->data[i]->val4 * 10000;
                break;
            default:
                continue;
                break;
        }
        if (i) {
            data.val1 = sc->data[i]->val1;
            data.val2 = sc->data[i]->val2;
            data.val3 = sc->data[i]->val3;
            data.val4 = sc->data[i]->val4;
            status_change_start(bl,(sc_type)i,10000,data.val1,data.val2,data.val3,data.val4,data.tick,1|2|8);
            flag = 1;
        }
    }

    return flag;
}

//Natural regen related stuff.
static unsigned int natural_heal_prev_tick,natural_heal_diff_tick;
static int status_natural_heal(struct block_list *bl, va_list args)
{
    struct regen_data *regen;
    struct status_data *status;
    struct status_change *sc;
    struct unit_data *ud;
    struct view_data *vd = NULL;
    struct regen_data_sub *sregen;
    struct map_session_data *sd;
    int val,rate,bonus = 0,flag;

    regen = status_get_regen_data(bl);
    if (!regen) return 0;
    status = status_get_status_data(bl);
    sc = status_get_sc(bl);
    if (sc && !sc->count)
        sc = NULL;
    sd = BL_CAST(BL_PC,bl);

    flag = regen->flag;
    if (flag&RGN_HP && (status->hp >= status->max_hp || regen->state.block&1))
        flag&=~(RGN_HP|RGN_SHP);
    if (flag&RGN_SP && (status->sp >= status->max_sp || regen->state.block&2))
        flag&=~(RGN_SP|RGN_SSP);

    if (flag && (
            status_isdead(bl) ||
            (sc && (sc->option&(OPTION_HIDE|OPTION_CLOAK|OPTION_CHASEWALK) || sc->data[SC__INVISIBILITY]))
        ))
        flag=0;

    if (sd) {
        if (sd->hp_loss.value || sd->sp_loss.value)
            pc_bleeding(sd, natural_heal_diff_tick);
        if (sd->hp_regen.value || sd->sp_regen.value)
            pc_regen(sd, natural_heal_diff_tick);
    }

    if (flag&(RGN_SHP|RGN_SSP) && regen->ssregen &&
        (vd = status_get_viewdata(bl)) && vd->dead_sit == 2) {
        //Apply sitting regen bonus.
        sregen = regen->ssregen;
        if (flag&(RGN_SHP)) {
            //Sitting HP regen
            val = natural_heal_diff_tick * sregen->rate.hp;
            if (regen->state.overweight)
                val>>=1; //Half as fast when overweight.
            sregen->tick.hp += val;
            while (sregen->tick.hp >= (unsigned int)battle_config.natural_heal_skill_interval) {
                sregen->tick.hp -= battle_config.natural_heal_skill_interval;
                if (status_heal(bl, sregen->hp, 0, 3) < sregen->hp) {
                    //Full
                    flag&=~(RGN_HP|RGN_SHP);
                    break;
                }
            }
        }
        if (flag&(RGN_SSP)) {
            //Sitting SP regen
            val = natural_heal_diff_tick * sregen->rate.sp;
            if (regen->state.overweight)
                val>>=1; //Half as fast when overweight.
            sregen->tick.sp += val;
            while (sregen->tick.sp >= (unsigned int)battle_config.natural_heal_skill_interval) {
                sregen->tick.sp -= battle_config.natural_heal_skill_interval;
                if (status_heal(bl, 0, sregen->sp, 3) < sregen->sp) {
                    //Full
                    flag&=~(RGN_SP|RGN_SSP);
                    break;
                }
            }
        }
    }

    if (flag && regen->state.overweight)
        flag=0;

    ud = unit_bl2ud(bl);

    if (flag&(RGN_HP|RGN_SHP|RGN_SSP) && ud && ud->walktimer != INVALID_TIMER) {
        flag&=~(RGN_SHP|RGN_SSP);
        if (!regen->state.walk)
            flag&=~RGN_HP;
    }

    if (!flag)
        return 0;

    if (flag&(RGN_HP|RGN_SP)) {
        if (!vd) vd = status_get_viewdata(bl);
        if (vd && vd->dead_sit == 2)
            bonus++;
        if (regen->state.gc)
            bonus++;
    }

    //Natural Hp regen
    if (flag&RGN_HP) {
        rate = natural_heal_diff_tick*(regen->rate.hp+bonus);
        if (ud && ud->walktimer != INVALID_TIMER)
            rate/=2;
        // Homun HP regen fix (they should regen as if they were sitting (twice as fast)
        if (bl->type==BL_HOM) rate *=2;

        regen->tick.hp += rate;

        if (regen->tick.hp >= (unsigned int)battle_config.natural_healhp_interval) {
            val = 0;
            do {
                val += regen->hp;
                regen->tick.hp -= battle_config.natural_healhp_interval;
            } while (regen->tick.hp >= (unsigned int)battle_config.natural_healhp_interval);
            if (status_heal(bl, val, 0, 1) < val)
                flag&=~RGN_SHP; //full.
        }
    }

    //Natural SP regen
    if (flag&RGN_SP) {
        rate = natural_heal_diff_tick*(regen->rate.sp+bonus);
        // Homun SP regen fix (they should regen as if they were sitting (twice as fast)
        if (bl->type==BL_HOM) rate *=2;

        regen->tick.sp += rate;

        if (regen->tick.sp >= (unsigned int)battle_config.natural_healsp_interval) {
            val = 0;
            do {
                val += regen->sp;
                regen->tick.sp -= battle_config.natural_healsp_interval;
            } while (regen->tick.sp >= (unsigned int)battle_config.natural_healsp_interval);
            if (status_heal(bl, 0, val, 1) < val)
                flag&=~RGN_SSP; //full.
        }
    }

    if (!regen->sregen)
        return flag;

    //Skill regen
    sregen = regen->sregen;

    if (flag&RGN_SHP) {
        //Skill HP regen
        sregen->tick.hp += natural_heal_diff_tick * sregen->rate.hp;

        while (sregen->tick.hp >= (unsigned int)battle_config.natural_heal_skill_interval) {
            sregen->tick.hp -= battle_config.natural_heal_skill_interval;
            if (status_heal(bl, sregen->hp, 0, 3) < sregen->hp)
                break; //Full
        }
    }
    if (flag&RGN_SSP) {
        //Skill SP regen
        sregen->tick.sp += natural_heal_diff_tick * sregen->rate.sp;
        while (sregen->tick.sp >= (unsigned int)battle_config.natural_heal_skill_interval) {
            val = sregen->sp;
            if (sd && sd->state.doridori) {
                val*=2;
                sd->state.doridori = 0;
                if ((rate = pc_checkskill(sd,TK_SPTIME)))
                    sc_start(bl,status_skill2sc(TK_SPTIME),
                             100,rate,skill_get_time(TK_SPTIME, rate));
                if (
                    (sd->class_&MAPID_UPPERMASK) == MAPID_STAR_GLADIATOR &&
                    rnd()%10000 < battle_config.sg_angel_skill_ratio
                ) { //Angel of the Sun/Moon/Star
                    clif_feel_hate_reset(sd);
                    pc_resethate(sd);
                    pc_resetfeel(sd);
                }
            }
            sregen->tick.sp -= battle_config.natural_heal_skill_interval;
            if (status_heal(bl, 0, val, 3) < val)
                break; //Full
        }
    }
    return flag;
}

//Natural heal main timer.
static int status_natural_heal_timer(int tid, unsigned int tick, int id, intptr_t data)
{
    natural_heal_diff_tick = DIFF_TICK(tick,natural_heal_prev_tick);
    map_foreachregen(status_natural_heal);
    natural_heal_prev_tick = tick;
    return 0;
}

/**
 * Get the chance to upgrade a piece of equipment.
 * @param wlv The weapon type of the item to refine (see see enum refine_type)
 * @param refine The target refine level
 * @return The chance to refine the item, in percent (0~100)
 **/
int status_get_refine_chance(enum refine_type wlv, int refine)
{

    if (refine < 0 || refine >= MAX_REFINE)
        return 0;

    return refine_info[wlv].chance[refine];
}


/*------------------------------------------
 * DB reading.
 * job_db1.txt    - weight, hp, sp, aspd
 * job_db2.txt    - job level stat bonuses
 * size_fix.txt   - size adjustment table for weapons
 * refine_db.txt  - refining data table
 *------------------------------------------*/
static bool status_readdb_job1(char *fields[], int columns, int current)
{
    // Job-specific values (weight, HP, SP, ASPD)
    int idx, class_;
    unsigned int i;

    class_ = atoi(fields[0]);

    if (!pcdb_checkid(class_)) {
        ShowWarning("status_readdb_job1: Invalid job class %d specified.\n", class_);
        return false;
    }
    idx = pc_class2idx(class_);

    max_weight_base[idx] = atoi(fields[1]);
    hp_coefficient[idx]  = atoi(fields[2]);
    hp_coefficient2[idx] = atoi(fields[3]);
    sp_coefficient[idx]  = atoi(fields[4]);
#ifdef RENEWAL_ASPD
    for (i = 0; i <= MAX_WEAPON_TYPE; i++)
#else
    for (i = 0; i < MAX_WEAPON_TYPE; i++)
#endif
    {
        aspd_base[idx][i] = atoi(fields[i+5]);
    }
    return true;
}

static bool status_readdb_job2(char *fields[], int columns, int current)
{
    int idx, class_, i;

    class_ = atoi(fields[0]);

    if (!pcdb_checkid(class_)) {
        ShowWarning("status_readdb_job2: Invalid job class %d specified.\n", class_);
        return false;
    }
    idx = pc_class2idx(class_);

    for (i = 1; i < columns; i++) {
        job_bonus[idx][i-1] = atoi(fields[i]);
    }
    return true;
}

static bool status_readdb_sizefix(char *fields[], int columns, int current)
{
    unsigned int i;

    for (i = 0; i < MAX_WEAPON_TYPE; i++) {
        atkmods[current][i] = atoi(fields[i]);
    }
    return true;
}

static bool status_readdb_refine(char *fields[], int columns, int current)
{
    int i, bonus_per_level, random_bonus, random_bonus_start_level;

    current = atoi(fields[0]);

    if (current < 0 || current >= REFINE_TYPE_MAX)
        return false;

    bonus_per_level = atoi(fields[1]);
    random_bonus_start_level = atoi(fields[2]);
    random_bonus = atoi(fields[3]);

    for (i = 0; i < MAX_REFINE; i++) {
        char *delim;

        if (!(delim = strchr(fields[4+i], ':')))
            return false;

        *delim = '\0';

        refine_info[current].chance[i] = atoi(fields[4+i]);

        if (i >= random_bonus_start_level - 1)
            refine_info[current].randombonus_max[i] = random_bonus * (i - random_bonus_start_level + 2);

        refine_info[current].bonus[i] = bonus_per_level + atoi(delim+1);
        if (i > 0)
            refine_info[current].bonus[i] += refine_info[current].bonus[i-1];
    }
    return true;
}

/*
* Read status db
* job1.txt
* job2.txt
* size_fixe.txt
* refine_db.txt
*/
int status_readdb(void)
{
    int i, j;

    // initialize databases to default
    //

    // reset job_db1.txt data
    memset(max_weight_base, 0, sizeof(max_weight_base));
    memset(hp_coefficient, 0, sizeof(hp_coefficient));
    memset(hp_coefficient2, 0, sizeof(hp_coefficient2));
    memset(sp_coefficient, 0, sizeof(sp_coefficient));
    memset(aspd_base, 0, sizeof(aspd_base));
    // reset job_db2.txt data
    memset(job_bonus,0,sizeof(job_bonus)); // Job-specific stats bonus

    // size_fix.txt
    for (i=0; i<ARRAYLENGTH(atkmods); i++)
        for (j=0; j<MAX_WEAPON_TYPE; j++)
            atkmods[i][j]=100;

    // refine_db.txt
    for (i=0; i<ARRAYLENGTH(refine_info); i++) {
        for (j=0; j<MAX_REFINE; j++) {
            refine_info[i].chance[j] = 100;
            refine_info[i].bonus[j] = 0;
            refine_info[i].randombonus_max[j] = 0;
        }
    }

    // read databases
    //


#ifdef RENEWAL_ASPD
    sv_readdb(db_path, "re/job_db1.txt",   ',', 6+MAX_WEAPON_TYPE, 6+MAX_WEAPON_TYPE,   -1,     &status_readdb_job1);
#else
    sv_readdb(db_path, "pre-re/job_db1.txt",   ',', 5+MAX_WEAPON_TYPE, 5+MAX_WEAPON_TYPE,   -1,     &status_readdb_job1);
#endif
    sv_readdb(db_path, "job_db2.txt",   ',', 1,                 1+MAX_LEVEL,       -1,                            &status_readdb_job2);
    sv_readdb(db_path, "size_fix.txt",  ',', MAX_WEAPON_TYPE,   MAX_WEAPON_TYPE,    ARRAYLENGTH(atkmods),         &status_readdb_sizefix);
    sv_readdb(db_path, DBPATH"refine_db.txt", ',', 4+MAX_REFINE, 4+MAX_REFINE, ARRAYLENGTH(refine_info), &status_readdb_refine);

    return 0;
}

/*==========================================
 * Status db init and destroy.
 *------------------------------------------*/
int do_init_status(void)
{
    add_timer_func_list(status_change_timer,"status_change_timer");
    add_timer_func_list(kaahi_heal_timer,"kaahi_heal_timer");
    add_timer_func_list(status_natural_heal_timer,"status_natural_heal_timer");
    initChangeTables();
    initDummyData();
    status_readdb();
    status_calc_sigma();
    natural_heal_prev_tick = gettick();
    sc_data_ers = ers_new(sizeof(struct status_change_entry),"status.c::sc_data_ers",ERS_OPT_NONE);
    add_timer_interval(natural_heal_prev_tick + NATURAL_HEAL_INTERVAL, status_natural_heal_timer, 0, 0, NATURAL_HEAL_INTERVAL);
    return 0;
}
void do_final_status(void)
{
    ers_destroy(sc_data_ers);
}