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