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