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