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