CRYPTO NEWS

This unknown play to earn games could have significant potential

Play to earn is by far one of the most exciting new frontiers in crypto. After the massive success of Axie Infinity, newer more exciting projects in play to earn are steadily coming out. But why would you even consider this niche? Here are some reasons:

  • Play-to-earn games are now combining NFTs as part of the process.

  • The rise of augmented and virtual reality could make a play to earn games bigger.

  • A lot of institutional investors are also checking out P2E games as future investments.

Well, for those of you looking for small and relatively unknown P2E games in crypto, the list below should be ideal:

Thetan Arena (THG)

Thetan Arena (THG) calls itself an eSport-based game that combines multiplayer functionality and virtual reality. It allows users to form teams and battle other teams for in-game rewards.

Thetan Arena has so far managed to attract over 23 million users. It also remains significantly undervalued, with a market cap of less than $30 million.

Pegaxy (PGX)

Pegaxy (PGX) is a small and relatively under-the-radar play-to-earn game that allows players to earn and create real value from the game. The blockchain game is free to play and largely involves mech horse racing within a metaverse. 

Pegaxy uses a dual token system. On the one hand, there is the PGX which is the main governance token for the platform. There is however another in-game utility token called VIS. As of now, Pegaxy has a market cap of less than $3 million.

Alien Worlds (TLM)

Alien Worlds (TLM) is more of an NFT-powered metaverse that includes a P2E gaming element. The platform allows users to earn NFT rewards as they compete in a simulated virtual economy through various planetary worlds. So far, the project has seen its market cap rise above $50 million, and more growth could still come in the future.

The post This unknown play to earn games could have significant potential appeared first on Coin Journal.

Carry-less Karatsuba with PCLMULQDQ – mistake

I’m trying to implement Carry-less Karatsuba with PCLMULQDQ instructions from here (Algorithm 2, page 12): https://www.intel.cn/content/dam/www/public/us/en/documents/white-papers/carry-less-multiplication-instruction-in-gcm-mode-paper.pdf I learned how to use PCLMULQDQ from here: https://wunkolo.github.io/post/2020/05/pclmulqdq-tricks/ #include <cstdint> #include <cstdio> #include <bitset> #include <immintrin.h> #include<iostream> __int128 carry_less_karatsuba(__int128 a1_a0, __int128 b1_b0) { __m128i c1_c0 = _mm_clmulepi64_si128(_mm_set_epi64x(0, (uint64_t)(a1_a0>>64)), _mm_set_epi64x(0, (uint64_t)(b1_b0 >> 64)),0); __m128i d1_d0 = _mm_clmulepi64_si128(_mm_set_epi64x(0, (uint64_t)(a1_a0)), _mm_set_epi64x(0,::Listen

I’m trying to implement Carry-less Karatsuba with PCLMULQDQ instructions from here (Algorithm 2, page 12):

https://www.intel.cn/content/dam/www/public/us/en/documents/white-papers/carry-less-multiplication-instruction-in-gcm-mode-paper.pdf

I learned how to use PCLMULQDQ from here:

https://wunkolo.github.io/post/2020/05/pclmulqdq-tricks/

#include <cstdint>
#include <cstdio>
#include <bitset>
#include <immintrin.h>
#include<iostream>


__int128 carry_less_karatsuba(__int128 a1_a0, __int128 b1_b0)
{
    __m128i c1_c0 = _mm_clmulepi64_si128(_mm_set_epi64x(0, (uint64_t)(a1_a0>>64)), _mm_set_epi64x(0, (uint64_t)(b1_b0 >> 64)),0);
    __m128i d1_d0 = _mm_clmulepi64_si128(_mm_set_epi64x(0, (uint64_t)(a1_a0)), _mm_set_epi64x(0, (uint64_t)(b1_b0)),0);
    __m128i e1_e0 = _mm_clmulepi64_si128(_mm_set_epi64x(0, ((uint64_t)(a1_a0))^((uint64_t)(a1_a0 >> 64))), _mm_set_epi64x(0, ((uint64_t)(b1_b0)) ^ ((uint64_t)(b1_b0 >> 64))), 0);

    __int128 x3 = _mm_extract_epi64(c1_c0, 1);
    __int128 x2 = _mm_cvtsi128_si64(c1_c0) ^ _mm_extract_epi64(c1_c0, 1) ^ _mm_extract_epi64(d1_d0, 1) ^ _mm_extract_epi64(e1_e0, 1);
    __int128 x1 = _mm_extract_epi64(d1_d0, 1) ^ _mm_cvtsi128_si64(c1_c0) ^ _mm_cvtsi128_si64(d1_d0) ^ _mm_cvtsi128_si64(e1_e0);
    __int128 x0 = _mm_cvtsi128_si64(d1_d0);


    return x2;
}


int main()
{
    __int128 result = 0;

        result = carry_less_karatsuba(331755698128909410983678231014631813416,293755568177669651454576723109054048987);
        
    return 0;
}

But it gives me wrong results. $x2$ is always zero, but multiplication of two 128-bit numbers should give 256-bit numbers. There shouldn’t be all zeros. Maybe I’m using PCLMULQDQ wrong? Or there is mistake in my code? Or mistake in algorithm itself?

This unknown play to earn games could have significant potential

Shopping cart
There are no products in the cart!
Continue shopping
0