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