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