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