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