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