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