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