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