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