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