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