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