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