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