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