API tools faq
paste
Ameisen

Untitled

Ameisen
Jul 13th, 2022
1,565
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 10.37 KB | None | 0 0
raw download clone embed print report
  1. long SumProductArrayIndex(int[] array0, int[] array1) {
  2.     long sum = 0;
  3.     for (int i = 0; i < array0.Length; ++i) {
  4.         sum += array0[i] * array1[i];
  5.     }
  6.     return sum;
  7. }
  8.  
  9. long SumProductArrayIndexRef1(int[] array0, int[] array1) {
  10.     long sum = 0;
  11.     ref int ref1 = ref MemoryMarshal.GetArrayDataReference(array1);
  12.     for (int i = 0; i < array0.Length; ++i) {
  13.         sum += array0[i] * Unsafe.Add(ref ref1, i);;
  14.     }
  15.     return sum;
  16. }
  17.  
  18. long SumProductSpanIndex(ReadOnlySpan<int> span0, ReadOnlySpan<int> span1) {
  19.     long sum = 0;
  20.     for (int i = 0; i < span0.Length; ++i) {
  21.         sum += span0[i] * span1[i];
  22.     }
  23.     return sum;
  24. }
  25.  
  26. long SumProductSpanIndexRef1(ReadOnlySpan<int> span0, ReadOnlySpan<int> span1) {
  27.     long sum = 0;
  28.     ref int ref1 = ref MemoryMarshal.GetReference(span1);
  29.     for (int i = 0; i < span0.Length; ++i) {
  30.         sum += span0[i] * Unsafe.Add(ref ref1, i);
  31.     }
  32.     return sum;
  33. }
  34.  
  35. long SumProductFixedIncrement(int[] array0, int[] array1) {
  36.     long sum = 0;
  37.     fixed (int* vp0 = array0) {
  38.         fixed (int* vp1 = array1) {
  39.             int* vpp0 = vp0;
  40.             int* vpp1 = vp1;
  41.             int len = array0.Length;
  42.             for (int i = 0; i < len; ++i) {
  43.                 sum += *vpp0 * *vpp1;
  44.                 ++vpp0;
  45.                 ++vpp1;
  46.             }
  47.         }
  48.     }
  49.     return sum;
  50. }
  51.  
  52. long SumProductFixedIndex(int[] array0, int[] array1) {
  53.     long sum = 0;
  54.     fixed (int* vp0 = array0) {
  55.         fixed (int* vp1 = array1) {
  56.             int len = array0.Length;
  57.             for (int i = 0; i < len; ++i) {
  58.                 sum += vp0[i] + vp1[i];
  59.             }
  60.         }
  61.     }
  62.     return sum;
  63. }
  64.  
  65. long SumProductPtrIncrement(int* ptr0, int* ptr1, int length) {
  66.     long sum = 0;
  67.     int* vpp0 = ptr0;
  68.     int* vpp1 = ptr1;
  69.     for (int i = 0; i < length; ++i) {
  70.         sum += *vpp0 * *vpp1;
  71.         ++vpp0;
  72.         ++vpp1;
  73.     }
  74.     return sum;
  75. }
  76.  
  77. long SumProductPtrIndex(int* ptr0, int* ptr1, int length) {
  78.     long sum = 0;
  79.     int* vpp0 = ptr0;
  80.     int* vpp1 = ptr1;
  81.     for (int i = 0; i < length; ++i) {
  82.         sum += vpp0[i] + vpp1[i];
  83.     }
  84.     return sum;
  85. }
  86.  
  87. long SumProductRefIncrement(int[] array0, int[] array1) {
  88.     long sum = 0;
  89.     ref int vr0 = ref MemoryMarshal.GetArrayDataReference(array0);
  90.     ref int vr1 = ref MemoryMarshal.GetArrayDataReference(array1);
  91.     int length = array0.Length;
  92.     for (int i = 0; i < length; ++i) {
  93.         sum += vr0 * vr1;
  94.         vr0 = ref Unsafe.Add(ref vr0, 1);
  95.         vr1 = ref Unsafe.Add(ref vr1, 1);
  96.     }
  97.     return sum;
  98. }
  99.  
  100. long SumProductRefIndex(int[] array0, int[] array1) {
  101.     long sum = 0;
  102.     ref int vr0 = ref MemoryMarshal.GetArrayDataReference(array0);
  103.     ref int vr1 = ref MemoryMarshal.GetArrayDataReference(array1);
  104.     int length = array0.Length;
  105.     for (int i = 0; i < length; ++i) {
  106.         sum += Unsafe.Add(ref vr0, i) * Unsafe.Add(ref vr1, i);
  107.     }
  108.     return sum;
  109. }
  110.  
  111. long SumProductSpanRefIncrement(ReadOnlySpan<int> span0, ReadOnlySpan<int> span1) {
  112.     long sum = 0;
  113.     ref int vr0 = ref MemoryMarshal.GetReference(span0);
  114.     ref int vr1 = ref MemoryMarshal.GetReference(span1);
  115.     int length = span0.Length;
  116.     for (int i = 0; i < length; ++i) {
  117.         sum += vr0 * vr1;
  118.         vr0 = ref Unsafe.Add(ref vr0, 1);
  119.         vr1 = ref Unsafe.Add(ref vr1, 1);
  120.     }
  121.     return sum;
  122. }
  123.  
  124. long SumProductSpanRefIndex(ReadOnlySpan<int> span0, ReadOnlySpan<int> span1) {
  125.     long sum = 0;
  126.     ref int vr0 = ref MemoryMarshal.GetReference(span0);
  127.     ref int vr1 = ref MemoryMarshal.GetReference(span1);
  128.     int length = span0.Length;
  129.     for (int i = 0; i < length; ++i) {
  130.         sum += Unsafe.Add(ref vr0, i) * Unsafe.Add(ref vr1, i);
  131.     }
  132.     return sum;
  133. }
  134.  
  135. ---
  136.  
  137. SumProductArrayIndex|4_0 (Int32[], Int32[])
  138. L0000   sub rsp, 0x28
  139. L0004   xor eax, eax
  140. L0006   xor r8d, r8d
  141. L0009   mov r9d, [rcx+8]
  142. L000d   test    r9d, r9d
  143. L0010   jle short L006c
  144. L0012   test    rdx, rdx
  145. L0015   setne   r10b
  146. L0019   movzx   r10d, r10b
  147. L001d   test    r10b, 1
  148. L0021   je  short L004a
  149. L0023   cmp [rdx+8], r9d
  150. L0027   jl  short L004a
  151. L0029   movsxd  r10, r8d
  152. L002c   mov r11d, [rcx+r10*4+0x10]
  153. L0031   imul    r11d, [rdx+r10*4+0x10]
  154. L0037   movsxd  r10, r11d
  155. L003a   add r10, rax
  156. L003d   mov rax, r10
  157. L0040   inc r8d
  158. L0043   cmp r9d, r8d
  159. L0046   jg  short L0029
  160. L0048   jmp short L006c
  161. L004a   movsxd  r10, r8d
  162. L004d   mov r11d, [rcx+r10*4+0x10]
  163. L0052   cmp r8d, [rdx+8]
  164. L0056   jae short L0071
  165. L0058   imul    r11d, [rdx+r10*4+0x10]
  166. L005e   movsxd  r10, r11d
  167. L0061   add rax, r10
  168. L0064   inc r8d
  169. L0067   cmp r9d, r8d
  170. L006a   jg  short L004a
  171. L006c   add rsp, 0x28
  172. L0070   ret
  173. L0071   call    0x00007ffdbff0abc0
  174. L0076   int3   
  175.  
  176. SumProductArrayIndexRef1|4_1 (Int32[], Int32[])
  177. L0000   xor eax, eax
  178. L0002   cmp [rdx], edx
  179. L0004   add rdx, 0x10
  180. L0008   xor r8d, r8d
  181. L000b   mov r9d, [rcx+8]
  182. L000f   test    r9d, r9d
  183. L0012   jle short L002f
  184. L0014   movsxd  r10, r8d
  185. L0017   mov r11d, [rcx+r10*4+0x10]
  186. L001c   imul    r11d, [rdx+r10*4]
  187. L0021   movsxd  r10, r11d
  188. L0024   add rax, r10
  189. L0027   inc r8d
  190. L002a   cmp r9d, r8d
  191. L002d   jg  short L0014
  192. L002f   ret
  193.  
  194. SumProductSpanIndex|4_2 (ReadOnlySpan <Int32>, ReadOnlySpan <Int32>)
  195. L0000   push    rsi
  196. L0001   sub rsp, 0x20
  197. L0005   mov r8, [rcx]
  198. L0008   mov ecx, [rcx+8]
  199. L000b   xor eax, eax
  200. L000d   xor r9d, r9d
  201. L0010   test    ecx, ecx
  202. L0012   jle short L003a
  203. L0014   mov r10d, [rdx+8]
  204. L0018   mov rdx, [rdx]
  205. L001b   movsxd  r11, r9d
  206. L001e   mov esi, [r8+r11*4]
  207. L0022   cmp r9d, r10d
  208. L0025   jae short L0040
  209. L0027   imul    esi, [rdx+r11*4]
  210. L002c   movsxd  r11, esi
  211. L002f   add rax, r11
  212. L0032   inc r9d
  213. L0035   cmp r9d, ecx
  214. L0038   jl  short L001b
  215. L003a   add rsp, 0x20
  216. L003e   pop rsi
  217. L003f   ret
  218. L0040   call    0x00007ffdbff0abc0
  219. L0045   int3   
  220.  
  221. SumProductSpanIndexRef1|4_3 (ReadOnlySpan <Int32>, ReadOnlySpan <Int32>)
  222. L0000   mov rax, [rcx]
  223. L0003   mov ecx, [rcx+8]
  224. L0006   xor r8d, r8d
  225. L0009   mov rdx, [rdx]
  226. L000c   xor r9d, r9d
  227. L000f   test    ecx, ecx
  228. L0011   jle short L002d
  229. L0013   movsxd  r10, r9d
  230. L0016   mov r11d, [rax+r10*4]
  231. L001a   imul    r11d, [rdx+r10*4]
  232. L001f   movsxd  r10, r11d
  233. L0022   add r8, r10
  234. L0025   inc r9d
  235. L0028   cmp r9d, ecx
  236. L002b   jl  short L0013
  237. L002d   mov rax, r8
  238. L0030   ret
  239.  
  240. SumProductFixedIncrement|4_4 (Int32[], Int32[])
  241. L0000   sub rsp, 0x38
  242. L0004   xor eax, eax
  243. L0006   mov [rsp+0x30], rax
  244. L000b   mov [rsp+0x28], rax
  245. L0010   xor eax, eax
  246. L0012   mov [rsp+0x30], rcx
  247. L0017   test    rcx, rcx
  248. L001a   je  short L0028
  249. L001c   mov r8, [rsp+0x30]
  250. L0021   cmp dword ptr [r8+8], 0
  251. L0026   jne short L002d
  252. L0028   xor r8d, r8d
  253. L002b   jmp short L0042
  254. L002d   mov r8, [rsp+0x30]
  255. L0032   cmp dword ptr [r8+8], 0
  256. L0037   jbe short L00a7
  257. L0039   mov r8, [rsp+0x30]
  258. L003e   add r8, 0x10
  259. L0042   mov [rsp+0x28], rdx
  260. L0047   test    rdx, rdx
  261. L004a   je  short L0057
  262. L004c   mov rdx, [rsp+0x28]
  263. L0051   cmp dword ptr [rdx+8], 0
  264. L0055   jne short L005b
  265. L0057   xor edx, edx
  266. L0059   jmp short L006f
  267. L005b   mov rdx, [rsp+0x28]
  268. L0060   cmp dword ptr [rdx+8], 0
  269. L0064   jbe short L00a7
  270. L0066   mov rdx, [rsp+0x28]
  271. L006b   add rdx, 0x10
  272. L006f   mov ecx, [rcx+8]
  273. L0072   xor r9d, r9d
  274. L0075   test    ecx, ecx
  275. L0077   jle short L0096
  276. L0079   mov r10d, [r8]
  277. L007c   imul    r10d, [rdx]
  278. L0080   movsxd  r10, r10d
  279. L0083   add rax, r10
  280. L0086   add r8, 4
  281. L008a   add rdx, 4
  282. L008e   inc r9d
  283. L0091   cmp r9d, ecx
  284. L0094   jl  short L0079
  285. L0096   xor edx, edx
  286. L0098   mov [rsp+0x28], rdx
  287. L009d   mov [rsp+0x30], rdx
  288. L00a2   add rsp, 0x38
  289. L00a6   ret
  290. L00a7   call    0x00007ffdbff0abc0
  291. L00ac   int3   
  292.  
  293. SumProductFixedIndex|4_5 (Int32[], Int32[])
  294. L0000   sub rsp, 0x38
  295. L0004   xor eax, eax
  296. L0006   mov [rsp+0x30], rax
  297. L000b   mov [rsp+0x28], rax
  298. L0010   xor eax, eax
  299. L0012   mov [rsp+0x30], rcx
  300. L0017   test    rcx, rcx
  301. L001a   je  short L0028
  302. L001c   mov r8, [rsp+0x30]
  303. L0021   cmp dword ptr [r8+8], 0
  304. L0026   jne short L002d
  305. L0028   xor r8d, r8d
  306. L002b   jmp short L0042
  307. L002d   mov r8, [rsp+0x30]
  308. L0032   cmp dword ptr [r8+8], 0
  309. L0037   jbe short L00a3
  310. L0039   mov r8, [rsp+0x30]
  311. L003e   add r8, 0x10
  312. L0042   mov [rsp+0x28], rdx
  313. L0047   test    rdx, rdx
  314. L004a   je  short L0057
  315. L004c   mov rdx, [rsp+0x28]
  316. L0051   cmp dword ptr [rdx+8], 0
  317. L0055   jne short L005b
  318. L0057   xor edx, edx
  319. L0059   jmp short L006f
  320. L005b   mov rdx, [rsp+0x28]
  321. L0060   cmp dword ptr [rdx+8], 0
  322. L0064   jbe short L00a3
  323. L0066   mov rdx, [rsp+0x28]
  324. L006b   add rdx, 0x10
  325. L006f   mov ecx, [rcx+8]
  326. L0072   xor r9d, r9d
  327. L0075   test    ecx, ecx
  328. L0077   jle short L0092
  329. L0079   movsxd  r10, r9d
  330. L007c   mov r11d, [r8+r10*4]
  331. L0080   add r11d, [rdx+r10*4]
  332. L0084   movsxd  r10, r11d
  333. L0087   add rax, r10
  334. L008a   inc r9d
  335. L008d   cmp r9d, ecx
  336. L0090   jl  short L0079
  337. L0092   xor edx, edx
  338. L0094   mov [rsp+0x28], rdx
  339. L0099   mov [rsp+0x30], rdx
  340. L009e   add rsp, 0x38
  341. L00a2   ret
  342. L00a3   call    0x00007ffdbff0abc0
  343. L00a8   int3   
  344.  
  345. SumProductPtrIncrement|4_6 (Int32*, Int32*, Int32)
  346. L0000   xor eax, eax
  347. L0002   xor r9d, r9d
  348. L0005   test    r8d, r8d
  349. L0008   jle short L0027
  350. L000a   mov r10d, [rcx]
  351. L000d   imul    r10d, [rdx]
  352. L0011   movsxd  r10, r10d
  353. L0014   add rax, r10
  354. L0017   add rcx, 4
  355. L001b   add rdx, 4
  356. L001f   inc r9d
  357. L0022   cmp r9d, r8d
  358. L0025   jl  short L000a
  359. L0027   ret
  360.  
  361. SumProductPtrIndex|4_7 (Int32*, Int32*, Int32)
  362. L0000   xor eax, eax
  363. L0002   xor r9d, r9d
  364. L0005   test    r8d, r8d
  365. L0008   jle short L0023
  366. L000a   movsxd  r10, r9d
  367. L000d   mov r11d, [rcx+r10*4]
  368. L0011   add r11d, [rdx+r10*4]
  369. L0015   movsxd  r10, r11d
  370. L0018   add rax, r10
  371. L001b   inc r9d
  372. L001e   cmp r9d, r8d
  373. L0021   jl  short L000a
  374. L0023   ret
  375.  
  376. SumProductRefIncrement|4_8 (Int32[], Int32[])
  377. L0000   xor eax, eax
  378. L0002   cmp [rcx], ecx
  379. L0004   lea r8, [rcx+0x10]
  380. L0008   cmp [rdx], edx
  381. L000a   add rdx, 0x10
  382. L000e   mov ecx, [rcx+8]
  383. L0011   xor r9d, r9d
  384. L0014   test    ecx, ecx
  385. L0016   jle short L0035
  386. L0018   mov r10d, [r8]
  387. L001b   imul    r10d, [rdx]
  388. L001f   movsxd  r10, r10d
  389. L0022   add rax, r10
  390. L0025   add r8, 4
  391. L0029   add rdx, 4
  392. L002d   inc r9d
  393. L0030   cmp r9d, ecx
  394. L0033   jl  short L0018
  395. L0035   ret
  396.  
  397. SumProductRefIndex|4_9 (Int32[], Int32[])
  398. L0000   xor eax, eax
  399. L0002   cmp [rcx], ecx
  400. L0004   lea r8, [rcx+0x10]
  401. L0008   cmp [rdx], edx
  402. L000a   add rdx, 0x10
  403. L000e   mov ecx, [rcx+8]
  404. L0011   xor r9d, r9d
  405. L0014   test    ecx, ecx
  406. L0016   jle short L0032
  407. L0018   movsxd  r10, r9d
  408. L001b   mov r11d, [r8+r10*4]
  409. L001f   imul    r11d, [rdx+r10*4]
  410. L0024   movsxd  r10, r11d
  411. L0027   add rax, r10
  412. L002a   inc r9d
  413. L002d   cmp r9d, ecx
  414. L0030   jl  short L0018
  415. L0032   ret
  416.  
  417. SumProductSpanRefIncrement|4_10 (ReadOnlySpan <Int32>, ReadOnlySpan <Int32>)
  418. L0000   xor eax, eax
  419. L0002   mov r8, [rcx]
  420. L0005   mov rdx, [rdx]
  421. L0008   mov ecx, [rcx+8]
  422. L000b   xor r9d, r9d
  423. L000e   test    ecx, ecx
  424. L0010   jle short L002f
  425. L0012   mov r10d, [r8]
  426. L0015   imul    r10d, [rdx]
  427. L0019   movsxd  r10, r10d
  428. L001c   add rax, r10
  429. L001f   add r8, 4
  430. L0023   add rdx, 4
  431. L0027   inc r9d
  432. L002a   cmp r9d, ecx
  433. L002d   jl  short L0012
  434. L002f   ret
  435.  
  436. SumProductSpanRefIndex|4_11 (ReadOnlySpan <Int32>, ReadOnlySpan <Int32>)
  437. L0000   xor eax, eax
  438. L0002   mov r8, [rcx]
  439. L0005   mov rdx, [rdx]
  440. L0008   mov ecx, [rcx+8]
  441. L000b   xor r9d, r9d
  442. L000e   test    ecx, ecx
  443. L0010   jle short L002c
  444. L0012   movsxd  r10, r9d
  445. L0015   mov r11d, [r8+r10*4]
  446. L0019   imul    r11d, [rdx+r10*4]
  447. L001e   movsxd  r10, r11d
  448. L0021   add rax, r10
  449. L0024   inc r9d
  450. L0027   cmp r9d, ecx
  451. L002a   jl  short L0012
  452. L002c   ret
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!