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