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