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