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