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