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