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