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