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