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