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