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